Uw Robot Besturen met Hersengolven: Uitgebreid Arduino Project

Onderdelen en benodigdheden

Arduino UNO	1	Wordt gebruikt voor de robot.
Arduino Mega 2560	1	De hersenen van het project...
Arduino Leonardo	1	Muiscontroller
Particle Photon	1	Webserver Data Logger
Necomimi Hersengolf Kattenoren	1	EEG Sensor
SparkFun Dual H-Bridge Motor Drivers L298	1	Koop dit als u uw eigen motordriver niet wilt bouwen.
Relais Module	1	Koop deze module als u geen circuits wilt solderen.
HC-05 Bluetooth Module	1
HC-06 Bluetooth Module	1
LED (standaard)	3
Weerstand 330 ohm	3
Algemene Doel Transistor NPN	3
Male/Female Jumper Wires	1
Jumper wires (standaard)	1
Solderloos Breadboard Half Size	1

Benodigde tools en machines

Soldeerbout (standaard)

Apps en online diensten

Brain Visualizer (alleen nodig voor experimenten)

Over dit project

Als kind wilde ik altijd een speciale vaardigheid hebben, zoals voorwerpen bewegen met gedachten of vliegen. Ik probeerde voorwerpen te bewegen met "de kracht van mijn gedachten", natuurlijk zonder succes. Nou ja, ik was en ben een enorme Star Wars-fan, maar ik houd ook van elektronica en programmeren, waarom zou ik deze twee dingen niet combineren om een ongelofelijk project te bouwen?

U vindt alle onderdelen, codes en bibliotheken met links in de Hardware- en Software-sectie.

Uw Robot Besturen met Hersengolven: Uitgebreid Arduino Project

Het hoofdconcept is dat door verschillende hersengolven de gebruiker in staat zal zijn om een robot te besturen, de muis op zijn PC of lichten in zijn huis aan/uit te zetten, terwijl een microcontroller (Particle Photon) een online analyse maakt over de hersengolven van de gebruiker. Dit is een perfecte methode om ziekten of stress en slaapstaat te detecteren. Dit kan ook worden gebruikt om mensen te helpen hun leven beter te leven, leren om hun emoties te controleren en hoe men altijd gelukkig kan zijn. De menselijke hersenen hebben balans nodig, om gezond te zijn, moeten we slapen, denken, bewegen... Met de Particle Photon en de webserver die gemaakt is door de oprichters van Particle kunnen we mensen helpen hun natuurlijke hersenbalans te vinden. Een kinderdroom leidde me tot dit project, en ik ben heel blij dat ik het gemaakt heb.

Maar als we Star Wars en de Kracht even aan de kant zetten, is dit apparaat niet alleen voor luie mensen of fans, het is gemaakt om een vaardigheid terug te geven aan mensen die elke dag vechten met hun beperking. De robot die ik ontwierp werkt op dezelfde manier als een rolstoel, het huisautomatiseringssysteem zou de gebruiker helpen om lichten of TV's te bedienen zelfs als hij/zij niet kan bewegen. De PC-controllermodus kan zelfs nuttig zijn voor diegenen die perfect gezond zijn. Ik denk dat we allemaal willen computergames spelen of gewoon op internet surfen met alleen gedachten.

Bekijk deze korte introductievideo over het verhaal van het project:

De Wetenschap Achter het Project

Elektroencephalografie (EEG) is een electrofysiologische bewakingsmethode om de elektrische activiteit van de hersenen vast te leggen. Het is doorgaans non-invasief, met de elektraden langs de hoofdhuid geplaatst, hoewel invasieve elektraden soms in specifieke toepassingen worden gebruikt. EEG meet spanningsfluctuaties die voortkomen uit ionische stroom binnen de neuronen van de hersenen. Diagnostische toepassingen richten zich doorgaans op de spectrale inhoud van EEG, dat wil zeggen, het type neurale oscillaties (populair "hersengolven" genoemd) die in EEG-signalen waargenomen kunnen worden. (dank u Wikipedia) Maar we gaan twee zeer nauwkeurige waarden gebruiken:

Alpha is het frequentiebereik van 7 Hz tot 14 Hz. Het ontstaat bij het sluiten van de ogen en bij ontspanning, en vermindert bij het openen van de ogen of mentale inspanning.
Beta is het frequentiebereik van 15 Hz tot ongeveer 30 Hz. Lage amplitude bèta met meerdere en variërende frequenties wordt vaak geassocieerd met actieve, drukke of angstige denkactiviteit en actieve concentratie.

Hoe werkt het?

Ik gebruikte vier microcontrollers om dit project tot leven te wekken: een Arduino Mega, een Arduino Leonardo, een UNO en een Particle Photon. De Mega is de hersenen van het project die signalen ontvangt van het headset, analyseert en vervolgens commando's doorstuurt naar de andere apparaten. Het stuurt alle data door naar de Photon die de webserver creëert. De Leonardo bestuurt de muis op een PC en de Uno wordt gebruikt om IR (infrarood signalen) te ontvangen en de robot te besturen. Zoals ik zei, is het apparaat in staat om drie verschillende dingen te besturen (of meer als u ergens anders voor wilt programmeren). Noem nu deze drie verschillende dingen kanalen. Het apparaat schakelt tussen deze kanalen als u uw ogen sluit:

Sluit uw ogen voor 1-2 seconden: schakelt naar huisautomatisatiefunctie
Sluit uw ogen voor 2-4 seconden: schakelt naar robotcontrollermodus
Sluit uw ogen voor 1-6 seconden: schakelt naar muiscontrollermodus

Ik gebruikte relais om de huisautomatisatiefunctie te maken; u kunt er alles aan verbinden: TV, gloeilampen, wandstopcontacten, wat u maar wilt.

Het draadloze headset:

Ik hou van het hacken van speelgoed, dus ik kocht een hersengolf-meetend speelgoed genaamd Necomimi, dat in staat is om zijn oren te bewegen afhankelijk van uw hersengolven (aandacht, meditatie). Dit is de meest nutteloze speelgoed die ik ooit zag, maar er zit een kleine chip in die hersengolven leest, ruis filtert en een heel goed signaal geeft. Het werkt met UART (Serieel) interface, dus met wat hacken kunnen we Arduinos gebruiken om hersengolven te lezen. De rol van dit headset is om hersengolven draadloos door te sturen naar de centrale server. Niemand wil kabels op zijn hoofd, dus ik creëerde dit comfortabele en gebruiksvriendelijke headset.

Scroll naar beneden om te zien hoe u het uit elkaar kunt halen en een draadloos Bluetooth-headset ervan kunt maken.

Hoe te gebruiken?

We hebben twee meetbare eSense-waarden (NeuroSky-waarden): meditatie van 0 tot 100 en aandacht van 0 tot 100. Hoe meer gefocust u bent, hoe hoger de aandachtswaarde wordt. Hoe meer ontspannen u bent, hoe hoger het meditatieniveau wordt.

Het systeem werkt met gedachten, niets anders is nodig dan leren hoe gefocust of ontspannen te zijn. Na een week experimenteren was ik in staat om mijn "aandacht"-waarde heel nauwkeurig te controleren. Ik kan mijn aandachtniveau bewust instellen op ongeveer 15, of 39, 65 en 90. U moet ontdekken hoe u uw waarden kunt controleren, we zijn allemaal anders. Het werkte heel goed met emoties. Nadenken over liefde, vriendschap, woede of angst geeft een heel goed contrast in de waarden.

Om het systeem aan te zetten, plug een micro-USB kabel in de Arduino Leonardo. Dit zal ook uw muis besturen (als u dat wilt) en zorgt voor 5 volt en 500mA voor het systeem.

De Huisautomatisering Besturen

Als u bent overgeschakeld naar de huisautomatisatiemodus, verhoog uw aandachtsniveau boven de 70 om het eerste relais aan te zetten, verhoog het meditatieniveau boven de 70 om het tweede relais aan te zetten, en verhoog beide boven de 70 om het derde relais aan te zetten. Het is een beetje tricky, maar niet onmogelijk na wat geoefend. Als het al aanstaat, gebruik dan hetzelfde commando om het uit te zetten (dus als het aanstaat, bereik opnieuw 70 om het uit te zetten). Wanneer het systeem klaar is, kunt u elk hoogspanningsapparaat (licht, TV, PC, koelventilator, wat u maar wilt) aan de relaismodule verbinden.

De Muis Besturen

De cursor wordt bestuurd met emoties. Als het aandachtniveau onder de 25 is, beweegt hij naar links, als het tussen 25 en 50 is, beweegt hij naar rechts, als het tussen 50 en 75 is, beweegt hij naar boven en als het tussen 75 en 100 is, beweegt hij naar beneden. U kunt klikken door het meditatieniveau te verhogen. Zoals ik eerder zei, kan het aandachtniveau gemakkelijk worden beheerst met emoties (voor mij).

De Robot Besturen

De robot heeft alleen drie verschillende toestanden: stop, links draaien, en vooruit rijden. Waarom alleen twee bewegingsopties? Omdat deze twee richtingen voldoende zijn om de robot overal heen te sturen waar u wilt. Gebruik uw meditatieniveau om te draaien met de robot, en wanneer u de richting bereikt heeft waar u naartoe wilt gaan, stop de robot en rij vooruit met het aandachtniveau. Het is een betere methode om de robot te besturen en zelfs beginners, die hun aandachts/meditatiewaarden niet zo goed kunnen controleren, kunnen met deze robot spelen.

Mijn Plan

Dit is een oudere afbeelding van mijn plan, maar ik slaagde erin dus ik ben heel blij met de resultaten. De headset verstuurt BT (Bluetooth) signalen naar de Arduino Mega die de binnenkomende bytes analyseert en afhankelijk van de gedachten van de gebruiker de verschillende functies bestuurt. Het was heel moeilijk om de beste manieren te vinden om deze hoeveelheid data te transmitteren, maar ik koos voor Bluetooth in plaats van WiFi. In eerste instantie wilde ik de Particle Photon als datatransmitter gebruiken, maar die kleine kerel kreeg een betere rol bij het maken van de webserver. Dat was de grootste wijziging in het hele project. (Op de afbeelding ziet u het actuele plan). Ik gebruikte zelfgemaakte Arduino-modules, omdat ik hou van het ontwerpen van mijn eigen circuits. U kunt deze modules online kopen als u wilt of ze zelf met mij bouwen.

Een Half Jaar Leren en Experimenteren

Ik heb heel hard aan dit project gewerkt en ja, ik begon bijna een half jaar geleden, maar met de Photon ging het versneld. Het was heel gemakkelijk om hun dashboard te gebruiken. Overigens zijn er veel tutorials op internet over het hacken van EEG-speelgoed, dat hielp me een beetje, maar ze hadden geen extra functies. Dus ik besloot dat ik dit Necomimi-speelgoed zou hacken en met mijn creativiteit dit apparaat zou creëren dat veel meer functies heeft dan een LED laten knipperen. Hopelijk geniet u ervan!

Laten we beginnen!

De Necomimi Speelgoed Hacken

We willen dit EEG-speelgoed aanpassen om data via Bluetooth te transmitteren, dus haal de behuizing los. De schroeven zitten onder het sticker. Haal het sticker en de achterkant van het apparaat af en u vindt er een klein circuit in. De chip die onder het hoofdcircuit zit, is de Neurosky TGAM-chip. Deze is met vier header-pins verbonden met het hoofdmicrocontrollerbord, dus pak een soldeerbout en verwijder dit circuit voorzichtig. Soldeer nu drie draden aan de GND-pin, de VCC-pin en de T-pin. De T-pin is de zenderpin met 57600 baudrate, dit stuurt datapakketten naar onze microcontroller, maar ik verbond deze direct met een HC-06 slave BT-module. De HC-06 is ingesteld op 9600 baudrate, maar maak u geen zorgen, we lossen dit probleem op. Als u de drie draden heeft gesoldeerd, kunt u uw eigen herlaadbare voedingsbron inbouwen. Ik gebruikte een 500mAh Li-Ion-batterij, een USB-oplaadcircuit, een 5V opwaartscircuit en twee weerstanden (100 ohm en 200 ohm) om een perfecte 3,4 volt voeding voor de chip en de Bluetooth-module te garanderen. Volg het schema om het circuit te bouwen dat in het headset nodig is. Als het circuit klaar is, configureer de Bluetooth-module.

Over de chip:

De Neurosky ThinkGear AM is ontworpen om te filteren, te versterken en data via seriele interface te verzenden. Meer info hier.

Het Schema / Electronica

Volg de instructies en de afbeeldingen hieronder en maak uw eigen draadloze EEG-headset.

U hebt een 500mAh Lithium-Ion-batterij nodig, een 5V opwaarts-spanningsmodule om een stabiele spanning te creëren, dan een 100 Ohm en 200 Ohm weerstand om de spanning te verlagen tot een stabiele 3,3 Volt. Ik soldeerde female header-pins om de Bluetooth-module te voeden en data naar te sturen.

Het belangrijkste deel is om de "T" pin met de "RX" op de Bluetooth-module te verbinden. Dit brengt ons project tot leven.

Bluetooth-modules Configureren

HC-06: Laad eerst de sketch genaamd "HC_06_Bluetooth" op een Arduino UNO en sluit de Bluetooth-module aan zoals het schema toont. Ik vond dit schema op de website van het Artronix-team en leek nuttig.

void setup() {
  // Start de hardware serial.
  Serial.begin(9600); // standaard HC-06 baudrate
  delay(1000);
  Serial.print("AT");
  delay(1000);
  Serial.print("AT+VERSION");
  delay(1000);
  Serial.print("AT+PIN"); // om wachtwoord te verwijderen
  delay(1000);
  Serial.print("AT+BAUD7"); // Stel baudrate in op 57600 - bv Necomimi standaard
  delay(1000);
  Serial.begin(57600);
  // delay(1000);
}
void loop() { }

Open uw Seriële Monitor in de Arduino IDE en wacht tot de Arduino de BT-module configureert. Nu is uw Bluetooth-module ingesteld op 57600 baudrate. U kunt nu veel BCI (Brain Computer Interface) apps uitproberen, want deze gehackte Bluetooth Necomimi-speelgoed zal compatibel zijn met elke Neurosky-app.

U kunt deze apps gebruiken om te leren uw hersengolven en waarden te controleren, zoals aandacht of meditatie. U kunt veel coole games uitproberen, maar ik raad deze apps aan (ze zijn compatibel met PC, iOS en Android):

https://store.neurosky.com/products/brainwave-visualizer-android

https://store.neurosky.com/products/eeg-analyzer

https://store.neurosky.com/collections/android/products/blink-camera-android

Gebruik dan de "HC_05_Bluetooth" en laad deze op uw Arduino op dezelfde manier als eerder. Verbind de "EN"-pin van de HC-05 met de 3v3 van de Arduino. U moet het adres van uw HC-06-module in de code schrijven. Controleer het adres van de BT-module met een Android-smartphone, zoals ik. Vervang ":" (dubbele puntjes) door "," komma's in de code.

En u moet het adres in de code wijzigen:

20:15:09:15:17:82 ==> 2015,09,151782 Op deze manier kan de HC-05-module het adres herkennen. Laat gewoon enkele ":" achter, omdat ze niet nodig zijn.

// HC-05 configuratie
void setup() {
  // Start de hardware serial.
  Serial.begin(9600); // standaard HC-05 baudrate
  delay(1000);
  Serial.print("AT");
  delay(1000);
  Serial.print("AT+VERSION");
  delay(1000);
  Serial.println("AT+ROLE=1"); // stel de HC-05 in op mastermodus
  delay(1000);
  Serial.println(" AT+LINK=kopieer hier uw adres"); // nu zou de module automatisch moeten verbinden
  delay(1000);
  Serial.print("AT+UART=57600,1,0"); // Stel baudrate in op 57600
  Serial.begin(57600);
  // delay(1000);
}
void loop() { }

Ten slotte zouden de twee modules met elkaar moeten verbinden. Als u problemen heeft, klik op deze link om meer te lezen.

De Draadloos Bestuurde Robot

Om deze goedkope robot te maken, gebruikte ik 38kHz IR-technologie, die wordt gebruikt in TV-afstandsbedieningen. Ik kocht van Amazon een chassis voor mijn robot. De IR-ontvanger is gesalvaged van een oude TV en de Arduino is ook van Amazon. Ik heb links naar de onderdelen toegevoegd (zie beneden in de Hardware-sectie).

De Motordriver-circuit

U heeft deze onderdelen nodig:

2 Schroefklemmen
L293D IC
3 Header Pin
9 Header Pin (90 graden)
1k Weerstand
Rode LED
Draden
Een PCB-bord

Ik gebruikte enkele koperen draden en volgens het schema de pinnen van de IC verbonden met de header-pins. Het maakt niet uit welke pin naar welke header-pin gaat, onthoud alleen waar u ze verbonden hebt. De LED is in serie met de weerstand en parallel met de 5V VCC aangesloten.

Het Chassis Monteren

Deze stap was heel makkelijk, met een schroevendraaier en wat knutselvaardigheden bouwde ik de frame in vijf minuten. Daarna komt het moeilijkere deel: we moeten een motordriver-circuit bouwen. Om mijn motoren te besturen, koos ik de L293D IC die twee motoren kan aansturen. Kijk naar het schema om het circuit te bouwen.

De Onderdelen Aansluiten op de Arduino

Ik gebruikte jumper wires om de sensor en de motordriver aan de Arduino te verbinden.

Arduino Pin ==> Motordriver

4 ==> 15

5 ==> 10

6 ==> 7

7 ==> 2

VIN ==> 8

5v ==> 1, 9, 16

GND ==> 4, 5, 13, 12

Kijk dus naar het schema van de L293D-module, en verbind de pinnen met de Arduino UNO zoals hierboven geschreven. De 5v-pin van de Arduino moet verbonden worden met de 1, 9, 16 pinnen om de motordriver-functie van de IC in te schakelen. Gebruik tenslotte de schroefklemmen om de motoren te voeden.

Code Schrijven…

Met de IRremote-bibliotheek creëerde ik een code die 38kHz infraroodsignalen leest, decodeert, en dan de robot beweegt. (Download de bibliotheek in de Code-sectie).

Ik voegde uitleg toe in de code, maar de kern is dat het IR-signalen decodeert die van de hoofserver komen, en vervolgens, afhankelijk van wat de gebruiker wil, de motoren beweegt die de robot vooruit laten rijden of links laten draaien. Download de code: "Robot_Code". Laad deze op uw Arduino en uw robot is compleet.

De Hoofdserver (Arduino Mega, Leonardo, Photon)

De server leest binnenkomende datapakketten van het draadloze headset. We zullen de geconfigureerde BT-module gebruiken om de verbinding tussen het headset en de server te garanderen. De Arduino Mega is de hersenen van het circuit, alles is met deze microcontroller verbonden: Bluetooth, infrarood-zender LED, webserver, en muiscontroller. De code is wat gecompliceerd, maar ik heb uitleg toegevoegd om het begrijpelijk te maken.

De Behuizing

Het is simpel maar ziet er geweldig uit. Ik zaagde twee 18x15 cm platen en gladde de randen met schuurpapier. Met enkele schroeven verbond ik ze met elkaar.

Het Relais-circuit

U heeft deze onderdelen nodig:

2n2222 transistor (3 stuks)
Germanium diodes (3 stuks)
330 ohm weerstanden (3 stuks)
1k Ohm weerstanden (3 stuks)
5V relais (3 stuks)
Hook-up draden
Header pins
PCB-bord

Een plaatje zegt meer dan duizend woorden, dus in plaats van te proberen te schrijven hoe u de onderdelen op de PCB moet verbinden, kijk naar het schema. Als de "Signal"-pin een signaal krijgt van de Arduino, schakelt het relais in. De transistor versterkt het signaal om voldoende stroom voor de relais te garanderen. We zullen pinnen 37-38-39 gebruiken om de HIGH-LOW-niveaus van elk relais te besturen.

Onderdelen in de Behuizing Monteren

Om de onderdelen op de plexiglas-behuizing te monteren, gebruikte ik dubbelzijdig wit tape. Dit ziet er netjes uit en houdt de circuits stevig op de behuizing.

De Server-circuitu

Deze server is softwarematig, dus het maken van het circuit is niet zo moeilijk. (Zie schema hieronder). U hoeft alleen de microcontrollers te voeden en verbinding tussen hen te maken. De IR-LED is verbonden met pin D3 en de relais met 37-38-39. D16 van de Arduino Mega gaat naar RX van de Photon en D18 naar RX van de Leonardo.

Verbinden met de Robot

De IR-LED's zijn verbonden met digitale pin D3 en met de IRremote-bibliotheek sturen we codes naar de robot. Het is vrij simpel. De IR-codes moeten hetzelfde zijn in de code van de robot. Als u denkt dat u klaar bent, kunt u het testen met uw camera. Het infraroodlicht ziet er paars uit op een foto, camera's kunnen het IR-licht detecteren. Deze truc werkt altijd.

De Code

Gebruik de "Arduino_Mega_Server" code in het Software-deel.

Ik heb heel erg geleden tijdens het schrijven van de codes. Ik moest drie verschillende microcontrollers programmeren, dus het was een grote uitdaging. Ik gebruikte de IRremote-, Brain-, SoftwareSerial- en Mouse-bibliotheken. (zie downloadlinks in het Software-deel). Maar nu is de code klaar en werkt het, dus u hoeft het alleen naar uw microcontrollers te uploaden. Download het .ino-bestand of kopieer/plak de code in uw IDE en gebruik het. De code voor de Particle Photon moet via de browser IDE worden geüpload. Om dit te doen, registreer u bij Particle Build. En verbind uw laptop met uw microcontroller. Ik was echt verrast dat dit bijna automatisch gebeurde, ik moest alleen mijn Device ID-nummer toevoegen.

Voordat u de codes laadt, zorg ervoor dat niets verbonden is met de RX/TX-pinnen. Dus koppel uw Bluetooth-module van de Mega los, en koppel de Mega van de Leonardo en de Photon los.

De Muiscontroller

De Webserver

Ik wilde een IoT-functie (Internet of Things) in mijn project toevoegen, dus ik maakte een online datalogger met behulp van de Particle Photon. Afhankelijk van wat u met het apparaat doet, creëert de Photon een persoonlijke server en schrijft de data in de Cloud.

Dit kan op het eerste gezicht eng lijken, maar stel u voor dat u kunt detecteren of u gestrest bent (aandachtsniveau stijgt en daalt snel) of of u moet slapen (meditatieniveau is altijd hoger dan 80). Deze webserver kan u helpen gezonder te leven.

De Particle heeft ook een online dashboard waar u elke soort data kunt publiceren met de syntaxis "Particle.publish();". We moeten een groot "dank u" zeggen aan de ontwikkelaars van het dashboard. Ze hebben ons veel tijd bespaard.

Code schrijven in een browser?

Het was interessant om code op een webpagina te schrijven, maar het werkte op dezelfde manier als de normale IDE. De code werd draadloos geüpload. Deze microcontroller zou een heel nuttig hulpmiddel in ieders gereedschapskist zijn.

Het dashboard ziet er ongeveer zo uit als u goed heeft gewerkt. Toont Aandacht en Meditatie, en u kunt ze altijd controleren, op uw dashboard-URL. Voor meer info over de dashboards, klik hier.

Een Snelle Upgrade voor Wie Alleen een Robot Wil Besturen met Hersengolven

U wilt niet het hele project bouwen, alleen een hersengolf-gestuurde robot? Maak u geen zorgen, als u een beginner bent, heb ik zelfs aan u gedacht. Ik maakte een code met uitleg die een Arduino Mini Pro en een IR-LED nodig heeft en natuurlijk het headset om de robot te besturen. Ik weet dat veel van mijn lezers een eenvoudig en leuk weekendproject willen maken, dus hier is de beschrijving en de code voor u.

Gebruik de "RobotControlllerHeadset" code in de Software-sectie. Verbind een IR-LED met de D3-pin op de Mini Pro (of Arduino UNO) en verbind de T-pin van de NeuroSky-chip met de RX-pin van de Arduino. Voed met 3,3 of 5 volt en u bent klaar. Bouw de robot, en gebruik dan deze code in uw 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() {
  // Stel de LED-pin in.
  pinMode(ledPin, OUTPUT);
  // Start de hardware serial.
  Serial.begin(57600);
}

void loop() {
  // Verwacht pakketten ongeveer één keer per seconde.
  if (brain.update()) {
    Serial.println(brain.readCSV()); // Aandacht loopt van 0 tot 100.
    medValue = brain.readMeditation();
  }
  // Zorg dat we een signaal hebben.
  if(brain.readSignalQuality() == 0) {
    // Stuur een signaal naar de LED.
    if (medValue > 65) {
      irsend.sendNEC(0xFF10EF, 32);
      delay(40);
    }
    if (brain.readAttention() > 65) {
      irsend.sendNEC(0xFF18E7, 32);
      delay(40);
    }
  }
}

Een IoT Jedi Worden (Testen)

Na alles te maken wat ik hier uitlegde, is er nog maar één ding over: probeer het uit. Gebruik de kracht van uw geest, gebruik de Kracht van de neuronen in uw hersenen, beweeg uw kleine robot, bestuur uw huis, bestuur alles met gedachten...

Nu bent u een echte IoT Jedi!

Het apparaat heeft veel functies en is heel leuk om mee te spelen. Maar zoals ik eerder zei, is het niet alleen een speelgoed, met biologie en elektronica creëerden we een apparaat dat mensen kan helpen, die elke dag vechten met hun beperkingen, hun natuurlijke mogelijkheden terug te krijgen.

De robot kan gemakkelijk worden bestuurd, de relais zijn ook geen grote uitdaging. U hoeft alleen te leren hoe u uw aandachtsniveaus kunt controleren om de muis te besturen. Op de afbeelding probeer ik een app te sluiten met mijn hersengolven. Meer oefening garandeert een betere ervaring.

Dankjewel voor het kijken!

Ik hoop echt dat u mijn project leuk vond en schrijf uw mening in de reacties. Ik wilde een video maken over het apparaat, maar coderen was zwaar dus ik had niet genoeg tijd om een korte film te maken, maar ik zal het binnenkort op mijn YouTube-kanaal publiceren en deze projectpresentatie ook bijwerken.

Moge de Kracht met u zijn, altijd!

Code

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

Particle Photon Code

Kopieer dit in uw browser IDE en upload naar de Particle Photon. Open het dashboard om de resultaten in realtime te zien.

//dit is de code voor de webserver voor een "Use the Force... Or your Brainwaves?" project
//creëert een statistiek voor de gebruiker over zijn/haar hersengolven meditatie en aandachtsniveau
//bedankt aan het volledig functionerende dashboard van de Particle is de code heel simpel
int att;
int med;
int function;

void setup() {
  Serial.begin(9600);
}

void loop() {
  // Publiceer data
  Spark.publish("Attention", (att) + "%");
  delay(2000);
  Spark.publish("Meditation", (med) + "%");
  delay(2000);
  Spark.publish("Last Function", (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

Deze code bestuurt de robot. Upload naar de Arduino UNO. U kunt de IR-codes wijzigen als u wilt.

//Gebruikt voor "Use the Force or your Brainwaves?" project
#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(); // Ontvang de volgende waarde
  }
  if (results.value == 0xFF18E7) //als deze code ontvangen gaat vooruit
  {
    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(); // Ontvang de volgende waarde
  }
  if (results.value == 0xFF4AB5) //als deze code ontvangen gaat achteruit
  {
    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(); // Ontvang de volgende waarde
  }
  if (results.value == 0xFF10EF) //als deze code ontvangen draait 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(); // Ontvang de volgende waarde
  }
  if (results.value == 0xFF5AA5) //als deze code ontvangen draait 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(); // Ontvang de volgende waarde
  }
  if (results.value == 0xFF38C7) //als deze code ontvangen stopt
  {
    digitalWrite(motor_pin1,LOW);
    digitalWrite(motor_pin2,LOW);
    digitalWrite(motor_pin3,LOW);
    digitalWrite(motor_pin4,LOW);
    { Serial.println("Stop!"); }
  }
}

HC_05_Bluetooth.ino

Configureert HC-05 module.

// HC-05 configuratie
void setup() {
  // Start de hardware serial.
  Serial.begin(9600); // standaard HC-05 baudrate
  delay(1000);
  Serial.print("AT");
  delay(1000);
  Serial.print("AT+VERSION");
  delay(1000);
  Serial.println("AT+ROLE=1"); // stel de HC-05 in op mastermodus
  delay(1000);
  Serial.println(" AT+PAIR=kopieer hier uw adres,9"); // nu zou de module automatisch moeten verbinden
  delay(1000);
  Serial.print("AT+BAUD7"); // Stel baudrate in op 57600 - bv Necomimi standaard
  Serial.begin(57600);
  // delay(1000);
}
void loop() { }

Mouse Controller Code

Upload naar de Arduino Leonardo. Bestuurt de cursor op uw computer, afhankelijk van het signaal dat van de Arduino Mega ontvangen wordt.

//Code by Imets Tamas voor het Use the Force... Or your Brainwaves? project
//Beweegt de muiscursor via seriële signalen
#include <Mouse.h>

void setup() {
  Serial.begin(9600);
  // initialiseer muiscontrole:
  Mouse.begin();
}

void loop() {
  // gebruik seriële invoer om de muis te besturen:
  if (Serial.available() > 0) {
    char inByte = Serial.read();
    switch (inByte) {
      case 'u': // muis omhoog
        Mouse.move(0, -8);
        break;
      case 'd': // muis omlaag
        Mouse.move(0, 8);
        break;
      case 'l': // muis links
        Mouse.move(-8, 0);
        break;
      case 'r': // muis rechts
        Mouse.move(8, 0);
        break;
      case 'c': // linkermuisklik
        Mouse.click(MOUSE_LEFT);
        break;
    }
  }
}

Arduino_Mega_Server

Analyseert hersengolven, bestuurt alles...

/* Arduino Mega Code voor "A Tool for the Mind" project door Imets Tams, 2 februari 2016
Deze code analyseert en organiseert en stuurt vervolgens binnenkomende bluetooth seriële signalen van de hersengolfsensor door
Vrij om te bewerken, maar vergeet niet te crediteren.
Voor de variabele waarden gebruikte ik de karakters van de familienaam, u kunt ze wijzigen als u wilt: I. M. E. T. S.
Zie meer details op https://www.instructables.com/member/Imetomi/ of https://www.hackster.io/Imetomi */
#include <VirtualWire.h> // includeren bibliotheek
#include <SoftwareSerial.h> // includeren bibliotheek
#include <Brain.h> // includeren bibliotheek
#include <LiquidCrystal.h> // includeren bibliotheek
#include <IRremote.h>

int led = 13;
int medled = 50; // de LED die het meditatieniveau toont
int attled = 51; // de LED die het aandachtsniveau toont
int blinkled = 52;
char robot;
IRsend irsend; // IR led naar pin 3
SoftwareSerial mouse(18, 19); // RX, TX dit gaat naar het Leonardo-bord
SoftwareSerial webserver(16, 15); // gaat naar de Particle Photon om een webserver te maken
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // initialiseer de bibliotheek met de nummers van de interface-pinnen
Brain brain(Serial); // De Hersengolven worden gelezen met behulp van de bluetooth-module via hardware serial
int closedeye = (brain.readLowAlpha()); // om knipperen te detecteren
int attention = (brain.readAttention()); // om aandacht te lezen
int brainsignal = (brain.readSignalQuality()); // om signaalkwaliteit te lezen
int meditation = (brain.readMeditation()); // om meditatie te detecteren
int alpha = (brain.readHighAlpha()); // om gesloten oog te detecteren
int lightatt;
int lightmed;
int blinklength;
int prevsignal = 0;

void setup() {
  // hier gaan we de hoofdinstellingen instellen:
  mouse.begin(9600); // stel de baudrate in
  webserver.begin(9600); // stel de baudrate in
  Serial.begin(57600); // stel de baudrate in (57600 is de Necomimi's bits/seconden snelheid)
  lcd.begin(16, 2); // start het LCD-scherm
  pinMode(led, OUTPUT); // stel pinmodes in voor de leds en relais
  pinMode(attled, OUTPUT); // stel pinmodes in voor de leds en relais
  pinMode(medled, OUTPUT); // stel pinmodes in voor de leds en relais
  pinMode(blinkled, OUTPUT); // stel pinmodes in voor de leds en relais
  pinMode(37, OUTPUT); // stel pinmodes in voor de leds en relais
  pinMode(38, OUTPUT); // stel pinmodes in voor de leds en relais
  pinMode(39, OUTPUT); // stel pinmodes in voor de leds en relais
  lightatt = map(attention, 0, 100, 0, 255); // map het aandachtsniveau voor analogWrite de LED
  lightmed = map(meditation, 0, 100, 0, 255); // map het aandachtsniveau voor analogWrite de LED
}

void robotmode() {
  if (brain.update()) {
    if ((blinklength > 0) && (blinklength < 2000)) {
      // als u uw ogen 2 seconden dichtdoet
      loop(); // u verlaat de robotcontrollermodus
    }
    if (attention > 70) {
      irsend.sendNEC(0xFF18E7, 32); // vooruit
      webserver.println("g");
      delay(40);
    }
    if (meditation > 70) {
      irsend.sendNEC(0xFF10EF, 32); // draaien
      webserver.println("q");
      delay(40);
    }
  }
}

void loop() {
  if (brain.update()){
    analogWrite(attled, lightatt); // analog schrijf de aandachtsled om het actuele aandachtsniveau te tonen
    // hoe meer gefocust u bent, hoe harder de LED brandt
    analogWrite(medled, lightmed); // analog schrijf de aandachtsled om het actuele aandachtsniveau te tonen
    // hoe hoger meditatieniveau, hoe harder de LED brandt
    if ((closedeye > 30000) && (alpha > 30000)) {
      // we gebruiken 2 waarden om zeker te zijn dat het oog van de gebruiker dicht is
      digitalWrite(blinkled, HIGH); // in het engels: als ogen dicht zijn, brandt de LED
      blinklength = millis(); // tel milliseconden als oog dicht is
    } else if ((closedeye < 30000) && (alpha < 30000)) {
      digitalWrite(blinkled, LOW); // in het engels: als ogen open zijn, gaat de LED uit
      blinklength = 0;
    }
    if ((blinklength > 0) && (blinklength < 2000)) {
      // als u uw ogen 2 seconden dichtdoet
      webserver.println("a");
      delay(40);
      robotmode(); // u kunt de robot besturen
    }
    if ((blinklength > 2001) && (blinklength < 4000)) {
      // als u uw ogen 3-4 seconden dichtdoet
      webserver.println("a");
      delay(40);
      relay(); // u kunt het huisautomatiseringssysteem besturen
    }
    if ((blinklength > 4001) && (blinklength < 6000)) {
      // als u uw ogen 4-6 seconden dichtdoet
      webserver.println("a");
      delay(40);
      mousecontrol(); // u kunt de muis besturen
    }
    Serial.println(brain.readCSV()); // print data op seriële monitor, niet noodzakelijk, alleen voor testen
  }
}

void relay() {
  webserver.println("");
  if (brain.update()) {
    if ((blinklength > 0) && (blinklength < 2000)) {
      // als u uw ogen 2 seconden dichtdoet
      loop(); // u verlaat de relaiscontrollermodus
    }
    if(attention > 70) {
      // relais1 aan
      digitalWrite(37, HIGH);
      webserver.println("g");
      prevsignal = 1;
    }
    if(meditation > 70) {
      // relais2 aan
      digitalWrite(37, HIGH);
      webserver.println("q");
      prevsignal = 1;
    }
    if(1000 > blinklength > 0) {
      // relais3 aan
      digitalWrite(37, HIGH);
      webserver.println("qj");
      prevsignal = 1;
    }
    if((attention > 70) && (prevsignal == 1)) {
      digitalWrite(37, LOW);
      webserver.println("q");
      prevsignal = 1;
      // controleren of al aanstaat, dan uit
    }
    if((meditation > 70) && (prevsignal == 1)) {
      digitalWrite(37, LOW);
      webserver.println("qj");
      prevsignal = 1;
      // controleren of al aanstaat, dan uit
    }
    if((1000 > blinklength > 0) && (prevsignal == 1)) {
      digitalWrite(37, LOW);
      webserver.println("a");
      prevsignal = 1;
      // controleren of al aanstaat, dan uit
    }
  }
}

void mousecontrol() {
  // u hebt een paar uur oefening nodig om de cursor perfect te besturen
  webserver.println("z"); // data doorsturen naar webserver
  if(brain.update()) {
    if (0 < attention && attention < 25) {
      mouse.println('l'); // links
      webserver.println("a");
    }
    if (26 < attention && attention < 50) {
      mouse.println('r'); // rechts
      webserver.println("c");
    }
    if (51 < attention && attention < 75) {
      mouse.println('u'); // boven
      webserver.println("f");
    }
    if (76 < attention && attention < 100) {
      mouse.println('d'); // onder
      webserver.println("h");
    }
    if (meditation > 70) {
      mouse.println('c'); // klik
      webserver.println("t");
    }
  }
}

RobotControllerHeadset.ino

Voor wie een IR-robot wil bouwen.

#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() {
  // Stel de LED-pin in.
  pinMode(ledPin, OUTPUT);
  // Start de hardware serial.
  Serial.begin(57600);
}

void loop() {
  // Verwacht pakketten ongeveer één keer per seconde.
  if (brain.update()) {
    Serial.println(brain.readCSV()); // Aandacht loopt van 0 tot 100.
    medValue = brain.readMeditation();
  }
  // Zorg dat we een signaal hebben.
  if(brain.readSignalQuality() == 0) {
    // Stuur een signaal naar de LED.
    if (medValue > 65) {
      irsend.sendNEC(0xFF10EF, 32);
      delay(40);
    }
    if (brain.readAttention() > 65) {
      irsend.sendNEC(0xFF18E7, 32);
      delay(40);
    }
  }
}