Controle Seu Robô com Ondas Cerebrais: Projeto Arduino Completo

Componentes e Materiais

Componente	Qtd	Observações
Arduino UNO	1	Usado no robô.
Arduino Mega 2560	1	O "cérebro" do projeto.
Arduino Leonardo	1	Controlador de mouse.
Particle Photon	1	Servidor web / data logger.
Necomimi Brainwave Cat Ears	1	Sensor EEG (chip NeuroSky TGAM).
Driver de motor dual H-Bridge L298 (SparkFun)	1	Ou construa seu próprio driver.
Módulo Relé	1	Se não quiser soldar circuitos.
Módulo Bluetooth HC-05	1
Módulo Bluetooth HC-06	1
LED (genérico)	3
Resistor 330 Ω	3
Transistor NPN uso geral	3
Jumpers macho/fêmea	1
Jumpers (genéricos)	1
Protoboard meia (solderless)	1

Ferramentas Necessárias

Ferro de soldar (genérico)

Aplicativos e Serviços Online

Brain Visualizer (apenas para experimentos)

Sobre o Projeto

Quando criança, sempre quis uma habilidade especial: mover objetos com o pensamento ou voar. Tentei mover objetos com "o poder da mente" — sem sucesso. Bem, sou fã de Star Wars, mas também gosto de eletrônica e programação; por que não combinar as duas coisas para construir um projeto incrível?

Todos os componentes, códigos e bibliotecas com links estão nas seções Hardware e Software.

Controle Seu Robô com Ondas Cerebrais: Projeto Arduino Completo

O conceito principal é: usando diferentes ondas cerebrais, o usuário controla um robô, o cursor do PC ou liga/desliga luzes em casa, enquanto um microcontrolador (Particle Photon) cria um painel online analisando as ondas cerebrais. Método perfeito para detectar doenças, estresse ou sonolência. Também ajuda as pessoas a viverem melhor, aprenderem a controlar emoções e manterem-se felizes. O cérebro humano precisa de equilíbrio: sono, pensamento, movimento... Usando o Particle Photon e o webserver dos criadores do Particle, ajudamos as pessoas a encontrar seu equilíbrio cerebral natural. Um sonho de infância me guiou a este projeto, e fico muito feliz por tê-lo realizado.

Mas, tirando Star Wars e a Força de lado, este dispositivo não é só para preguiçosos ou fãs; foi feito para devolver uma capacidade a quem luta diariamente com deficiência. O robô funciona como uma cadeira de rodas; a automação residencial permite controlar luzes ou TV mesmo sem mobilidade. O controle de PC pode ser útil até para pessoas saudáveis — quem não quer jogar ou navegar só com o pensamento?

Assista a este vídeo introdutório sobre a história do projeto:

Quer construir o seu? Aqui explico tudo: códigos, esquemáticos e instruções detalhadas. Aqueça seu ferro de solda…

A Ciência por Trás do Projeto

Eletroencefalografia (EEG) é um método eletrofisiológico não invasivo para registrar atividade elétrica do cérebro. Eletrodos no couro cabeludo medem flutuações de tensão decorrentes de correntes iônicas nos neurônios. Aplicações diagnósticas focam no conteúdo espectral do EEG — os tipos de oscilações neurais ("ondas cerebrais"). (Obrigado, Wikipedia). Usamos dois valores precisos:

Alpha (7–14 Hz): aparece ao fechar os olhos e relaxar; atenua com abertura dos olhos ou esforço mental.
Beta (15–30 Hz): amplitude baixa, múltiplas frequências; associado a pensamento ativo, ansioso, concentração ativa.

Como Funciona?

Usei quatro microcontroladores: Arduino Mega (cérebro central, recebe sinais do headset, analisa, encaminha comandos), Arduino Leonardo (controla mouse), Arduino UNO (recebe IR e controla robô), Particle Photon (webserver/data logger). O Mega transmite todos os dados ao Photon.

O dispositivo alterna entre três "canais" fechando os olhos:

Fechar olhos 1–2 s: modo automação residencial
Fechar olhos 2–4 s: modo controle de robô
Fechar olhos 4–6 s: modo controle de mouse

Usei relés para automação residencial — conecte o que quiser: TV, lâmpadas, tomadas.

O Headset Sem Fio

Adoro hackear brinquedos. Comprei o Necomimi, brinquedo que move orelhas conforme ondas cerebrais (atenção, meditação). Brinquedo inútil, mas dentro tem o chip NeuroSky TGAM que lê ondas, filtra ruído e dá ótimo sinal. Funciona via UART (Serial); com hacking, usamos Arduinos para ler as ondas. O headset transmite via Bluetooth para o servidor central. Ninguém quer cabos na cabeça — criei este headset confortável e amigável.

Veja abaixo como desmontar e fazer um headset Bluetooth sem fio.

Como Usar?

Temos dois valores eSense (NeuroSky): meditação (0–100) e atenção (0–100). Quanto mais focado, maior a atenção. Quanto mais relaxado, maior a meditação.

O sistema funciona com pensamentos; basta aprender a focar ou relaxar. Após uma semana, eu controlava minha atenção com precisão: 15, 39, 65, 90. Cada um descobre seu jeito. Emoções funcionam bem: amor, amizade, raiva, medo dão bom contraste nos valores.

Para ligar: plugue cabo micro USB no Arduino Leonardo. Isso também controla o mouse (se desejado) e garante 5V/500mA para o sistema.

Controlando a Automação Residencial

No modo automação: atenção > 70 liga relé 1; meditação > 70 liga relé 2; ambos > 70 ligam relé 3. É um pouco tricky, mas possível após treino mental. Se já ligado, o mesmo comando desliga (atingir 70 novamente). Conecte qualquer dispositivo de alta tensão (luz, TV, PC, ventilador) ao módulo relé.

Controlando o Mouse

Cursor controlado por emoções: atenção < 25 → esquerda; 25–50 → direita; 50–75 → cima; 75–100 → baixo. Clique aumentando meditação. A atenção é facilmente controlada com emoções (para mim).

Controlando o Robô

O robô tem três estados: parar, virar esquerda, avançar. Por que só dois movimentos? Porque são suficientes para ir a qualquer lugar. Use meditação para girar; ao atingir a direção desejada, pare o robô e avance com atenção. Método melhor; até iniciantes que não controlam bem atenção/meditação conseguem brincar.

Meu Planejamento

Imagem antiga do planejamento, mas deu certo — fico feliz com o resultado. O headset transmite BT (Bluetooth) para o Arduino Mega que analisa bytes e controla as funções. Foi difícil achar a melhor forma de transmitir tantos dados, mas escolhi Bluetooth em vez de WiFi. Inicialmente queria usar o Photon como transmissor, mas ele ganhou papel melhor no webserver. Foi a maior modificação do projeto. Usei módulos Arduino caseiros porque adoro projetar meus circuitos. Pode comprar módulos prontos ou construir comigo.

Meio Ano de Aprendizado e Experimentos

Trabalhei muito nisso, comecei há quase meio ano, mas com o Photon as coisas aceleraram. O dashboard deles é muito fácil. Há muitos tutoriais na net sobre hackear brinquedos EEG, ajudaram um pouco, mas não tinham funções extras. Decidi hackear o Necomimi e, com criatividade, criei este dispositivo com muito mais recursos que piscar LED. Espero que gostem!

Vamos começar!

Hackeando o Brinquedo Necomimi

Queremos modificar este brinquedo EEG para transmitir via Bluetooth. Primeiro, abra a caixa. Parafusos ficam sob o adesivo. Remova o adesivo e a tampa traseira; dentro há um pequeno circuito. O que fica sob o circuito principal é o chip NeuroSky TGAM. Conectado por 4 pinos ao microcontrolador principal. Use ferro de solda e remova este circuito com cuidado. Solde 3 fios: GND, VCC e pino T (transmissor, 57600 baud). Conectei o pino T diretamente a um módulo HC-06 slave BT. O HC-06 vem a 9600 baud, mas corrigimos isso. Se soldou os 3 fios, pode embutir sua fonte recarregável. Usei bateria Li-Ion 500mAh, circuito carregador USB, step-up 5V e dois resistores (100 Ω e 200 Ω) para garantir 3.4V estável para chip e Bluetooth. Siga o esquema para construir o circuito do headset. Configure o módulo Bluetooth.

Sobre o chip:

O NeuroSky ThinkGear AM filtra, amplifica e envia dados via interface serial. Mais info aqui.

O Esquemático / Eletrônica

Siga as instruções e imagens abaixo para criar seu headset EEG sem fio.

Precisa: bateria Li-Ion 500mAh, módulo step-up 5V para tensão estável, resistores 100 Ω e 200 Ω para reduzir a 3.3V estável. Soldei headers fêmea para alimentar e transmitir dados ao Bluetooth. A parte mais importante: conectar o pino "T" ao "RX" do módulo Bluetooth. Isso dá vida ao projeto.

Configurando Módulos Bluetooth

HC-06

Carregue o sketch "HC_06_Bluetooth" no Arduino UNO, conecte o módulo conforme esquema (encontrei no site da equipe Artronix).

void setup() {
  Serial.begin(9600); // baud padrão HC-06
  delay(1000);
  Serial.print("AT");
  delay(1000);
  Serial.print("AT+VERSION");
  delay(1000);
  Serial.print("AT+PIN"); // remove senha
  delay(1000);
  Serial.print("AT+BAUD7"); // 57600 baud = padrão Necomimi
  delay(1000);
  Serial.begin(57600);
}
void loop() { }

Abra o Monitor Serial e aguarde a configuração. Agora seu BT está a 57600 baud. Pode testar apps BCI (Brain-Computer Interface) — este Necomimi hackeado será compatível com todos os apps NeuroSky.

Apps recomendados (compatíveis PC, iOS, Android):

HC-05

Use o sketch "HC_05_Bluetooth" no Arduino da mesma forma. Conecte pino "EN" do HC-05 ao 3.3V do Arduino. Escreva o endereço do seu HC-06 no código. Verifique o endereço com smartphone Android. Substitua ":" (dois pontos) por "," (vírgula) no código.

Exemplo de conversão de endereço:

20:15:09:15:17:82 ==> 2015,09,151782 (alguns ":" podem ficar, não são necessários).

// Configuração HC-05
void setup() {
  Serial.begin(9600);
  delay(1000);
  Serial.print("AT");
  delay(1000);
  Serial.print("AT+VERSION");
  delay(1000);
  Serial.println("AT+ROLE=1"); // master mode
  delay(1000);
  Serial.println(" AT+LINK=cole_aqui_seu_endereco"); // conexão automática
  delay(1000);
  Serial.print("AT+UART=57600,1,0"); // 57600 baud
  Serial.begin(57600);
}
void loop() { }

Os dois módulos devem se conectar. Se houver problemas, clique aqui para mais detalhes.

O Robô Controlado Remotamente

Robô barato usando tecnologia IR 38 kHz (controle de TV). Comprei chassis na Amazon. Receptor IR recuperado de TV velha; Arduino também da Amazon. Links nas partes (seção Hardware).

Circuito Driver de Motor

Peças necessárias:

2 Terminais de parafuso
CI L293D
3 Pinos header
9 Pinos header (90°)
Resistor 1k Ω
LED vermelho
Fios
Placa PCB

Usei fios de cobre e, seguindo o esquema, conectei os pinos do CI aos headers. Não importa qual pino vai a qual header, só lembre as conexões. LED em série com resistor e em paralelo com VCC 5V.

Montando o Chassis

Fácil: chave de fenda e habilidade manual, 5 minutos. Depois vem a parte difícil: driver de motor. Escolhi L293D para dois motores. Veja o esquema para montar.

Conectando as Peças ao Arduino

Jumpers para sensor e driver:

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

Veja o esquema do L293D e conecte conforme acima. O pino 5V do Arduino nos pinos 1, 9, 16 habilita a função driver. Use terminais de parafuso para alimentar os motores.

Escrevendo o Código

Com a biblioteca IRremote, criei código que lê sinais IR 38 kHz, decodifica e move o robô. (Baixe a biblioteca na seção Código).

Explicações no código: decodifica sinais IR do servidor principal, move motores conforme comando do usuário (frente ou esquerda). Baixe o código: "Robot_Code". Carregue no Arduino e seu robô estará pronto.

O Servidor Principal (Arduino Mega, Leonardo, Photon)

Lê pacotes de dados do headset sem fio via BT configurado. O Mega é o cérebro: Bluetooth, LED IR transmissor, webserver, controlador de mouse. Código complexo, mas com comentários.

O Gabinete

Simples mas bonito. Cortei duas placas 18×15 cm, lixei as bordas. Parafusos unem as duas.

Circuito de Relés

Peças necessárias:

Transistor 2N2222 (3 un.)
Diodos germânio (3 un.)
Resistores 330 Ω (3 un.)
Resistores 1k Ω (3 un.)
Relés 5V (3 un.)
Fios de conexão
Headers
Placa PCB

Uma imagem vale mais que mil palavras: veja o esquema. Se o pino "Signal" recebe sinal do Arduino, o relé liga. O transistor amplifica para garantir potência. Usamos pinos 37, 38, 39 para controlar HIGH/LOW de cada relé.

Instalando Peças no Gabinete

Usei fita dupla face branca para fixar os circuitos no acrílico. Fica bonito e firme.

Circuitaria do Servidor

Baseado em software; circuito simples. Alimente os microcontroladores e faça as conexões entre eles. LED IR no pino D3; relés nos 37–39. D16 do Mega → RX do Photon; D18 → RX do Leonardo.

Conexão com o Robô

LEDs IR no pino D3; com biblioteca IRremote enviamos códigos ao robô. Códigos IR devem ser iguais no código do robô. Teste com câmera: luz IR aparece roxa na foto; câmeras detectam IR. Truque sempre funciona.

O Código

Use o código "Arduino_Mega_Server" na seção Software.

Sofri muito escrevendo os códigos: programar três microcontroladores foi desafio. Usei bibliotecas IRremote, Brain, SoftwareSerial e Mouse (links na seção Software). Código pronto e funcional — faça upload nos microcontroladores. Baixe o .ino ou copie/cole na IDE. Código do Particle Photon via IDE web (Particle Build). Registre-se, conecte o laptop ao microcontrolador; surpreendentemente, quase automático, só adicionei o Device ID.

Antes de carregar os códigos, certifique-se que nada está conectado aos pinos RX/TX. Desconecte Bluetooth do Mega, e Mega do Leonardo e Photon.

O Controlador de Mouse

O Webserver

Quis adicionar função IoT: data logger online com Particle Photon. Conforme o uso, o Photon cria servidor pessoal e grava dados na nuvem.

Pode parecer assustador, mas imagine detectar estresse (atenção oscila rápido) ou necessidade de sono (meditação sempre > 80). Este webserver ajuda a viver de forma mais saudável.

O Particle tem dashboard online onde você publica dados com Particle.publish(). Agradecemos aos desenvolvedores do dashboard — economizaram muito tempo.

Escrever código no navegador? Foi interessante, mas funciona igual à IDE normal. Upload sem fio. Este microcontrolador seria ferramenta útil em qualquer caixa de ferramentas.

O dashboard mostra Atenção e Meditação; acesse a qualquer momento na URL do seu dashboard. Mais info aqui.

Upgrade Rápido para Quem Quer Apenas Controlar um Robô com Ondas Cerebrais

Não quer construir o projeto todo, só um robô controlado por ondas cerebrais? Sem problemas, se é iniciante pensei em você. Fiz código comentado que precisa de Arduino Mini Pro (ou UNO), LED IR e o headset para controlar o robô. Sei que muitos leitores querem projeto simples e divertido de fim de semana — aqui está descrição e código.

Use o código "RobotControllerHeadset" na seção Software. Conecte LED IR no pino D3 do Mini Pro (ou UNO) e pino T do chip NeuroSky ao RX do Arduino. Alimente com 3.3V ou 5V e pronto. Monte o robô e use este código no headset:

#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);
    }
  }
}

Tornando-se um Jedi IoT (Testes)

Após fazer tudo explicado, só resta: testar. Use o poder da mente, use a Força dos neurônios, mova seu robô, controle sua casa, controle tudo com pensamentos...

Agora você é um verdadeiro Jedi IoT!

O dispositivo tem muitos recursos e é muito divertido. Mas não é só um brinquedo: unindo biologia e eletrônica, criamos um dispositivo que pode ajudar pessoas com deficiência a recuperar capacidades naturais.

O robô é fácil de controlar; os relés não são grande desafio. Basta aprender a controlar seus níveis de atenção para controlar o mouse. Na foto, tento fechar um app com ondas cerebrais. Mais prática garante melhor experiência.

Obrigado por Assistir!

Espero que tenham gostado; deixem opinião nos comentários. Queria fazer vídeo, mas a codificação foi dura e não tive tempo; publicarei em breve no meu canal YouTube e atualizarei esta apresentação.

Que a Força esteja com você, sempre!

Código

Particle Photon Code
Robot Controller Code
HC_05_Bluetooth.ino
Mouse Controller Code
Arduino_Mega_Server
RobotControllerHeadset.ino

Particle Photon Code

Arduino

Copie no IDE do navegador e carregue no Particle Photon. Abra o dashboard para ver resultados em tempo real.

// Código do webserver para projeto "Use the Force... Or your Brainwaves?"
// Cria estatísticas das ondas cerebrais: meditação e atenção
// Obrigado ao dashboard funcional do Particle, o código é simples
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;
  }
}

Robot Controller Code

Arduino

Controla o robô. Carregue no Arduino UNO. Pode alterar códigos IR se quiser.

// Usado no projeto "Use the Force or your Brainwaves?"
#include <IRremote.h>
int IRpin = 3;
IRrecv irrecv(IRpin);
decode_results results;
int motor_pin1 = 4;
int motor_pin2 = 5;
int motor_pin3 = 6;
int 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) { // frente
    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) { // trá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) { // esquerda
    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) { // direita
    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) { // parar
    digitalWrite(motor_pin1, LOW);
    digitalWrite(motor_pin2, LOW);
    digitalWrite(motor_pin3, LOW);
    digitalWrite(motor_pin4, LOW);
    Serial.println("Stop!");
  }
}

HC_05_Bluetooth.ino

Arduino

Configura módulo HC-05.

// Configuração HC-05
void setup() {
  Serial.begin(9600);
  delay(1000);
  Serial.print("AT");
  delay(1000);
  Serial.print("AT+VERSION");
  delay(1000);
  Serial.println("AT+ROLE=1"); // master mode
  delay(1000);
  Serial.println(" AT+PAIR=cole_aqui_seu_endereco,9"); // conexão automática
  delay(1000);
  Serial.print("AT+BAUD7"); // 57600 baud
  Serial.begin(57600);
}
void loop() { }

Mouse Controller Code

Arduino

Carregue no Arduino Leonardo. Controla cursor do PC conforme sinal do Mega.

// Código por Imets Tamas para projeto "Use the Force... Or your Brainwaves?"
// Move mouse via sinais seriais
#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; // cima
      case 'd': Mouse.move(0, 8); break;  // baixo
      case 'l': Mouse.move(-8, 0); break; // esquerda
      case 'r': Mouse.move(8, 0); break;  // direita
      case 'c': Mouse.click(MOUSE_LEFT); break; // clique
    }
  }
}

Arduino_Mega_Server

Arduino

Analisa ondas cerebrais, controla tudo...

/* Arduino Mega Code for "A Tool for the Mind" by Imets Tams, 2 Feb 2016
   Analisa e organiza sinais seriais Bluetooth do sensor de ondas cerebrais
   Livre para editar, mas dê crédito. Variáveis usam letras do sobrenome da família: I. M. E. T. S.
   Mais detalhes: https://www.instructables.com/member/Imetomi/ ou https://www.hackster.io/Imetomi */
#include <VirtualWire.h>
#include <SoftwareSerial.h>
#include <Brain.h>
#include <LiquidCrystal.h>
#include <IRremote.h>

int led = 13;
int medled = 50;
int attled = 51;
int blinkled = 52;
char robot;
IRsend irsend;
SoftwareSerial mouse(18, 19); // RX, TX -> Leonardo
SoftwareSerial webserver(16, 15); // -> Particle Photon
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
Brain brain(Serial); // ondas lidas via BT no hardware serial

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

void setup() {
  mouse.begin(9600);
  webserver.begin(9600);
  Serial.begin(57600); // 57600 = taxa Necomimi
  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(); // sai do modo robô
    }
    if (attention > 70) {
      irsend.sendNEC(0xFF18E7, 32); // frente
      webserver.println("g");
      delay(40);
    }
    if (meditation > 70) {
      irsend.sendNEC(0xFF10EF, 32); // gira
      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(37, HIGH);
      webserver.println("q");
      prevsignal = 1;
    }
    if (1000 > blinklength && blinklength > 0) {
      digitalWrite(37, 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(37, LOW);
      webserver.println("qj");
      prevsignal = 1;
    }
    if ((1000 > blinklength && blinklength > 0) && (prevsignal == 1)) {
      digitalWrite(37, LOW);
      webserver.println("a");
      prevsignal = 1;
    }
  }
}

void mousecontrol() {
  webserver.println("z");
  if (brain.update()) {
    if (0 < attention && attention < 25) {
      mouse.println('l'); // esquerda
      webserver.println("a");
    }
    if (26 < attention && attention < 50) {
      mouse.println('r'); // direita
      webserver.println("c");
    }
    if (51 < attention && attention < 75) {
      mouse.println('u'); // cima
      webserver.println("f");
    }
    if (76 < attention && attention < 100) {
      mouse.println('d'); // baixo
      webserver.println("h");
    }
    if (meditation > 70) {
      mouse.println('c'); // clique
      webserver.println("t");
    }
  }
}

RobotControllerHeadset.ino

Arduino

Para quem quer construir robô IR.

#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);
    }
  }
}