Controla tu Robot con Ondas Cerebrales: Proyecto Arduino Completo

Componentes y materiales

Arduino UNO – 1 ud. (robot)
Arduino Mega 2560 – 1 ud. (cerebro principal)
Arduino Leonardo – 1 ud. (controlador ratón)
Particle Photon – 1 ud. (servidor web / data logger)
Necomimi Brainwave Cat Ears (sensor EEG) – 1 ud.
Driver motor dual H-Bridge L298 (SparkFun) – 1 ud.
Módulo relé – 1 ud.
Módulo Bluetooth HC-05 – 1 ud.
Módulo Bluetooth HC-06 – 1 ud.
LED genérico – 3 uds.
Resistencia 330 Ω – 3 uds.
Transistor NPN propósito general – 3 uds.
Cables jumper macho/hembra – 1 ud.
Cables jumper genéricos – 1 ud.
Protoboard media – 1 ud.

Herramientas necesarias

Soldador genérico

Software y servicios online

Brain Visualizer (solo para experimentos)

Sobre el proyecto

De niño siempre quise una habilidad especial: mover objetos con la mente o volar. Intentaba mover cosas con «el poder de mi mente», sin éxito. Sí, fui y soy fan de Star Wars, pero también me gustan la electrónica y la programación, ¿por qué no combinarlas para construir un proyecto increíble?

Controla tu Robot con Ondas Cerebrales: Proyecto Arduino Completo

El concepto principal: usando diferentes ondas cerebrales, el usuario controla un robot, el ratón del PC o enciende/apaga luces en casa, mientras un microcontrolador (Particle Photon) crea un análisis online de las ondas cerebrales. Método perfecto para detectar enfermedades, estrés o somnolencia. También ayuda a vivir mejor, aprender a controlar emociones y ser más feliz. El cerebro necesita equilibrio; con Particle Photon y su dashboard web ayudamos a encontrar ese equilibrio natural. Un sueño infantil me guió a este proyecto y estoy muy contento de haberlo logrado.

Pero dejando a un lado Star Wars y la Fuerza, este dispositivo no es solo para fans o perezosos: devuelve capacidades a personas que luchan diariamente con discapacidad. El robot funciona como una silla de ruedas; la domótica permite controlar luces/TV aunque no puedas moverte; el control de ratón sirve incluso a gente sana. Todos queremos jugar o navegar solo con pensamientos.

Mira este vídeo introductorio sobre la historia del proyecto:

¿Te gustaría construir el tuyo? Aquí explico todo: comparto códigos, esquemas e instrucciones detalladas. ¡Calienta el soldador!

La ciencia detrás del proyecto

La electroencefalografía (EEG) registra la actividad eléctrica cerebral. Es no invasiva, con electrodos en el cuero cabelludo. Mide fluctuaciones de voltaje por corrientes iónicas en neuronas. Las aplicaciones diagnósticas se centran en el contenido espectral (oscilaciones neurales o «ondas cerebrales»). Usamos dos valores precisos:

Alfa (7–14 Hz): aparece al cerrar ojos y relajarse; atenúa al abrirlos o esfuerzo mental.
Beta (15–30 Hz): amplitud baja, frecuencias variables → pensamiento activo, ansioso, concentración.

Cómo funciona

Usé 4 microcontroladores: Arduino Mega (cerebro principal, recibe señales del casco, analiza y reenvía comandos), Arduino Leonardo (controla ratón PC), Arduino UNO (recibe IR y controla robot), Particle Photon (servidor web). El dispositivo alterna entre 3 «canales» cerrando los ojos:

Cerrar ojos 1–2 s → domótica
Cerrar ojos 2–4 s → control robot
Cerrar ojos 4–6 s → control ratón

Los relés permiten conectar cualquier aparato: TV, bombillas, enchufes.

El casco inalámbrico

Me encanta hackear juguetes. Compré Necomimi, un juguete que mueve orejas según ondas cerebrales (atención, meditación). Inútil como juguete, pero dentro lleva un chip NeuroSky TGAM que lee ondas, filtra ruido y da buena señal. Interfaz UART (Serie), así que con hacking podemos leer ondas con Arduino. El casco transmite ondas vía Bluetooth al servidor central. Nadie quiere cables en la cabeza: creé este casco cómodo y amigable.

Ver abajo cómo desmontar y convertir en casco Bluetooth.

Cómo usarlo

Tenemos dos valores eSense (NeuroSky): meditación (0–100) y atención (0–100). Más concentrado → atención alta. Más relajado → meditación alta.

El sistema funciona con pensamientos; solo hay que aprender a concentrarse o relajarse. Tras una semana logré controlar mi atención con precisión: puedo fijarla conscientemente en ~15, 39, 65, 90. Cada persona es distinta. Funciona bien con emociones: amor, amistad, ira, miedo dan buen contraste.

Para encender: conectar micro USB al Arduino Leonardo (también controla ratón y da 5 V/500 mA al sistema).

Control domótico

En modo domótica: atención >70 → relé 1; meditación >70 → relé 2; ambas >70 → relé 3. Mismo comando apaga si ya está encendido. Requiere entrenamiento mental, pero es posible. Conecta cualquier dispositivo de alta tensión a los relés.

Control ratón

Cursor controlado por emociones: atención <25 → izquierda; 25–50 → derecha; 50–75 → arriba; 75–100 → abajo. Click subiendo meditación. La atención se controla bien con emociones (en mi caso).

Control robot

Robot tiene 3 estados: parar, girar izquierda, avanzar. ¿Por qué solo dos movimientos? Porque basta para ir a cualquier sitio. Usa meditación para girar; cuando apuntas a la dirección deseada, paras y usas atención para avanzar. Mejor método, incluso para principiantes.

Mi plan

Imagen antigua de mi plan, pero funcionó. El casco transmite BT al Arduino Mega que analiza bytes y controla funciones según pensamientos. Fue difícil encontrar la mejor forma de transmitir tantos datos; elegí Bluetooth sobre WiFi. Al principio quise usar Particle Photon como transmisor, pero acabó teniendo mejor papel como servidor web. Esa fue la mayor modificación. Usé módulos Arduino caseros porque me gusta diseñar mis circuitos. Puedes comprarlos o construirte los tuyos conmigo.

Medio año de aprendizaje y experimentación

Trabajé casi medio año en esto; con el Photon se aceleró. Su dashboard es muy fácil. Hay tutoriales para hackear juguetes EEG, pero no tenían funciones extra. Decidí hackear Necomimi y, con creatividad, crear un dispositivo con muchas más funciones que parpadear un LED. ¡Espero que lo disfrutes!

¡Empecemos!

Hackear el juguete Necomimi

Queremos modificar este juguete EEG para transmitir datos por Bluetooth. Primero abre la carcasa: tornillos bajo la pegatina. Quita la pegatina y la tapa trasera. Dentro hay un pequeño circuito; el que está debajo es el chip NeuroSky TGAM, conectado con 4 pines header al microcontrolador principal. Desolda ese circuito con cuidado. Suelda 3 cables a GND, VCC y pin T (transmisor, 57600 baudios). Conecté el pin T directamente a un módulo HC-06 esclavo BT. El HC-06 viene a 9600 baudios, pero lo arreglaremos. Si soldaste los 3 cables, integra tu propia fuente recargable. Usé batería Li-Ion 500 mAh, circuito cargador USB, step-up 5 V y dos resistencias (100 Ω y 200 Ω) para obtener 3,4 V estables para chip y Bluetooth. Sigue el esquema para el circuito del casco. Si el circuito está listo, configura el módulo Bluetooth.

Sobre el chip

El NeuroSky ThinkGear AM filtra, amplifica y envía datos por serie. Más info aquí.

Esquemático / Electrónica

Sigue las instrucciones e imágenes para crear tu propio casco EEG inalámbrico.

Necesitas: batería Li-Ion 500 mAh, step-up 5 V, resistencias 100 Ω y 200 Ω para bajar a 3,3 V estables. Soldé headers hembra para alimentar y transmitir al módulo Bluetooth.

Lo más importante: conectar pin «T» del chip con pin «RX» del módulo Bluetooth. Eso da vida al proyecto.

Configurar módulos Bluetooth

HC-06 (esclavo en casco)

Subir sketch «HC_06_Bluetooth» a Arduino UNO.
Conectar HC-06 como muestra esquema (encontrado en web Artronix).
Abrir Monitor Serie y esperar a que configure el módulo.

void setup() {
  Serial.begin(9600);
  delay(1000);
  Serial.print("AT");
  delay(1000);
  Serial.print("AT+VERSION");
  delay(1000);
  Serial.print("AT+PIN"); // quitar password
  delay(1000);
  Serial.print("AT+BAUD7"); // 57600 baudios (Necomimi default)
  delay(1000);
  Serial.begin(57600);
}
void loop() {}

Ahora tu Bluetooth está a 57600 baudios. El casco hackeado será compatible con todas las apps NeuroSky.

Apps recomendadas (PC, iOS, Android):

HC-05 (maestro en servidor)

Subir sketch «HC_05_Bluetooth» a Arduino UNO (mismo método).
Conectar pin EN del HC-05 a 3,3 V del Arduino.
Escribir dirección MAC de tu HC-06 en el código. Obtenerla con smartphone Android. Reemplazar «:» por «,» en el código.
Cambiar dirección en código: 20:15:09:15:17:82 → 2015,09,151782 (dejar algunos «:» que no son necesarios).

void setup() {
  Serial.begin(9600);
  delay(1000);
  Serial.print("AT");
  delay(1000);
  Serial.print("AT+VERSION");
  delay(1000);
  Serial.println("AT+ROLE=1"); // maestro
  delay(1000);
  Serial.println("AT+LINK=tu_direccion_aqui"); // conexión automática
  delay(1000);
  Serial.print("AT+UART=57600,1,0"); // 57600 baudios
  Serial.begin(57600);
}
void loop() {}

Ambos módulos deberían conectar automáticamente. Si hay problemas, consulta este enlace.

Robot controlado por IR

Robot barato usando tecnología IR 38 kHz (mandos TV). Compré chasis en Amazon. Receptor IR recuperado de TV vieja. Arduino también de Amazon. Enlaces en sección Hardware.

Circuito driver motor

Piezas:

2 bornas tornillo
IC L293D
3 pines header
9 pines header 90°
Resistencia 1 kΩ
LED rojo
Cables
Placa PCB

Usé hilos de cobre y siguiendo el esquema conecté pines del IC a headers. No importa qué pin va a qué header, solo recuerda las conexiones. LED en serie con resistencia y en paralelo con VCC 5 V.

Montar chasis

Fácil: destornillador y maña, listo en 5 min. Luego viene lo difícil: construir driver motor. Elegí L293D (controla 2 motores). Ver esquema para construir circuito.

Conectar a Arduino UNO

Cables jumper para sensor y driver.

Arduino Pin → Motor Driver (L293D)
4 → 15
5 → 10
6 → 7
7 → 2
VIN → 8
5V → 1, 9, 16
GND → 4, 5, 13, 12

Mira el esquema del L293D y conecta sus pines al UNO como arriba. El pin 5V del Arduino a pines 1,9,16 habilita el driver. Bornas tornillo para alimentar motores.

Código robot

Usando librería IRremote, creé código que lee señales IR 38 kHz, decodifica y mueve robot. (Descargar librería en sección Código).

El código tiene explicaciones: decodifica IR del servidor principal y mueve motores según orden. Descargar «Robot_Code». Subir a tu Arduino y robot listo.

Servidor principal (Arduino Mega, Leonardo, Photon)

Lee paquetes de datos del casco inalámbrico. Usa módulo BT configurado para conexión casco-servidor. Arduino Mega es el cerebro: todo conectado a él (Bluetooth, LED IR transmisor, servidor web, controlador ratón). Código complejo pero comentado.

Carcasa

Simple pero resultona: dos placas 18×15 cm, lijar bordes, unir con tornillos.

Circuito relés

Piezas:

Transistor 2N2222 (3 uds.)
Diodos germanio (3 uds.)
Resistencias 330 Ω (3 uds.)
Resistencias 1 kΩ (3 uds.)
Relés 5 V (3 uds.)
Cables, headers, PCB

Una imagen vale más que mil palabras: mira el esquema. Si pin «Signal» recibe señal del Arduino, relé activa. Transistor amplifica para dar potencia a relés. Pines 37, 38, 39 controlan cada relé.

Instalar en carcasa

Cinta doble cara blanca para fijar circuitos a metacrilato: queda limpio y sujeta fuerte.

Circuitría del servidor

Basado en software, circuito sencillo. (Ver esquema abajo). Alimentar microcontroladores y conectarlos entre sí. LED IR en pin D3, relés en 37-38-39. D16 Mega → RX Photon, D18 Mega → RX Leonardo.

Conexión con robot

LEDs IR en pin D3, librería IRremote envía códigos al robot. Los códigos IR deben coincidir con los del robot. Truco: mira con cámara; luz IR se ve púrpura.

Código servidor (Arduino Mega)

Usar código «Arduino_Mega_Server» en sección Software.

Costó mucho programar 3 microcontroladores. Usé librerías IRremote, Brain, SoftwareSerial, Mouse (ver enlaces descarga en sección Software). Ahora está listo: sube a tus microcontroladores. Código para Particle Photon se sube vía IDE web (Particle Build). Registrarse, conectar Photon, añadir Device ID. Sorprendentemente automático.

Antes de subir códigos: desconectar todo de pines RX/TX (Bluetooth del Mega, Mega-Leonardo, Mega-Photon).

Controlador ratón (Arduino Leonardo)

Sube código «Mouse Controller Code» a Leonardo. Mueve cursor según señales serie del Mega.

Servidor web (Particle Photon)

Quise añadir función IoT: data logger online con Particle Photon. Crea servidor personal y escribe datos en la nube según uso del dispositivo.

Puede parecer asustador, pero imagina detectar estrés (atención sube/baja rápido) o necesidad de dormir (meditación >80 constante). Este servidor web ayuda a vivir más sano.

Particle tiene dashboard online donde publicar datos con Particle.publish(). Gracias a sus desarrolladores por ahorrarnos tiempo.

Escribir código en navegador fue curioso, pero funciona igual que IDE normal. Subida inalámbrica. Este microcontrolador es herramienta muy útil.

Versión simplificada: solo robot controlado por mente

¿No quieres montar todo el proyecto, solo un robot mental? No te preocupes, pensé en principiantes. Código con explicaciones para Arduino Mini Pro (o UNO) + LED IR + casco. Fin de semana divertido y simple.

Usar código «RobotControllerHeadset» en sección Software. Conectar LED IR a pin D3 del Mini Pro (o UNO) y pin T del chip NeuroSky a RX del Arduino. Alimentar 3,3 V o 5 V. Construir robot y usar este código en el casco:

#include <IRremote.h>
#include <IRremoteInt.h>
#include <Brain.h>

IRsend irsend;
Brain brain(Serial);
const int ledPin = 3;
long interval = 500;
long previousMillis = 0;
int ledState = LOW;
int medValue;

void setup() {
  pinMode(ledPin, OUTPUT);
  Serial.begin(57600);
}

void loop() {
  if (brain.update()) {
    Serial.println(brain.readCSV());
    medValue = brain.readMeditation();
  }
  if (brain.readSignalQuality() == 0) {
    if (medValue > 65) {
      irsend.sendNEC(0xFF10EF, 32); delay(40);
    }
    if (brain.readAttention() > 65) {
      irsend.sendNEC(0xFF18E7, 32); delay(40);
    }
  }
}

Convirtiéndote en Jedi IoT (Pruebas)

Tras construir todo, solo queda: probarlo. Usa el poder de tu mente, usa la Fuerza de las neuronas, mueve tu robot, controla tu casa, controla todo con pensamientos…

¡Ahora eres un verdadero Jedi IoT!

El dispositivo tiene muchas funciones y es muy divertido. Pero no es solo un juguete: combinando biología y electrónica creamos un dispositivo que puede ayudar a personas que luchan contra discapacidades a recuperar capacidades naturales.

El robot se controla fácil, los relés tampoco son gran reto. Solo debes aprender a controlar tu atención para mover el ratón. En la foto intento cerrar una app con mis ondas cerebrales. Más práctica = mejor experiencia.

¡Gracias por leer!

Espero que te guste mi proyecto; deja tu opinión en comentarios. Quería hacer vídeo, pero la codificación me llevó tiempo; lo publicaré pronto en mi canal de YouTube y actualizaré esta presentación.

¡Que la Fuerza te acompañe, siempre!

Código

Código Particle Photon
Código Robot Controller
HC_05_Bluetooth.ino
Código Mouse Controller
Arduino_Mega_Server
RobotControllerHeadset.ino

Código Particle Photon

// Webserver para "Use the Force... Or your Brainwaves?"
// Estadísticas de meditación y atención
int att; int med; int function;
void setup() { Serial.begin(9600); }
void loop() {
  Spark.publish("Attention", String(att) + "%"); delay(2000);
  Spark.publish("Meditation", String(med) + "%"); delay(2000);
  Spark.publish("Last Function", String(function)); delay(2000);
  if (Serial.available() > 0) { char c = Serial.read(); }
  delay(10);
  switch(c) {
    case 'a': att=10; break; case 'b': att=20; break; case 'c': att=30; break;
    case 'd': att=40; break; case 'e': att=50; break; case 'f': att=60; break;
    case 'g': att=70; break; case 'h': att=80; break; case 'i': att=90; break;
    case 'j': att=100; break;
    case 'k': med=10; break; case 'l': med=20; break; case 'm': med=30; break;
    case 'n': med=40; break; case 'o': med=50; break; case 'p': med=60; break;
    case 'q': med=70; break; case 'r': med=80; break; case 's': med=90; break;
    case 't': med=100; break;
    case 'x': function="Home Automation"; break;
    case 'y': function="Robot Controller Mode"; break;
    case 'z': function="Mouse Controller"; break;
  }
}

Código Robot Controller (Arduino UNO)

// "Use the Force or your Brainwaves?" project
#include <IRremote.h>
int IRpin = 3;
IRrecv irrecv(IRpin);
decode_results results;
int motor_pin1=4, motor_pin2=5, motor_pin3=6, motor_pin4=7;

void setup() {
  irrecv.enableIRIn();
  pinMode(motor_pin1,OUTPUT); pinMode(motor_pin2,OUTPUT);
  pinMode(motor_pin3,OUTPUT); pinMode(motor_pin4,OUTPUT);
  Serial.begin(9600);
}

void loop() {
  if (irrecv.decode(&results)) { irrecv.resume(); }
  if (results.value == 0xFF18E7) { // adelante
    digitalWrite(motor_pin1,LOW); digitalWrite(motor_pin2,HIGH);
    digitalWrite(motor_pin3,LOW); digitalWrite(motor_pin4,HIGH);
    Serial.println("Go Forward!");
  }
  if (irrecv.decode(&results)) { irrecv.resume(); }
  if (results.value == 0xFF4AB5) { // atrás
    digitalWrite(motor_pin1,HIGH); digitalWrite(motor_pin2,LOW);
    digitalWrite(motor_pin3,HIGH); digitalWrite(motor_pin4,LOW);
    Serial.println("Go Backward!");
  }
  if (irrecv.decode(&results)) { irrecv.resume(); }
  if (results.value == 0xFF10EF) { // izquierda
    digitalWrite(motor_pin1,HIGH); digitalWrite(motor_pin2,LOW);
    digitalWrite(motor_pin3,LOW); digitalWrite(motor_pin4,HIGH);
    Serial.println("Turn Left!");
  }
  if (irrecv.decode(&results)) { irrecv.resume(); }
  if (results.value == 0xFF5AA5) { // derecha
    digitalWrite(motor_pin1,LOW); digitalWrite(motor_pin2,HIGH);
    digitalWrite(motor_pin3,HIGH); digitalWrite(motor_pin4,LOW);
    Serial.println("Turn Right!");
  }
  if (irrecv.decode(&results)) { irrecv.resume(); }
  if (results.value == 0xFF38C7) { // stop
    digitalWrite(motor_pin1,LOW); digitalWrite(motor_pin2,LOW);
    digitalWrite(motor_pin3,LOW); digitalWrite(motor_pin4,LOW);
    Serial.println("Stop!");
  }
}

HC_05_Bluetooth.ino

// HC-05 configuration
void setup() {
  Serial.begin(9600);
  delay(1000); Serial.print("AT"); delay(1000);
  Serial.print("AT+VERSION"); delay(1000);
  Serial.println("AT+ROLE=1"); delay(1000);
  Serial.println("AT+PAIR=tu_direccion,9"); delay(1000);
  Serial.print("AT+BAUD7"); // 57600
  Serial.begin(57600);
}
void loop() {}

Código Mouse Controller (Arduino Leonardo)

// By Imets Tamas - Use the Force... Or your Brainwaves?
#include <Mouse.h>
void setup() {
  Serial.begin(9600);
  Mouse.begin();
}
void loop() {
  if (Serial.available() > 0) {
    char inByte = Serial.read();
    switch (inByte) {
      case 'u': Mouse.move(0, -8); break; // up
      case 'd': Mouse.move(0, 8); break;  // down
      case 'l': Mouse.move(-8, 0); break; // left
      case 'r': Mouse.move(8, 0); break;  // right
      case 'c': Mouse.click(MOUSE_LEFT); break; // click
    }
  }
}

Arduino_Mega_Server

/* Arduino Mega Code for "A Tool for the Mind" by Imets Tams, 2016-02-02
   Analiza y organiza señales BT del sensor EEG. Libre para editar, dar crédito.
   Variables usan iniciales de familia: I. M. E. T. S.
   Detalles: https://www.instructables.com/member/Imetomi/ o https://www.hackster.io/Imetomi */
#include <VirtualWire.h>
#include <SoftwareSerial.h>
#include <Brain.h>
#include <LiquidCrystal.h>
#include <IRremote.h>

int led=13, medled=50, attled=51, blinkled=52;
char robot;
IRsend irsend;
SoftwareSerial mouse(18,19); // RX,TX → Leonardo
SoftwareSerial webserver(16,15); // → Photon
LiquidCrystal lcd(12,11,5,4,3,2);
Brain brain(Serial);

int closedeye = brain.readLowAlpha();
int attention = brain.readAttention();
int brainsignal = brain.readSignalQuality();
int meditation = brain.readMeditation();
int alpha = brain.readHighAlpha();
int lightatt, lightmed, blinklength, prevsignal=0;

void setup() {
  mouse.begin(9600); webserver.begin(9600);
  Serial.begin(57600); // Necomimi baudrate
  lcd.begin(16,2);
  pinMode(led,OUTPUT); pinMode(attled,OUTPUT); pinMode(medled,OUTPUT);
  pinMode(blinkled,OUTPUT); pinMode(37,OUTPUT); pinMode(38,OUTPUT); pinMode(39,OUTPUT);
  lightatt = map(attention,0,100,0,255);
  lightmed = map(meditation,0,100,0,255);
}

void robotmode() {
  if (brain.update()) {
    if (blinklength>0 && blinklength<2000) { loop(); } // salir modo robot
    if (attention>70) { irsend.sendNEC(0xFF18E7,32); webserver.println("g"); delay(40); }
    if (meditation>70) { irsend.sendNEC(0xFF10EF,32); webserver.println("q"); delay(40); }
  }
}

void loop() {
  if (brain.update()){
    analogWrite(attled, lightatt);
    analogWrite(medled, lightmed);
    if (closedeye>30000 && alpha>30000) {
      digitalWrite(blinkled,HIGH);
      blinklength = millis();
    } else if (closedeye<30000 && alpha<30000) {
      digitalWrite(blinkled,LOW);
      blinklength = 0;
    }
    if (blinklength>0 && blinklength<2000) {
      webserver.println("a"); delay(40);
      robotmode();
    }
    if (blinklength>2001 && blinklength<4000) {
      webserver.println("a"); delay(40);
      relay();
    }
    if (blinklength>4001 && blinklength<6000) {
      webserver.println("a"); delay(40);
      mousecontrol();
    }
    Serial.println(brain.readCSV());
  }
}

void relay() {
  webserver.println("");
  if (brain.update()) {
    if (blinklength>0 && blinklength<2000) { loop(); }
    if (attention>70) { digitalWrite(37,HIGH); webserver.println("g"); prevsignal=1; }
    if (meditation>70) { digitalWrite(38,HIGH); webserver.println("q"); prevsignal=1; }
    if (1000>blinklength && blinklength>0) { digitalWrite(39,HIGH); webserver.println("qj"); prevsignal=1; }
    if (attention>70 && prevsignal==1) { digitalWrite(37,LOW); webserver.println("q"); prevsignal=1; }
    if (meditation>70 && prevsignal==1) { digitalWrite(38,LOW); webserver.println("qj"); prevsignal=1; }
    if (1000>blinklength && blinklength>0 && prevsignal==1) { digitalWrite(39,LOW); webserver.println("a"); prevsignal=1; }
  }
}

void mousecontrol() {
  webserver.println("z");
  if (brain.update()) {
    if (070) { mouse.println('c'); webserver.println("t"); }
  }
}

RobotControllerHeadset.ino

#include <IRremote.h>
#include <IRremoteInt.h>
#include <Brain.h>

IRsend irsend;
Brain brain(Serial);
const int ledPin = 3;
long interval = 500;
long previousMillis = 0;
int ledState = LOW;
int medValue;

void setup() {
  pinMode(ledPin, OUTPUT);
  Serial.begin(57600);
}

void loop() {
  if (brain.update()) {
    Serial.println(brain.readCSV());
    medValue = brain.readMeditation();
  }
  if (brain.readSignalQuality() == 0) {
    if (medValue > 65) { irsend.sendNEC(0xFF10EF, 32); delay(40); }
    if (brain.readAttention() > 65) { irsend.sendNEC(0xFF18E7, 32); delay(40); }
  }
}