Talking Sword Video

I shot a short video of the sword in a more finished version. It could still use some touches, but I think it already looks pretty damn awesome. And it talks!

If someone is interested I'll translate the how-to stuff in English, so if you are leave a comment below.

Sprekend Zwaard (hout, foto's en video)

In de Maakbare Wereld van 2 juli kun je lezen over mijn sprekende zwaard. In mijn andere blog post kun je lezen over de elektronica kant van het verhaal. Maar zonder een omhulsel is het natuurlijk niks.

Ik heb mijn zwaard uit hout gemaakt omdat dat makkelijker te bewerken is zo thuis op de keukentafel :) De basis is een flinke lat waar ik grof de vorm op getekend heb en met een decoupeerzaag uitgezaagd. Vervolgens heb ik middenlijnen op alle zijdes getekend heb hier met vijlen naartoe geschuurd. Uiteindelijk met schuurpapier wat afgewerkt. Met beitels heb ik de naam van mijn zwaard gekerfd in runen schrift.

Om plaats te maken voor de elektronica heb ik in de kling met een beitel plek gemaakt. De batterij kwam aan de bovenkant en de Teensy en de speaker aan de onderkant.
De elektronica heb ik op hun plek gehouden met isolerend tape. Ook om later eventuele kortsluitingen te voorkomen. Mooi moment voor een video van mijn zwaard op dat punt met de elektronica in actie.

Afwerken

Een houten zwaard ziet er altijd wat knullig uit daarom heb ik het een metalen look gegeven die ik heb afgekeken van Adam Savage (bekend van Myth Busters). Check deze video voor de lange uitleg.
In het kort: bedek je zwaard met zelfkleven aluminium en duw voorzichtig lichtbelletjes er uit. Spuit matte zwarte verf over je zwaad. Als de verf droog is schuur je met en schuurpapiertje veel verf er weer af. Er blijft in al die onregelmatigheden, die je eerst misschien lelijk vond, wat verf achter en het eindresultaat is net een oud roestig metalen zwaard.

Aluminium er op

Zwart gespoten en opgeschuurd

Ik hoop dat dit ook een leuke inspiratie kan zijn voor mensen. Het was mijn eerste echte ervaring met houtbewerking en het maken van een prop. Het was erg leuk.en ik ben best tevreden.

Sprekend Zwaard (elektronica dingen)

In de Volkskrant van 2 Juli kun je in mijn Maakbare Wereld bijdrage lezen dat ik een sprekend zwaard heb gemaakt. Ik zou hier wat onderdelen in meer detail willen uitleggen met name de elektronische delen.

Hardware

In het zwaard heb ik een Teensy 3.2 met Prop shield gebruikt. Daarnaast een kleine metalen speaker en een oplaadbare batterij via Adafruit. De Teensy en prop shield heb ik aan elkaar gesoldeerd en na wat forum leeswerk en het goed bekijken van onderstaande foto wist ik hoe dat moest.

Je kunt zien dat er aan drie zijdes pinnetjes verbonden moeten worden.

De batterij moet op een 5V (rode draad) en GND (zwarte draad) pin aangesloten worden. Ik heb dit pas helemaal aan het einde gedaan nadat ik alle software er al op had. De speaker moet de + en - pinnen worden aangesloten.

Software
Je kunt de Teensy programmeren door een USB kabel aan te sluiten en de Arduino software te gebruiken met de Teensyduino add-on. De prop shield beschrijvingspagina heeft eerst een mooie beschrijving hoe je de sensoren kunt ijken en dat is zeker de moeite om even te doen.

Daarna wilde ik het geluid testen en daarvoor heb ik de code bekeken in Examples van de Arduino omgeving onder Talkie. Hier kun je een soort robot stem wat woordjes laten zeggen. Om deze code te laten werken moet je het volgende veranderen. Vervang AudioOutputI2S door AudioOutputAnalog en haal alles weg waar SGTL5000 staat.

Om het volume harder te krijgen moet je de volgende regels toevoegen.

 AudioMemory(20);  
  dac1.analogReference(EXTERNAL); // much louder!  
  delay(50);       // time for DAC voltage stable  
  pinMode(5, OUTPUT);  
  digitalWrite(5, HIGH); // turn on the amplifier  
  delay(10);       // allow time to wake up  

Als je nu geluid kunt produceren kun je doorgaan om eigen geluiden af te spelen

Audio bestanden gereedmaken 

Je kunt op de pc een geluid opnemen of een ander geluid gebruiken, maar voordat dat je het kunt gebruiken moet je het eerst omzetten in het RAW formaat. Hiervoor kun je het programma Sox gebruiken. Dit programma moet je gebruiken vanaf de command line, daarvoor kun je zoeken in Windows naar cmd.exe (net als ms-dos vroeger :)).  Ik heb er voor gekozen om de bestanden die ik wilde omzetten in dezelfde map als sox.exe te plaatsen.Bij mij was dat C:\Program Files (x86)\sox-14-4-2.
Als je deze gevonden hebt moet je een bestand omzetten met:
 sox file.mp3 --bits 16 --rate 44100 --channels 1 file.raw

Hier moet je nog je eigen bestandsnamen invullen. Het eindresultaat moet compleet in hoofdletters om te werken op de Teensy, dus bijvoorbeeld GELUID.RAW

Audio bestanden kopiëren
Als het omzetten gelukt is wil je het resultaat kopiëren op de flash drive van de prop shield. Allereerst moet de Teensy weten dat er iets gekopieerd gaat worden. Download eerst het volgende programma Teensytransfer. Je moet de usb mode op "Raw Hid" zetten in de Arduino omgeving. Om  teensytransfertool.ino op je Teensy uploaden moet je ervoor zorgen dat het in een map staat samen met version.h, Teensytranser.h en Teensytranfer.cpp. Het ino bestand kun je dan uploaden op de Teensy.
In de map waar Teensytranser gedownload is vind je ook een teensytransfer.zip bestand waar in teensytransfer.exe te vinden is. Deze moet je uitpakken. In dezelfde map heb ik de gevonverteerde RAW bestanden geplaatst.
Hierna moet je weer de command line openen (cmd.exe) en naar de map gaan waar het teensytransfer.exe en RAW bestanden te vinden zijn.

Om te zien of alles in orde is tik je: teensytransfer -i teensy
Om een bestand te kopiëren tik je: teensytransfer -w eeprom GELUID.RAW
Om te zien of dat gelukt is tik je: teensytranser -l

Geluid afspelen

Nu is het toch eindelijk tijd om onze eigen geluiden af te spelen. Ik zal gelijk overgaan tot mijn eigen code. Hier zijn er drie bestanden die afgespeeld worden onder verschillende omstandigheden. Eentje bijvoorbeeld als er lang geen beweging is. De andere twee als opeens wel beweging of draaiing is. Aangezien we al genoeg gelezen hebben zal ik de code hier gewoon plaatsen.

 #include <NXPMotionSense.h>  
 #include <Wire.h>  
 #include <EEPROM.h>  
 #include <SPI.h>  
 #include <SD.h>  
 #include <SerialFlash.h>  
 #include <Audio.h>  
   
 NXPMotionSense imu;  
 NXPSensorFusion filter;  
 AudioPlaySerialflashRaw playFlashRaw1; //xy=145,62  
 AudioPlaySerialflashRaw playFlashRaw2; //xy=161,115  
 AudioMixer4       mixer1;     //xy=390,210  
 AudioOutputAnalog      dac1;      //xy=740,251  
 AudioConnection     patchCord1(playFlashRaw1, 0, mixer1, 0);  
 AudioConnection     patchCord2(playFlashRaw2, 0, mixer1, 1);  
 AudioConnection     patchCord3(mixer1, 0, dac1, 0);  
 AudioConnection     patchCord4(mixer1, 0, dac1, 1);  
 int restTime = 0;  
 int yesTime = 10000;  
 int finallyTime = 10000;  
   
   
 void setup() {  
  pinMode(5, OUTPUT);  
  digitalWrite(5, HIGH);//Enable Amplified PROP shield  
  delay(10);  
  if (!SerialFlash.begin()) {  
   while (1)  
    {  
     Serial.println ("Cannot access SPI Flash chip");  
     delay (1000);  
    }  
  }  
  AudioMemory(20);  
  dac1.analogReference(EXTERNAL); // much louder!  
  delay(50);       // time for DAC voltage stable  
  pinMode(5, OUTPUT);  
  digitalWrite(5, HIGH); // turn on the amplifier  
  delay(10);   
  mixer1.gain(0, 0.4);  
  mixer1.gain(1, 0.4);  
    
   //Serial.begin(9600);  
  imu.begin();  
  //filter.begin(100);  
 }  
   
 void loop() {  
  float ax, ay, az;  
  float gx, gy, gz;  
  float mx, my, mz;  
  //float roll, pitch, heading;  
  float energy = 0;  
  float turn = 0;  
    
  if (imu.available()) {  
   // Read the motion sensors  
   imu.readMotionSensor(ax, ay, az, gx, gy, gz, mx, my, mz);  
   energy = sqrt(ax*ax+ay*ay+az*az);  
   turn = sqrt(gx*gx + gy*gy + gz*gz);  
   Serial.println("turn: " );  
   Serial.println(turn);  
  }  
  if (turn > 400)  
  {  
   if (finallyTime > 100000)  
   {  
    playFlashRaw1.play("FINALLY.RAW");  
    delay(2000);  
      
   }  
   restTime = 0;  
   finallyTime = 0;  
  }  
    
  if (energy> 3.5)  
  {  
   if(yesTime>10000)  
   {  
    playFlashRaw1.play("YES.RAW");  
   //Serial.println ("sound played?");  
    delay(2000);  
     
   }  
    restTime = 0;  
   yesTime = 0;  
  }  
  restTime = restTime + 1;  
   yesTime = yesTime +1;  
  finallyTime = finallyTime +1;  
    
  if (restTime > 1000000)  
  {  
   playFlashRaw1.play("EZKIEL.RAW");  
   delay(10000);  
   restTime = 0;  
  }  
   // Update the SensorFusion filter  
   // filter.update(gx, gy, gz, ax, ay, az, mx, my, mz);  
   
   // print the heading, pitch and roll  
   /*roll = filter.getRoll();  
   pitch = filter.getPitch();  
   heading = filter.getYaw();  
   Serial.print("Orientation: ");  
   Serial.print(heading);  
   Serial.print(" ");  
   Serial.print(pitch);  
   Serial.print(" ");  
   Serial.println(roll);*/  
    
 }  

Final Notes

Ik heb nu nog maar beperkt gebruik gemaakt van de mogelijkheden van de prop shield. Je kunt er ook knoppen op aansluiten of gewoon pins als tastsensor gebruiken. Sensoren die voor Arduino bedoeld zijn zullen ook wel werken denk ik zo. De prop shield kun je natuurlijk in van alles en nog wat verwerken.
Ik hoop dat dit stukje mensen wat sneller op weg helpt, want persoonlijk vond ik het een flinke speurtocht.
En zoals altijd, heb je vragen stel ze gerust.

Infrarood Camera met een Arduino

In de Maakbare Wereld van 16 januari staat mijn stukje over de infrarood camera die ik heb gemaakt.
De camera bestaat grofweg uit drie onderdelen: Een Arduino Uno, een Pan Tilt, en een infrarood sensor. Om een beeld te krijgen hoe het werkt een kort kort filmpje van de sensor die heen en weer beweegt.

Later heb ik een klein kartonnen buisje om de sensor geplaatst, zodat er geen licht van opzij valt.

Draadjes

De motoren van de pan tilt zijn redelijk eenvoudig aan te sluiten. Ze gebruiken allebei 5 Volt.  Het is nodig om een flinke condensator tussen de plus en min aansluitingen te plaatsen die spanningspieken op kan vangen bij het aanzetten van de motoren. Als je dit niet doet daalt de spanning zoveel dat de Arduino steeds opnieuw opstart.
De infrarood sensor heeft vier aansluitingen; er is een uitstekend stukje als oriëntatie punt. Aangezien er een duidelijk beschrijving hier staat ga ik dit niet herhalen. Er worden twee 10 kOhm weerstanden gebruikt die op de plus kant aangesloten worden. Ik vond dat niet heel duidelijk uit de foto. Let op dat deze sensoren in verschillende types bestaat. Ik heb de 3V versie gebruikt en daarom moest ik de 3.3 Volt aansluiting van de Arduino gebruiken, dus niet dezelfde als voor de motoren.

Het complete schema ziet er ongeveer zo uit. (hopelijk zonder fouten :) )

Voor de geïnteresseerde; deze afbeelding is gemaakt met Fritzing, een gratis programma om schakeling e.d. te tekenen.

Resultaten zijn natuurlijk ook leuk om te zien. Ik heb foto gemaakt van een glas bierglas gevuld met warm water.

Glas warm water scannen

Foto van het warme glas water

De kleuren zijn wat willekeurig gekozen, blauw is warm en rood is koud. Maar het idee is duidelijk lijkt me. Ik plaatste het glas toen de sensor al heen en weer bewoog, waardoor er strepen kwamen. Verder was ik erg tevreden of dit resultaat. De sensor heeft normaal een blikveld van ongeveer 90 graden, maar met het kokertje is het een aardig scherp beeld geworden. Het glas stond natuurlijk dichtbij. Misschien zou een lens kunnen helpen, maar de vraag is of een gewone lens wel goed werkt met infrarood licht.

Code

Motoren en sensoren gaan niet uit zichzelf werken en je computer maakt ook niet vanzelf afbeeldingen, dus kort daar wat over. De motoren kun je vertellen om naar een bepaalde stand te gaan van 0 tot 180 graden heen en weer en 0 tot 150 graden op en neer. Ik heb niet dat volledige gebied afgescand, maar van 0 tot 90 graden in beide richtingen. We gaan steeds één plekje opzij tot we de rand bereikt hebben, dan één plaatsje naar beneden en de andere kant weer op. 

Na elke beweging vragen we aan de infrarood sensor wat de gemeten temperatuur is. Deze sensor geeft omgevingstemperatuur en de voorwerpstemperatuur, Daarbinnen gebeurd dus ook al genoeg blijkbaar. 

De Arduino Uno is het hart van de operatie. Deze doet het aansturen van de motoren en het opvragen van de temperatuur. Als dat gebeurd is stuurt het een bericht naar de laptop via de USB kabel, een serial message. Op de laptop draait een Processing programma dat wacht op berichten, graden Celsius in dit geval. De graden worden omgezet in gehele waarden tussen de 0 en 255, waarbij 0 overkomt met bijv. 24 graden en 255 met 30 graden. Met deze waarde wordt een vierkantje ingekleurd, zo wordt 0 helemaal rood en 255 volledig blauw en alles er tussen in mooie mengkleuren.

Er zat wat verschil tussen de heen rijen en de terug rijen waardoor ze wat verschoven waren ten opzichte van elkaar en dus heb ik ze wat opgeschoven.

Beide programma's zijn hier te vinden. Je kunt ze ook openen in elk tekstverwekingsprogramma, zoals notepad.

Als iemand nog vragen heeft (zoals over code die niet werkt :) ) plaats ze hieronder.

Disco Jurk

In mijn 'Maakbare Wereld' stuk van 10 oktober 2015 in de Volkskrant beschrijf ik in het kort hoe ik een schitterende, blinkende disco jurk in elkaar gestoken heb. Allereerst een filmpje om te laten zien dat het echt werkt (of tenminste werkte totdat hij een paar uur gedragen was. Ik moet echt op naaicursus).

Omdat in de krant niet genoeg plek is om diep in te gaan op de software kant van het project wilde ik er hier wat over schrijven.

De FLORA die de LED lampjes aanstuurt wordt geprogrammeerd met de Arduino IDE. Al wordt het steeds makkelijker om hier mee te werken, het kost nog steeds wel wat tijd alles aan de praat te krijgen. Het is vooral nuttig om de handleiding van Adafruit te volgen over hoe je de FLORA voor het eerst moet gebruiken. Lees goed wat je precies moet doen dan zou het altijd goed moeten komen.

De Arduino taal is naar mijn mening een supermooie manier om met programmeren te beginnen. Het is goed leesbaar en je hebt gelijk een fysisch resultaat, zoals knipperende lichtjes.

Ik zal me verder beperken tot de onderdelen die ik gebruikt heb namelijk de FLORA, de 9DOF sensor en de NeoPixels (kleuren LED's). Ik vind het zelf erg fijn om te leren van simpele voorbeelden. Ik geef daarom een paar voorbeelden van wat je kunt doen met deze componenten. Ik zal proberen in de code Nederlands commentaar toe te voegen, zodat het duidelijk is wat de verschillende onderdelen doen.
Hieronder wat korte opmerkingen

Knipperen bij bewegen

Het voorbeeld dat Adafruit zelf in elkaar heeft gestoken is erg informatief. Het kijkt naar de totale versnelling op twee momenten vlak na elkaar en kijkt of er een (groot) verschil is. Zo ja, dan wordt er een functie aangeroepen die willekeurig de lampjes laten knipperen. Ik heb het commentaar vertaald en de sketch is hier te vinden. Je moet het bestand downloaden om het te kunnen inzien. Het beste natuurlijk bewerken in de Arduino IDE, maar in een tekstverwerker kan ook (notepad, wordpad, etc).
Het programma heeft waarschijnlijk maar weinig aanpassingen nodig om voor uw eigen ontwerp te werken. Het belangrijkste zijn de PIN waar het lint van NeoPixels op aangesloten is en het aantal NeoPixels in hetzelfde lint in deze regel:
Adafruit_NeoPixel strip = Adafruit_NeoPixel(7, 6, NEO_GRB + NEO_KHZ800);

Het gaat om de twee getallen die na het 'haakje open' staan: 7 en 6. In mijn geval heb ik namelijk 7 NeoPixels aangesloten op PIN 6.

Je kunt de gevoeligheid aanpassen bij:
#define MOVE_THRESHOLD 120

Oriëntatie

De 9DOF sensor kan ook de magneetsterkte in drie richtingen meten. Daardoor is het een soort 3D kompas. Je zou dus de kleuren van de NeoPixels kunnen laten veranderen van de windrichting dat je opkijkt.
Het is goed om te beseffen dat het magnetische noorden vanaf uw positie gezien ergens onder de horizon ligt en dat de richting van magnetische vector dus richting de grond wijst. Dat betekend niet dat je niet kunt gebruiken als kompas. Om het precies te doen zouden we wat rekenwerk moeten verrichten, maar voor dit geval proberen we het zo simpel mogelijk te houden. Aangezien de sensor vast zit aan de jurk zal deze in normale situatie steeds met dezelfde as omhoog wijzen. Twee andere assen zullen we steeds andere waarden aangeven. Ik heb gewoon even getest door de jurk rond te draaien en in de Serial Monitor gekeken wat de waardes waren van de verschillende kanalen x, y en z. In mijn geval bleek y niet veel te veranderen en x en z wel. Om de richting te berekenen neem ik de arctan van x en z: atan(magX/MagZ). Ik houd voor simpliciteit hier geen rekening met een vector die precies de andere kant opstaat. Dat kunt u eenvoudig zelf toevoegen (lees: ik was te lui om het te doen) Het bestand vindt u hier.


Ik hoop dat er binnenkort wat mooie kostuums gemaakt worden. Halloween?

Handschoen Richtingaanwijzer

In Maakbare Wereld van de Volkskrant van zaterdag 4 april heb ik geschreven over mijn handschoenen die ik heb uitgerust met een richtingaanwijzer voor als je aan het fietsen bent.

Hiervoor heb ik een Adafruit GEMMA gebruikt en een Neopixel. Informatie hierover kun je bijvoorbeeld hier vinden. Het mooie van dit product is dat je het op een stof kunt naaien met geleidend draad en daardoor hoef je vaak niks te solderen. Het programmeren is redelijk eenvoudig, hiervoor heb je de Arduino programmeeromgeving nodig. Ik heb hiervoor de aangepaste versie gebruikt die je kunt vinden op de Adafruit website, klik hier. Download de versie die bij je computer past en volg de instructies goed.
Ik had hier verder geen problemen mee, maar dat kwam denk ik ook omdat ik al eerder een Trinket (zie hier) van dezelfde fabrikant had gebruikt en daardoor er geen driver problemen meer waren.

Mijn code is te vinden onder Code Examples. De code kun je ook gewoon lezen in een tekstverwerker. (Word, notepad, wordpad, notepad++)

Ik wil nog maar eens benadrukken dat de GEMMA of de grotere FLORA hele eenvoudige en betaalbare apparaten zijn en waar een heel arsenaal aan sensoren bij beschikbaar zijn, zoals GPS, licht, geluid, versnelling en nog wat.

Als iemand vragen heeft, aarzel niet om ze te stellen. En ik vind het leuk om te horen als iemand zelf iets gemaakt heeft.


Succes met bouwen!
korte video demo

EDIT (21 april): Hier is de illustratie die Bier & Brood hebben gemaakt bij het artikel. Beter dan ik het kan uit tekenen. De weerstand van 10 kOhm tussen D2 en GND is erg belangrijk. 

Illustratie van Bier&Brood

Afbeeldingen bij Volkskrant stuk van 29 nov 2014

Als aanvulling op het stuk in de Volkskrant over de zelfrichtende zonnebloem wilde ik hier wat foto's laten zien, het elektrische schema en een kort filmpje.
Daarnaast zal ik een afbeelding plaatsen die ik zelf als zonnewijzer heb gebruikt. Ik heb een formule van Wikipedia gebruikt om de hoek tussen de uren te berekenen. Ik heb het één keer getest en toen was de afwijking ongeveer tien minuten wat ik aanvaardbaar vond.
Vragen zijn altijd welkom.

In de bovenstaande video zie je eerst hoe de bloem reageert als er niks van stabilisatie is. De motor draait op vol vermogen en schiet daardoor steeds te ver door. Hij beweegt daardoor heel wild. Daarna heb ik een kunstmatige vertraging toegepast door de motor steeds maar heel kort (10 ms) aan te laten en vervolgens weer uit te zetten.

Het initiële idee voor het gehele elektrische schema.
De weerstand van de LDR's is echter te groot om nog voldoende stroom te krijgen

Twee LDR's met weerstand, de feitelijke sensoren.

Het uiteindelijke elektrische schema.
Het sensor deel (boven) is nog hetzelfde maar de spanning gaat nu naar de Arduino.
De Arduino beslist dan welke transistoren in het onderste deel open mogen (pretty nice)
10 en 11 of 12 en 13 gaan tegelijk open.

Schakeling in test opstelling. Het bovenste breadboard bevat de LDR's,
de onderste de vier transistoren die de stroomrichting van de motor besturen

Definitieve opstelling in een houten doos

Zonnewijzer die onder de bloem geplaatst kan worden. Of gewoon op je vensterbank.
12 uur moet naar het zuiden gericht worden. Geschikt voor 52⁰ NB en wintertijd.

Foto's en Video's bij mijn Whack-A-Mole stukje uit de Volkskrant

Dit zijn wat foto's die ik gemaakt heb tijdens het maken van het Whack-A-Mole spel, of eigenlijk, Mep-Een-Vlieg waarover ik een stukje heb geschreven in de Volkskrant van 1 november 2014.

Als je geen papieren versie te pakken hebt gekregen is het artikel te vinden via de Volkskrant website of bijv. via Blendle.

Mocht iemand zelf een Mep-Een-Vlieg Spel willen maken, de foto's hieronder geven al een goed beeld van wat je moet doen. Als je nog vragen hebt stel ze dan vooral.

Allereerst een korte video van dochterlief terwijl ze het spel probeert.

Close up van mijn tekenkunst
Bovenaan het zilverfolie een groene LED
die door de folie prikt om het te verbinden

Enthousiast uittesten (maar echt hoor)

Serieus, ze vond het heel leuk,
maar het was 7:30 's ochtends

Binnenkant van de doos.
Boven in beeld de speaker

Schematisch schema

ENGLISH
These are some pictures I made during the making of my own Whack-A-Mole (Fly in this case).
I made this project for my article in de Volkskrantof 1st november 2014.
Questions are always welcome.

Zelfsturende Auto (foto's bij het Volkskrant stuk)

(English below)
Op zaterdag 3 oktober verscheen in De Volkskrant mijn eerste bijdrage in 'De Maakbare Wereld' in de zaterdag Sir Edmund katern. (te vinden op de Volkskrant website of bijv Blendle de eerste zoveel artikelen kun je gratis lezen)
Hier heb ik kort uitgelegd hoe ik een afstandsbestuurbare auto met mijn laptop kon besturen.
Een volgende stap is natuurlijk dat er geen persoon meer aan te pas komt. En ik heb daar al een groot deel van geknutseld, maar nog geen tijd gehad om de puntjes op de i te zetten.

Wat ik in elk geval wilde delen waren de foto's die ik gemaakt van tijdens het werken aan de auto. De foto's waar de toffe tekeningen op gebaseerd die gemaakt zijn door Bier & Brood.

De auto en wat belangrijke werkspullen

Testen waar spanning op gezet moet worden

Draden gesoldeerd in AB en via wat transistoren (kleine zwarte dingen) op
een breadboard (witte ding) naar de Arduino (blauw ding)

Als iemand specifieke vragen heeft, stel ze. Dit is niet een enorm ingewikkeld knutsel project en zeker niet duur. In dit geval is de Arduino het meest kostbaar en een autootje is natuurlijk niet gratis.

Het lastigste is in zo'n geval het uittesten hoe de afstandsbediening nu precies werkt. En dat testen heb ik gewoon gedaan door te kijken hoe zit de batterij aangesloten (waar gaan de plus en min heen) en gewoon wat met de 5 Volt uitgang van de Arduino en twee draden proberen. Kleine kans dat je iets stuk maakt met die 5 Volt, want de batterij die er inzat was een 9V blok.

En gaat er een keer iets stuk dan heb je ook iets geleerd. Gebruik dus spullen waar bij het niet erg is dat ze stuk gaan.

Misschien een goeie tip voor Sinterklaas: vraag een soldeerbout en wat weerstanden :)

ENGLISH (very short summary)

I wrote my first newspaper article about controlling a RC car with my laptop. These are some pictures I made while making the project.
If you have any questions, ask them.

Do It Yourself Tracking Software

Introduction

In a preview I showed a radio controlled boat where I hacked the remote control. With an Arduino Uno you can send a signal to the remote which then sends it to the boat. A small video of my daughter trying it out to show it works.

My ultimate goal is to make the boat autonomous. I want to use a webcam to determine the position of the boat and then be able to steer in the right direction. So that could be making sure it doesn't crash into the wall or that it follows a certain route, I haven't made up my mind about that yet.

Choosing the system

When I started with this project I was thinking about all the obstacles and steps I would find along the way. But I soon realized that I was making the rules here. I could choose what system I was using and how difficult it was going to be. That sounds a bit vague so I guess I'll give an example. When I saw the remote control I immediately was thinking about the Arduino. Nowadays there are quite a few ways for computer-machine interaction but since I have some experience with the Arduino I knew I would have less problems implementing it.

One of the bigger challenges was using a webcam and it's images to send the right commands to the Arduino and so the boat. I followed part of a course last year on Coursera called: Creative Programming for Digital Media & Mobile Apps. All the apps they worked with were built in Processing which has a very low entry level and let's you make Android apps and JavaScript apps. It's really meant for fun user interfaces.
Bonus: It's really similar to the Arduino language and even the programs look similar. So if you know one, the other will be a cinch.
And yes you can access the webcam with processing and use the images to do whatever you want.

Object tracking

That was a long intro, bear with me.
Processing doesn't have object recognition functions built in and I figured any program you could find on the internet would not be suitable for what I wanted. So I decided to make it myself which is always more fun.
Accessing the webcam wasn't that hard (there are examples in Processing) but I needed some boundaries.
What did I want to recognize? The boat, but I didn't feel like building a Machine Learning algorithm that knows what the boat looks like and finds. Possible I guess, but pretty hard work. I wanted something simple.
I made the choice of placing a colored sticker (or maybe two) on the boat, let's say red. I intend to place the webcam above the water and I can choose what color bottom of the water will have. I could make sure that the only red thing in the webcam image is the red sticker. This is what I talked about earlier, I can make the choices of how difficult the problem is going to be. I have reduced the problem to finding a red dot in an image.

Finding the red dot

To give you a break from all this reading, here is a demo of my Processing program using the webcam on my laptop to follow a small red object.

In my hand I'm holding a small piece of red plastic. The program takes a webcam image and analyses it in two steps.
First it performs a threshold. Using the fact that red objects are red :) it assigns a '1' to pixels that have lot's of red and little green and blue (i.e. white pixels have lot's of red, green and blue) and it assigns a '0' to all the other pixels.
Next it calculates how many pixels in the neighborhood are found red and finds the pixel with the most neighboring red pixels. That neighborhood can be quite big, for instance this was done with 10 by 10 pixels.
The way these calculations are done can and will be topic of a separate blog entry.

To show the result it draws a white circle at the found position.
You can vaguely see image it works with around the white circle. That represents the number of pixels around every pixel. If you would have a stepfunction in your image the result of counting the neighboring pixels would look like something below.

Sketch of how the counting of neighboring pixels would look like

It reminds me of a Gaussian blur. Most important is that you see that the middle of the original platform results in a high peak in the second image. Important is choosing the right neighborhood size as you can imagine.

In the near future

Keeping the main goal in sight, tracking and controlling the boat there is still some work to be done.
I intend to place two stickers one the boat, a blue one and a green one and track them both. With the position of these two stickers you can determine the position and orientation of the boat. If you use previous positions and orientations you can calculate the speed and direction of the boat.

Then I have to think of some rules the boat has to follow like: don't touch the walls, or go around in circles.

So far the program is perfectly capable of doing all the calculations in real time, and I hope that it still does so when all these features are added.

To be continued...

The boat