Gedachte-gestuurde Drone: EEG gebruiken om een Micro Race Drone te Vliegen

Onderdelen en Benodigdheden

Onderdeel	Aantal
Arduino MKR1000	1
Micro Race Drone	1
Condensator 100 µF	4
Weerstand 221 ohm	4
Jumper wires (standaard)	12
Breadboard (standaard)	1
Mindwave Neurosky	1

Nodige Tools en Machines

• Solderbout (standaard)
• Digilent Schroevendraaier

Apps en Online Services

• Processing 3
• Arduino IDE

Over dit Project

Achtergrond

Ik vind drones fascinerend, die kleine vliegende machines die bijna alles kunnen. Toen ik de kans kreeg om een project met coole technologie te doen, besloot ik een jongensdroom waar te maken: een drone besturen met je gedachten.

In het onderzoek dat ik voor dit project deed, vond ik geen tutorials die uitleggen hoe je een drone-controller eenvoudig kunt hacken. De meeste tutorials gaan over hoe je je eigen drone bouwt met een Arduino of hoe je het transmissieprotocol haakt.

Deze tutorial dekt het meest basale concept van het hacken van een PCB om het digitaal te besturen. Het doel is je de basale concepten te leren die je in staat stellen om zelf te experimenteren met een drone en iets leuks te creëren.

Let Op

• Je kunt potentiëel je drone of controller kapmaken en onbruikbaar maken.
• Dit project dekt niet hoe je je drone stuurt, alleen opstijgen en landen.
• Je hebt niet per se een MindWave / EEG sensor nodig, je kunt elke input gebruiken. Maar een drone besturen met je gedachten is zuiver geweldig!

Video Tutorial

Bekijk de video tutorial voor visuele begeleiding.

Benodigde Vaardigheden

Deze tutorial veronderstelt dat je enige ervaring hebt met solderen en desolderen.

Onderdelenlijst

• Drone + controller
• Solderstation + accessoires (geflochten koperdraad, desolderpompen, helpende hand, massieve draad, soldeer)
• Multimeter
• MindWave sensor
• Arduino MKR1000
• Breadboard
• 4x 100uF condensators
• 4x 220Ω Weerstanden
• 12x Jumper wires
• 6 Krokodillenip draden (optioneel)

Je hebt ook 4 weerstanden met een nog onbekende weerstandswaarde nodig.

Fase 1: Drone PCB

Je kunt bijna elke drone gebruiken. De meeste controllers werken met twee-as joysticks. Die joysticks gaan we omzeilen.

Open eerst het behuizing van je controller. Deze controller gebruikt twee 1.5V batterijen wat ongeveer 3.3V is. Deze waarde is hetzelfde als de output van de Arduino MKR1000.

Het is mogelijk om een andere Arduino te gebruiken, maar wees je bewust dat je de printplaat kunt beschadigen als je meer spanning geeft dan de PCB aankan. (Ik spreek uit ervaring.)

Meet met een multimeter wat de middelste, hoge en lage spanningen zijn van de joysticks zodra gevoed. Noteer ze voor later gebruik.

Desolder de joystick componenten van de PCB.

In wezen zijn deze joystick componenten potentiometers. Een potentiometer is een analoog variabele weerstand. Je kunt de maximale weerstand met een multimeter meten. Verbind de multimeter met de + en - om de weerstand te lezen.

Solder (in dit geval 10Ω weerstanden) 4 weerstanden op de gaten van de + en - van de joysticks om de schakeling te completeren.

Solder ook massieve draden aan de + (B+ op deze print) en - (B- op deze print) poorten op de PCB. En solder massieve draden aan de signaalpoorten van de joysticks.

Nu is je controller klaar voor de volgende stap.

Fase 2: Digitaal naar Analoog

Wanneer je AnalogWrite gebruikt met je Arduino, is de output een PWM (Pulse Width Modulation) signaal. De pin zet zijn waarde HIGH en LOW in een vaste frequentie.

Onze voorbereide PCB houdt niet van PWM, het verwacht een constante spanning.

Om een analoog waarde te creëren kunnen we diverse digitale-naar-analoog converters gebruiken zoals een DAC chip of een RF ladder filter.

Omdat ik dit project zo simpel mogelijk wil houden, leer ik je hoe je een Laagdoorlaatfilter (Low Pass Filter) gebruikt, wat ons de gewenste output geeft.

Om een laagdoorlaatfilter te maken heb je een condensator en een weerstand nodig.

Een van de kenmerken van een laagdoorlaatfilter is dat de analoog spanning geleidelijk verandert (het duurt even). Dit circuit werkt het beste voor mij omdat het de gewenste uitkomst geeft en weinig onderdelen gebruikt.

Fase 3: Het Arduino Circuit

Het hoofddeel van ons circuit is het laagdoorlaatfilter dat we net creëerden. Maak er vier in een rij en we hebben een analoog spanning voor alle vier de controller inputs.

Verbind de juiste outputs met de juiste ingangen op de controller PCB. Zorg dat je het correct hebt voordat je de Arduino Sketch uploadt.

De standaard drone layout is als volgt:

• Throttle (Gas) => boven/onder aan de linkerkant van de controller
• Yaw (Gieren) => links/rechts aan de linkerkant van de controller
• Pitch (Nicken) => boven/onder aan de rechterkant van de controller
• Roll (Rollen) => links/rechts aan de rechterkant van de controller

Zodra alles verbonden is, kun je je sketch uploaden naar je Arduino MKR1000. Je vindt de sketch aan de onderkant van deze tutorial.

De Arduino vervangt de batterijen en kan signalen (als spanningen) sturen naar de overgeslagen joysticks. Op dit moment kun je je eigen programma's en experimenten bouwen om de drone met PWM te besturen.

Ik zal je nu laten zien hoe je Processing en een MindWave sensor kunt gebruiken om de drone te laten opstijgen.

Fase 4: Gedachtebesturing

Installeer alle drivers op je computer. Deze MindWave sensor wordt geleverd met een CD.

Koppel de MindWave sensor met je computer via Bluetooth. Houd de knop 3 seconden ingedrukt en de blauwe LED knippert tweemaal, het is nu detecteerbaar.

Zodra verbonden, start Processing.

Installeer de MindSet bibliotheek gemaakt door Jorge C. S Cardoso voor Processing van https://jorgecardoso.eu/processing/MindSetProcessing/#download

Pak de bibliotheek uit in je libraries map. Je vindt de libraries map in je Processing map.

Zorg dat je com-poorten correct zijn in de setup, anders krijg je een fout. Je vindt de com-poorten in je apparaatbeheer.

Je vindt ook de com-poort van de Arduino onder "Tools" in de Arduino IDE bij "Port".

Je vindt ook de com-poort van de MindWave sensor in de ThinkGear Connector Preferences (je krijgt dit programma bij installatie van de drivers) onder "Options".

receiver = new Serial(this, "COM10", 115200);
mindSet = new MindSet(this, "COM5");

Processing communiceert met je Arduino via Serial. Je kunt de Processing code naar wens aanpassen, lees de commentaren in de sketch om te begrijpen wat er gebeurt.

Start je Processing sketch en concentreer je op je drone. Wanneer je concentratieniveau boven de 40% komt, zal de drone opstijgen. Hoe harder je je concentreert, des te agressiever de drone zal zijn. Je kunt de drone laten landen door je gedachten te laten dwalen en te stoppen met concentreren.

Conclusie

Ik hoop dat deze tutorial je wat inzicht gaf in hoe simpel het kan zijn om een drone-controller (of elke PCB) te hacken en het een andere input te geven. Je kunt met experimenteren ontdekken hoe je andere inputs kunt gebruiken om te besturen en hoe je andere bewegingen kunt maken naast opstijgen en landen.

Ik ben benieuwd wat jullie coole dingen gaan maken!

Code

Processing Master

/* 
 * Drone gedachtebesturing 
 * 
 * Deze sketch stuurt Serial waarden naar een ontvanger 
 * 
 * De input wordt gegenereerd via een Neurosky MindSet Mobile headset 
 * 
 * Gemaakt 21 maart 2018 
 * Door Wesley Hartogs 
 * Communicatie en Multimediadesign 
 * Avans Hogeschool 
 * 
 */ 
// importeer Serial bibliotheek
import processing.serial.*;
// Definieer ontvanger Serial
Serial receiver;
// Importeer MindSet bibliotheek
import pt.citar.diablu.processing.mindset.*;
MindSet mindSet;
// Stel initiële waarden in
int throttle = 0;
int yaw = 127;
int pitch = 127;
int roll = 127;
void setup() {
  size(150, 500);
  // Initieer Serial communicatie op COM10
  receiver = new Serial(this, "COM10", 115200);
  // Initieer MindSet communicatie
  // De MindSet gebruikt Bluetooth Serial communicatie,
  // Controleer de COM-poort in de ThinkGear Connector in je Apparaatbeheer
  mindSet = new MindSet(this, "COM5");
  // Schakel anti-aliassing in
  smooth();
  // Stel strekeigenschappen in
  strokeWeight(5);
  stroke(255);
  strokeCap(SQUARE);
  // Stel vulkleur in
  fill(255);
}
// setup()
void draw() {
  // Begin met zwarte achtergrond
  background(0);
  // Teken horizontale lijn op 40% vanaf onderen
  // Deze lijn geeft de minimale (40%) aandacht aan die nodig is
  line(0, height*0.60, width, height*.60);
  // Teken een lijn van het horizontale centrum naar boven
  // Deze lijn geeft een indicatie van je aandacht
  // De hoogte is omgekeerd gemapt om een percentage van boven te krijgen
  // Voorbeeld: bij 40% (0.4) aandacht is de hoogte waarde (100 - 40) 60% (0.6) vanaf boven
  line(width*.5, height, width*.5, height*map(float(attentionLevel) / 100, 0, 1, 1, 0));
  // Duw het aandachtsniveau naar de throttle variabele
  // 40 = minimum aandacht nodig om iets te doen
  // 100 = maximum aandacht
  // 30 = 8-bit min waarde voor Arduino
  // 255 = 8-bit max waarde voor Arduino
  throttle = int(map(attentionLevel, 40, 100, 30, 255));
  // Beperk waarden tot 8-bit waarden om fouten te voorkomen
  throttle = constrain(throttle, 0, 255);
  pitch = constrain(pitch, 0, 255);
  roll = constrain(roll, 0, 255);
  yaw = constrain(yaw, 0, 255);
  // Wanneer er communicatie mogelijk is, stuur de waarden naar de Arduino ontvanger
  if (receiver.available() > 0) {
    println("attentionLevel: " + attentionLevel + " throttle: " + throttle + " yaw: " + yaw + " pitch: " + pitch + " roll: " + roll);
    receiver.write("throttle: " + throttle + " yaw: " + yaw + " pitch: " + pitch + " roll: " + roll);
  }
}
// draw()
// Noodstop, druk K om te resetten en het programma te sluiten
void keyPressed() {
  if (key == 'k' || key == ESC) {
    if (receiver.available() > 0) {
      receiver.write("throttle: " + 0 + " yaw: " + 127 + " pitch: " + 127 + " roll: " + 127);
      exit();
    }
  }
}
// MindSet variabelen en functies
int signalStrenght = 0;
int attentionLevel = 0;
public void attentionEvent(int attentionLevel_val) {
  attentionLevel = attentionLevel_val;
}
// Deze functie wordt geactiveerd wanneer de verbinding met de MindSet niet optimaal is
public void poorSignalEvent(int signalNoise) {
  // MindSet is aan het aanpassen
  if (signalNoise == 200) {
    println("Mindset raakt je huid niet!");
  }
  // Map de signaalsterkte naar een percentage
  signalStrenght = int(map((200 - signalNoise), 200, 0, 100, 0));
  println("Signaalsterkte: " + signalStrenght + "%");
}

Drone Control

/* 
 * Drone besturing 
 * 
 * Deze sketch ontvangt Serial input waarden (van processing) en stuurt deze waarden naar de gehackte controller. 
 * Gebruik dit programma alleen met de Arduino MKR1000 (of een andere 3.3 volt output gebaseerde Arduino) 
 * 
 * Het circuit:
 * - 4 Laagdoorlaatfilters met 100 µF condensators en 220Ω weerstanden
 * - Gehackte drone controller
 * 
 * Gemaakt 21 maart 2018 
 * Door Wesley Hartogs 
 * Communicatie en Multimediadesign 
 * Avans Hogeschool 
 * 
 * Gebruik deze sketch op eigen risico.
 * */ 
// Stel initiële waarden in
int throttle = 0;
int yaw = 255/2; // 3.3v / 2
int pitch = 255/2; // 3.3v / 2
int roll = 255/2; // 3.3v / 2
int throttlePin = 2; // PWM
int yawPin = 3; // PWM
int pitchPin = 4; // PWM
int rollPin = 5; // PWM
void setup() {
  // Start Serial communicatie op 115200 baud
  Serial.begin(115200);
  // Stel pinModes in
  pinMode(throttlePin, OUTPUT);
  pinMode(yawPin, OUTPUT);
  pinMode(pitchPin, OUTPUT);
  pinMode(rollPin, OUTPUT);
}
void loop() {
  // Wanneer er een Serial verbinding beschikbaar is, haal de waarden op
  if (Serial.available() > 0) {
    throttle = Serial.parseInt(); // Eerste integer waarde uit Serial buffer
    yaw = Serial.parseInt(); // Tweede integer waarde uit Serial buffer
    pitch = Serial.parseInt(); // Derde integer waarde uit Serial buffer
    roll = Serial.parseInt(); // Vierde integer waarde uit Serial buffer
  }
  // Schrijf waarden naar de drone controller
  // Gebruik een laagdoorlaatfilter of DAC (digitaal-naar-analoog converter) om PWM om te zetten naar een analoog spanning
  analogWrite(throttlePin, throttle);
  analogWrite(yawPin, yaw);
  analogWrite(pitchPin, pitch);
  analogWrite(rollPin, roll);
}

Schema's

Converteer PWM signaal naar analoog spanning

Circuit om Arduino MK1000 te verbinden met de gehackte controller