Roboter per Gedanken steuern: Umfassendes Arduino-Projekt mit EEG

Komponenten und Materialien

Arduino UNO (für Roboter)	×	1
Arduino Mega 2560 (Zentrale)	×	1
Arduino Leonardo (Maus-Controller)	×	1
Particle Photon (Webserver/Datenlogger)	×	1
Necomimi Brainwave Cat Ears (EEG-Sensor)	×	1
SparkFun Dual H-Bridge L298 (Motortreiber)	×	1
Relais-Modul	×	1
HC-05 Bluetooth-Modul	×	1
HC-06 Bluetooth-Modul	×	1
LED	×	3
Widerstand 330 Ω	×	3
NPN-Transistor (Allzweck)	×	3
Jumper-Kabel (m/w)	×	1
Jumper-Kabel	×	1
Steckbrett (Halbgröße)	×	1

Benötigte Werkzeuge und Maschinen

Lötkolben

Apps und Online-Dienste

Brain Visualizer (nur für Experimente nötig)

Über dieses Projekt

Als Kind wollte ich immer eine besondere Fähigkeit haben – Gegenstände mit Gedanken bewegen oder fliegen. Ich versuchte, Objekte mit „der Kraft meiner Gedanken“ zu bewegen, natürlich ohne Erfolg. Nun, ja, ich war und bin ein riesiger Star-Wars-Fan, aber ich mag auch Elektronik und Programmierung – warum nicht beides kombinieren, um ein unglaubliches Projekt zu bauen?

Alle Teile, Codes und Bibliotheken mit Links finden Sie im Hard- und Software-Bereich.

Roboter per Gedanken steuern: Umfassendes Arduino-Projekt mit EEG

Das Hauptkonzept ist: Mithilfe verschiedener Gehirnwellen kann der Benutzer einen Roboter steuern, den Mauszeiger am PC bewegen oder Lichter im Haus ein-/ausschalten, während ein Mikrocontroller (Particle Photon) eine Online-Analyse der Gehirnwellen erstellt. Dies eignet sich ideal zur Erkennung von Krankheiten, Stress oder Müdigkeit. Es kann auch helfen, das Leben zu verbessern, Emotionen zu kontrollieren und glücklich zu sein. Das menschliche Gehirn braucht Balance – Schlaf, Denken, Bewegung… Mit dem Particle Photon und dem Webserver der Particle-Gründer können wir Menschen helfen, ihre natürliche Gehirnbalance zu finden. Ein Kindheitstraum führte mich zu diesem Projekt, und ich bin sehr glücklich, es realisiert zu haben.

Abseits von Star Wars und der Macht ist dieses Gerät nicht nur für Faule oder Fans gedacht – es soll Menschen, die täglich mit Behinderungen kämpfen, ein Stück Fähigkeit zurückgeben. Der von mir entworfene Roboter funktioniert wie ein Rollstuhl, die Hausautomation hilft bei der Steuerung von Licht oder TV, auch wenn man sich nicht bewegen kann. Der PC-Controller-Modus kann sogar für gesunde Menschen nützlich sein – wer möchte nicht Computerspiele nur mit Gedanken steuern?

Sehen Sie sich dieses kurze Einführungsvideo zur Geschichte des Projekts an:

Die Wissenschaft hinter dem Projekt

Elektroenzephalografie (EEG) ist eine elektrophysiologische Methode zur Aufzeichnung der elektrischen Aktivität des Gehirns. Sie ist typischerweise nicht-invasiv, mit Elektroden auf der Kopfhaut. EEG misst Spannungsschwankungen durch Ionenströme in den Neuronen. Diagnostische Anwendungen konzentrieren sich auf den Spektralinhalt – die Art der neuronalen Oszillationen (umgangssprachlich „Gehirnwellen“). Wir nutzen zwei präzise Werte:

Alpha (7–14 Hz): Tritt bei geschlossenen Augen und Entspannung auf, verschwindet bei Augenöffnung oder geistiger Anstrengung.
Beta (15–30 Hz): Niedrige Amplitude, variable Frequenzen – assoziiert mit aktiver, ängstlicher oder konzentrierter Denkweise.

Wie funktioniert es?

Ich verwendete vier Mikrocontroller: Arduino Mega (Zentrale, empfängt Signale vom Headset, analysiert, leitet Befehle weiter), Arduino Leonardo (Maussteuerung am PC), Arduino UNO (IR-Empfang, Robotersteuerung) und Particle Photon (Webserver für Online-Analyse). Das Gerät kann drei Dinge steuern (erweiterbar). Ich nenne sie „Kanäle“. Wechsel zwischen Kanälen erfolgt durch Augen schließen:

1–2 Sekunden Augen schließen: Hausautomatisierungs-Modus
2–4 Sekunden Augen schließen: Roboter-Steuerungs-Modus
4–6 Sekunden Augen schließen: Maus-Steuerungs-Modus

Für die Hausautomation nutze ich Relais – daran können Sie alles anschließen: TV, Lampen, Steckdosen.

Das kabellose Headset:

Ich liebe es, Spielzeug zu hacken. Ich kaufte ein EEG-Spielzeug namens Necomimi, das seine Ohren je nach Gehirnwellen (Aufmerksamkeit, Meditation) bewegt. Ein nutzloses Spielzeug, aber darin steckt ein kleiner Chip (NeuroSky ThinkGear AM), der Gehirnwellen liest, Rauscht filtert und ein gutes Signal liefert. Er arbeitet über UART (Serial), sodass wir mit etwas Hacking Arduinos damit auslesen können. Die Aufgabe des Headsets: Gehirnwellen kabellos an die Zentrale senden. Niemand will Kabel am Kopf – ich baute dieses bequeme, benutzerfreundliche Headset.

Weiter unten sehen Sie, wie man es auseinanderbaut und zum kabellosen Bluetooth-Headset macht.

Bedienung

Wir haben zwei messbare eSense-Werte (NeuroSky): Meditation (0–100) und Aufmerksamkeit (0–100). Je fokussierter Sie sind, desto höher der Aufmerksamkeitswert. Je entspannter, desto höher der Meditationswert.

Das System arbeitet mit Gedanken – man muss nur lernen, fokussiert oder entspannt zu sein. Nach einer Woche Experimentieren konnte ich meinen Aufmerksamkeitswert sehr präzise steuern (bewusst auf ca. 15, 39, 65, 90 setzen). Jeder ist anders; es funktioniert gut mit Emotionen (Liebe, Freundschaft, Wut, Angst geben gute Kontraste).

Zur Stromversorgung stecken Sie ein Micro-USB-Kabel in den Arduino Leonardo. Dieser steuert auch die Maus (falls gewünscht) und liefert 5 V / 500 mA für das System.

Hausautomation steuern

Im Hausautomatisierungsmodus: Aufmerksamkeit > 70 → Relais 1 ein, Meditation > 70 → Relais 2 ein, beide > 70 → Relais 3 ein. Etwas tricky, aber nach etwas Mentaltraining machbar. Bereits eingeschaltet? Derselben Befehl schaltet aus (wieder > 70 erreichen). Danach können Sie beliebige Hochspannungsgeräte an das Relaismodul anschließen.

Maus steuern

Der Cursor wird über Emotionen gesteuert: Aufmerksamkeit < 25 → links, 25–50 → rechts, 50–75 → oben, 75–100 → unten. Klick durch Erhöhen der Meditation. Wie gesagt, Aufmerksamkeit lässt sich gut über Emotionen steuern.

Roboter steuern

Der Roboter hat nur drei Zustände: Stopp, Links drehen, Vorwärts fahren. Warum nur zwei Bewegungsrichtungen? Weil diese ausreichen, um den Roboter überall hin zu manövrieren. Nutzen Sie Meditation zum Drehen, stoppen Sie, dann Aufmerksamkeit für Vorwärtsfahrt. Einfacher für Anfänger, die ihre Werte noch nicht gut kontrollieren können.

Mein Plan

Dies ist ein älteres Bild meines Plans, aber ich habe es geschafft und bin sehr zufrieden. Das Headset sendet Bluetooth-Signale an den Arduino Mega, der die eingehenden Bytes analysiert und je nach Gedanken die verschiedenen Funktionen steuert. Es war schwer, den besten Weg für die Datenübertragung zu finden, aber ich wählte Bluetooth statt WiFi. Ursprünglich wollte ich den Particle Photon als Datensender nutzen, aber der bekam die wichtigere Rolle als Webserver. Das war die größte Änderung im Projekt. Ich verwendete selbstgebaute Arduino-Module, weil ich gerne eigene Schaltungen designe. Sie können diese Module kaufen oder selbst bauen.

Ein halbes Jahr Lernen und Experimentieren

Ich arbeitete lange an diesem Projekt – fast ein halbes Jahr. Mit dem Photon ging es schneller. Dessen Dashboard war sehr einfach zu nutzen. Es gibt viele Tutorials zum Hacken von EEG-Spielzeug, aber sie boten keine zusätzlichen Funktionen. Also hackte ich das Necomimi-Spielzeug und schuf mit Kreativität ein Gerät mit weit mehr Features als nur eine LED blinken zu lassen. Hoffentlich gefällt es Ihnen!

Los geht’s!

Necomimi-Spielzeug hacken

Wir wollen das EEG-Spielzeug so modifizieren, dass es Daten per Bluetooth sendet. Zuerst Gehäuse öffnen: Schrauben sind unter dem Aufkleber. Aufkleber und Rückseite entfernen – darin liegt eine kleine Schaltung. Die untere Platine ist der NeuroSky TGAM-Chip, mit vier Stiftleisten an der Hauptplatine verbunden. Lötkolben nehmen und diese Platine vorsichtig entfernen. Nun drei Drähte an GND, VCC und T-Pin löten. Der T-Pin ist der Sender-Pin mit 57600 Baud – er sendet Datenpakete an unseren Mikrocontroller. Ich verband ihn direkt mit einem HC-06 Slave BT-Modul. Der HC-06 ist auf 9600 Baud eingestellt, aber wir korrigieren das. Nach dem Löten können Sie eine eigene wiederaufladbare Stromquelle einbauen. Ich nutzte einen 500-mAh-Li-Ion-Akku, USB-Ladeschaltung, 5-V-Step-Up und zwei Widerstände (100 Ω, 200 Ω) für stabile 3,4 V für Chip und Bluetooth-Modul. Folgen Sie dem Schaltbild für den Headset-Schaltkreis. Danach Bluetooth-Modul konfigurieren.

Zum Chip:

Der NeuroSky ThinkGear AM filtert, verstärkt und sendet Daten über Serial. Mehr Infos hier.

Schaltbild / Elektronik

Folgen Sie den Anweisungen und Bildern unten, um Ihr eigenes kabelloses EEG-Headset zu bauen.

Sie benötigen: 500-mAh-Li-Ion-Akku, 5-V-Step-Up-Modul, 100-Ω- und 200-Ω-Widerstände zur Spannungsreduktion auf stabile 3,3 V. Ich lötete weibliche Stiftleisten für Stromversorgung und Datenübertragung zum Bluetooth-Modul. Wichtigster Teil: Verbinden Sie den „T“-Pin mit dem „RX“ des Bluetooth-Moduls. Das erweckt das Projekt zum Leben.

Bluetooth-Module konfigurieren

HC-06: Sketch „HC_06_Bluetooth“ auf Arduino UNO laden, BT-Modul laut Schaltbild verbinden. Schema von Artronix-Team gefunden, schien nützlich.

void setup() {
  Serial.begin(9600);
  delay(1000);
  Serial.print("AT"); delay(1000);
  Serial.print("AT+VERSION"); delay(1000);
  Serial.print("AT+PIN"); delay(1000); // Passwort entfernen
  Serial.print("AT+BAUD7"); delay(1000); // Baudrate 57600
  Serial.begin(57600);
}
void loop() {}

Serial Monitor öffnen und warten, bis der Arduino das BT-Modul konfiguriert. Nun ist das Modul auf 57600 Baud eingestellt. Sie können viele BCI-Apps (Brain Computer Interface) testen – das gehackte Necomimi wird mit allen NeuroSky-Apps kompatibel sein.

Empfohlene Apps (kompatibel mit PC, iOS, Android):

HC-05: Sketch „HC_05_Bluetooth“ auf Arduino laden, EN-Pin des HC-05 an 3,3 V des Arduino. Adresse Ihres HC-06-Moduls im Code eintragen (mit Android-Smartphone auslesen). Doppelpunkte „:“ durch Kommas „,“ ersetzen.

Adresse im Code ändern: 20:15:09:15:17:82 → 2015,09,151782 (einige „:“ weglassen, da nicht nötig).

void setup() {
  Serial.begin(9600);
  delay(1000);
  Serial.print("AT"); delay(1000);
  Serial.print("AT+VERSION"); delay(1000);
  Serial.println("AT+ROLE=1"); // Master-Modus
  delay(1000);
  Serial.println("AT+PAIR=your_address,9"); // Auto-Connect
  delay(1000);
  Serial.print("AT+UART=57600,1,0"); // Baudrate 57600
  Serial.begin(57600);
}
void loop() {}

Schließlich sollten sich beide Module verbinden. Bei Problemen hier weiterlesen.

Der ferngesteuerte Roboter

Für den günstigen Roboter nutzte ich 38-kHz-IR-Technologie (wie TV-Fernbedienungen). Chassis von Amazon gekauft. IR-Empfänger aus altem TV ausgebaut, Arduino ebenfalls von Amazon. Links zu Teilen im Hardware-Bereich.

Motortreiber-Schaltung

Benötigte Teile:

2 Schraubklemmen
L293D IC
3 Stiftleisten
9 Stiftleisten (90°)
1-kΩ-Widerstand
Rote LED
Drähte
Platine

Ich verwendete Kupferdrähte und verband laut Schaltbild die IC-Pins mit den Stiftleisten. Welcher Pin zu welchem Stift geht, ist egal – Hauptsache, Sie merken Sie sich die Zuordnung. LED in Reihe mit Widerstand, parallel zu 5 V VCC.

Chassis zusammenbauen

Sehr einfach: Schraubendreher, etwas Geschick – Rahmen in fünf Minuten gebaut. Dann der schwierigere Teil: Motortreiber-Schaltung bauen. Ich wählte L293D, der zwei Motoren treiben kann. Schaltbild beachten.

Teile mit Arduino verbinden

Jumper-Kabel für Sensor und Motortreiber zum Arduino.

Arduino Pin → Motortreiber:

4 → 15
5 → 10
6 → 7
7 → 2
VIN → 8
5 V → 1, 9, 16
GND → 4, 5, 13, 12

Schaltbild des L293D-Moduls ansehen, dann Pins wie oben mit Arduino UNO verbinden. Der 5-V-Pin des Arduino muss an 1, 9, 16 gehen, um die Treiberfunktion des ICs zu aktivieren. Schließlich Schraubklemmen für Motorstromversorgung nutzen.

Code schreiben…

Mit der IRremote-Bibliothek erstellte ich einen Code, der 38-kHz-Infrarotsignale liest, decodiert und den Roboter bewegt. (Bibliothek im Code-Bereich herunterladen.)

Erklärungen im Code. Kern: IR-Signale vom Hauptserver decodieren, dann je nach Benutzerwunsch Motoren bewegen (Vorwärts / Links). Download: „Robot_Code“. Auf Arduino laden – Roboter fertig.

Hauptserver (Arduino Mega, Leonardo, Photon)

Der Server liest eingehende Datenpakete vom kabellosen Headset. Wir nutzen das konfigurierte BT-Modul für die Verbindung Headset–Server. Der Arduino Mega ist das Gehirn: Alles ist damit verbunden – Bluetooth, IR-Sender-LED, Webserver, Maus-Controller. Der Code ist komplex, aber kommentiert.

Gehäuse

Einfach, aber schick: Zwei 18×15-cm-Platten, Kanten geschliffen, mit Schrauben verbunden.

Relais-Schaltung

Benötigte Teile:

3× 2N2222 Transistor
3× Germanium-Dioden
3× 330-Ω-Widerstände
3× 1-kΩ-Widerstände
3× 5-V-Relais
Draht, Stiftleisten, Platine

Ein Bild sagt mehr als tausend Worte – statt Text schauen Sie auf das Schaltbild. Wenn der „Signal“-Pin ein Signal vom Arduino erhält, schaltet das Relais. Der Transistor verstärkt das Signal für ausreichend Relais-Leistung. Pins 37, 38, 39 steuern HIGH/LOW der drei Relais.

Bauteile im Gehäuse montieren

Zur Befestigung auf der Plexiglas-Platte nutzte ich doppelseitiges Klebeband – sieht gut aus und hält fest.

Server-Schaltung

Software-basiert, daher einfache Hardware. (Schaltbild unten.) Nur Mikrocontroller mit Strom versetzen und untereinander verbinden. IR-LED an Pin D3, Relais an 37–39. D16 (Mega) → RX (Photon), D18 (Mega) → RX (Leonardo).

Verbindung zum Roboter

IR-LEDs an digitalen Pin D3, mit IRremote-Bibliothek Codes an Roboter senden. IR-Codes müssen im Roboter-Code identisch sein. Testen mit Kamera: Infrarotlicht erscheint lila auf Fotos – Kameras detektieren IR. Funktioniert immer.

Der Code

Nutzen Sie den „Arduino_Mega_Server“-Code im Software-Bereich.

Ich litt beim Schreiben der Codes – drei Mikrocontroller zu programmieren war eine große Herausforderung. Ich nutzte Bibliotheken: IRremote, Brain, SoftwareSerial, Mouse (Links im Code-Bereich). Jetzt ist der Code fertig und funktioniert – einfach auf Ihre Mikrocontroller hochladen. Die Datei .ino herunterladen oder Code kopieren. Der Code für den Particle Photon wird über die Browser-IDE hochgeladen: Bei Particle Build registrieren, Laptop mit Mikrocontroller verbinden – ging fast automatisch, nur Device-ID hinzufügen.

Wichtig: Vor dem Hochladen der Codes sicherstellen, dass nichts an RX/TX-Pins angeschlossen ist. Bluetooth-Modul vom Mega trennen, Mega von Leonardo und Photon trennen.

Maus-Controller

Webserver

Ich wollte eine IoT-Funktion (Internet of Things) einbauen: einen Online-Datenlogger mit dem Particle Photon. Je nach Nutzung erstellt der Photon einen persönlichen Server und schreibt Daten in die Cloud.

Das mag zunächst gruselig wirken, aber stellen Sie sich vor: Sie können erkennen, ob Sie gestresst sind (Aufmerksamkeit schwankt schnell) oder ob Sie schlafen sollten (Meditation dauerhaft > 80). Dieser Webserver kann helfen, gesünder zu leben.

Particle bietet ein Online-Dashboard, wo man mit Particle.publish() beliebige Daten veröffentlichen kann. Großes Dankeschön an die Dashboard-Entwickler – sie haben uns viel Zeit gespart.

Code im Browser schreiben?

Interessant, Code auf einer Webseite zu schreiben, aber es funktioniert wie die normale IDE. Der Code wird kabellos hochgeladen. Dieser Mikrocontroller wäre ein nützliches Werkzeug in jedem Werkzeugkasten.

Das Dashboard zeigt Attention und Meditation in Echtzeit unter Ihrer Dashboard-URL. Mehr Infos zu Dashboards hier.

Kurzes Upgrade für alle, die nur einen Roboter mit Gedanken steuern wollen

Sie wollen nicht das ganze Projekt bauen, nur einen gedanken-gesteuerten Roboter? Keine Sorge, auch an Anfänger habe ich gedacht. Ich schrieb einen kommentierten Code, der einen Arduino Mini Pro (oder UNO), eine IR-LED und das Headset benötigt, um den Roboter zu steuern. Viele Leser wollen ein einfaches Wochenendprojekt – hier ist Beschreibung und Code.

Nutzen Sie den Code „RobotControlllerHeadset“ im Software-Bereich. IR-LED an Pin D3 am Mini Pro (oder UNO) anschließen, T-Pin des NeuroSky-Chips an RX-Pin des Arduino. Mit 3,3 oder 5 V versorgen – fertig. Roboter bauen, dann diesen Code im Headset nutzen:

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

Ein IoT-Jedi werden (Testen)

Nach allem, was hier erklärt wurde, bleibt nur eines: Ausprobieren. Nutzen Sie die Kraft Ihrer Gedanken, die Macht der Neuronen in Ihrem Gehirn – bewegen Sie Ihren kleinen Roboter, steuern Sie Ihr Zuhause, steuern Sie alles mit Gedanken…

Jetzt sind Sie ein echter IoT-Jedi!

Das Gerät hat viele Features und macht großen Spaß. Aber wie gesagt, es ist nicht nur ein Spielzeug – durch die Verbindung von Biologie und Elektronik schufen wir ein Gerät, das Menschen helfen kann, die täglich mit Behinderungen kämpfen, ihre natürlichen Fähigkeiten zurückzugewinnen.

Robotersteuerung ist einfach, Relais auch keine große Herausforderung. Sie müssen nur lernen, Ihre Aufmerksamkeitswerte zu kontrollieren, um die Maus zu steuern. Auf dem Bild versuche ich, eine App mit meinen Gehirnwellen zu schließen. Mehr Übung garantiert bessere Erfahrung.

Danke fürs Zuschauen!

Ich hoffe, Ihnen hat mein Projekt gefallen – schreiben Sie Ihre Meinung in die Kommentare. Ich wollte ein Video machen, aber das Programmieren war so aufwendig, dass ich keine Zeit für einen Film hatte. Ich werde es bald auf meinem YouTube-Kanal veröffentlichen und dieses Projekt aktualisieren.

Möge die Macht mit dir sein, immer!

Code

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

Particle Photon Code

// Webserver für "Use the Force... Or your Brainwaves?" Projekt
// Erstellt Statistik über Meditation und Attention
// Dank voll funktionsfähigem Particle Dashboard sehr simpler Code
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 UNO)

// "Use the Force or your Brainwaves?" Projekt
#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) { // Vorwärts
    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) { // Rückwärts
    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) { // Links
    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) { // Rechts
    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) { // Stopp
    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 Konfiguration
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); // Master
  Serial.println("AT+PAIR=your_address,9"); delay(1000); // Auto-Connect
  Serial.print("AT+BAUD7"); // 57600 Baud
  Serial.begin(57600);
}
void loop() {}

Mouse Controller Code (Arduino Leonardo)

// Maussteuerung über Serial-Signale
#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; // hoch
      case 'd': Mouse.move(0, 8); break;  // runter
      case 'l': Mouse.move(-8, 0); break; // links
      case 'r': Mouse.move(8, 0); break;  // rechts
      case 'c': Mouse.click(MOUSE_LEFT); break; // klick
    }
  }
}

Arduino_Mega_Server (Hauptcode)

/* Arduino Mega Code für "A Tool for the Mind" von Imets Tams, 2.2.2016
   Analysiert und organisiert eingehende Bluetooth-Signale vom Gehirnwellensensor
   Frei zu bearbeiten, aber bitte Credit geben.
   Variablennamen basieren auf Familiennamen I.M.E.T.S. – änderbar.
   Mehr Details: https://www.instructables.com/member/Imetomi/ oder 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); // → Particle Photon
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
Brain brain(Serial); // Bluetooth über Hardware-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(); } // Exit
    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 (attention > 0 && attention < 25) { mouse.println('l'); webserver.println("a"); }
    if (attention > 26 && attention < 50) { mouse.println('r'); webserver.println("c"); }
    if (attention > 51 && attention < 75) { mouse.println('u'); webserver.println("f"); }
    if (attention > 76 && attention < 100) { mouse.println('d'); webserver.println("h"); }
    if (meditation > 70) { mouse.println('c'); webserver.println("t"); }
  }
}

RobotControllerHeadset.ino (für einfachen IR-Roboter)

#include <IRremote.h>
#include <IRremoteInt.h>
#include <Brain.h>
IRsend irsend;
Brain brain(Serial);
const int ledPin = 3;
long interval = 500, previousMillis = 0;
int ledState = LOW, 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); }
  }
}