Gee!Design

Een van de onderwerpen die in mijn cursus “Game Input Design” aan de orde kwam, was hoe je met versnellingsopnemers (accelerometers) een beweging kan detecteren, en dat signaal vervolgens vertalen in een actie in een spel. Denk aan Wii Sports Tennis: als je de Wiimote snel genoeg heen en weer beweegt, dan zal het poppetje op het scherm zijn racket bewegen. Is de bal dan in de buurt, dan raakt het racket ook de bal.

De versnellingsopnemers in de Wiimote en de Wii nunchuk kijken naar de oriëntatie van de assen van het apparaat ten opzichte van het aardoppervlak (i.c. het zwaartekrachtveld). Als je een duidelijke uitleg over accelerometers, gyroscopen en kompassen wilt hebben en waarom deze nodig zijn, dan moet je deze Google Tech Talk bekijken: “Sensor Fusion on Android Devices: A Revolution in Motion Processing“.

Met de Nunchuk, als je je hand naar links of rechts kantelt, draait de nunchuk om de X-as, beweeg je hem omhoog of omlaag, dan draait hij om de Y-as. (Draai je je hand in het platte vlak, dan draait de nunchuk om de Z-as, die dus naar omhoog wijst. Deze draaiing kan de Nunchuk en de Wiimote slecht detecteren, omdat de zwaartekracht in deze richting niet verandert – daarvoor heb je dus een gyroscoop of kompas nodig).

Om elke draaiing te detecteren en door te geven aan een spel, moeten we eerst de meetwaarden uit de nunchuk uitlezen. We gebruiken in de cursus daarvoor de Teensy (een Arduino-compatibele kloon).  De nunchuk communiceert met een speciaal “protocol” met de Wii, en dat moeten wij dus ook doen. Het is het zogenaamde “Wire” of I2C protocol. Bij dit protocol communiceert het apparaat via “two wires” met een ander apparaat. Zie ook http://www.pjrc.com/teensy/td_libs_Wire.html

Nu is er iemand die een bibliotheek heeft geschreven voor het gebruik van dat I2C protocol met de Arduino of de Teensy, en dat kunnen wij dus direct gebruiken. Het enige is, dat daarvoor de juiste pins moeten gebruiken: SCL moet aan pin 0, SDA aan pin 1 bij de Teensy++. We gebruiken dus de volgende opstelling:

Het schema is:

Om de nunchuk zonder in draden te knippen aan te sluiten op een Teensy gebruiken we een Wiichuck Adapter (voor 2,54 euro te verkrijgen bij Floris.cc). Eigenlijk moet er een 1K8 Ohm weerstand als “pullup” resistor gebruikt worden, die hebben we niet in de “kit” die we bij de cursus gebruiken, dus dan doen we 2K Ohm (het komt niet zo nauw, maar die pullup resistor helpt wel!!)

We willen graag op de desktop computer goed zichtbaar maken wat er precies voor signalen binnenkomen van de Nunchuk. Daarvoor gebruiken we de “Monitor” applicatie die met de AS3Glue bundle meegeleverd wordt. Deze applicatie  is gemaakt door Kasper Kamperman en op zijn site te vinden.  Glue is een library voor Actionscript 3.0 en kan gebruikt worden om Flash via het Firmata protocol volledig te laten communiceren met een Arduino of Teensy. Daar gaan we nu nog niet op in (pas in les 8 van deze cursus), maar we gebruiken nu wel de voorbeeld applicatie “as3glue_standalone_monitor“.

Aan de computer kant

Aan de computer kant moet er naast het (Flash programma) Monitor een serial proxy programma draaien, dat de signalen van de Teensy die via de USB binnenkomen vertaalt in XML socket data, en vice versa. Je dus de volgende stappen ondernemen om de applicatie “as3glue_standalone_monitor” te draaien:

Aan de Teensy kant

Ik heb een programma (“sketch”) geschreven in Arduino code dat de meetwaarden via het Wire protocol uitleest uit de nunchuk en vervolgens doorgeeft naar de desktop computer via het Firmata protocol. Het programma is hier te vinden. Het bestaat uit:

• De programma sketch NunchukFirmataButton.ino (voor Arduino 1.0), en
• de code nunchuck_funcs.h, voor het uitlezen van de Nunchuk. Deze file moet in dezelfde map als de sketch geplaatst worden, anders vindt de Arduino editor het niet.

Als je de sketch met de Arduino ontwikkelomgeving compileert (N.B. gebruik Tools > USB Type > “Serial”) en op de Teensy zet, en vervolgens de Monitor applicatie op je computer draait en verbindt met de Teensy, dan zie je grafiekjes zoals hieronder:

In de bovenste drie grafiekjes zie je de ruwe waarden van de nunchuk accelerometers (X, Y en Z). In de bovenste grafiek zie je opeens een scherpe daling, even later gevolgd door een scherpe stijging. Dit kwam omdat ik de nunchuk snel naar links draaide, en even later weer naar rechts.

Bij “analog pin 3” en “analog pin 4”  staan de gefilterde waarden van de X en Y accelerometer. De ruwe waarden zijn door een “exponential smoothing filter” (zie les 6 van de cursus!) heen gegaan met een hele kleine waarde voor de parameter ALPHA. Dit betekent, dat het filter veel waarde hecht aan de waardes in het verleden, en de nieuwe meetwaarden slechts weinig meetellen. Je ziet dan ook, dat de scherpe daling in de waarde van de X-accelerometer pas na een tijdje gevolgd wordt, en als de ruwe waarde weer stijgt dan volgt de gefilterde waarde eveneens pas na een tijdje. Het verschil tussen de ruwe waarde en de afgevlakte waarde kunnen we dus ook gebruiken om snelle veranderingen (bewegingen!) te detecteren. Het grafiekje bij “analog pin 5” bevat een piekje als het verschil tussen de ruwe waarde (pin 0) en de afgevlakte waarde (pin 3) groter is dan een bepaalde drempelwaarde. Dit is ook direct de gebeurtenis die als een keystroke doorgegeven kan worden naar een spel dat door de nunchuk moet worden bestuurd!

In formules: bij “analog pin 0” staat de ruwe waarde van accelerometer X, op tijdstip t noemen we die waarde Y(t). Bij “analog pin 3” wordt de gefilterde waarde van die waarde getoond:

(Je ziet, als α klein is, dan wordt de waarde van S op tijdstip t meer bepaald door de waarde van S op het vorige tijdstip (t – 1) dan door de ruwe meetwaarde Y).  In de code wordt een waarde voor α van 0,01 gebruikt. Het verschil (Y(t) -S(t)) wordt in de code vergeleken met een drempelwaarde THRESHOLD om te zien of er een piekje aan “analog pin 5” gegeven moet worden.

Actie in het spel

Hierboven liet ik zien hoe je een snelle beweging naar links of naar rechts kan detecteren. In de praktijk zie je, dat een versnelling naar links zeer vaak gevolgd wordt door een versnelling naar rechts: immers, als je naar links beweegt en je stopt vervolgens, dan is het stoppen een relatieve versnelling naar rechts! (Je kunt dit mooi zelf testen door de code aan te passen en in de Monitor naar de grafiekjes te kijken!)

Daarom passen we in de code een trucje toe, door een versnelling naar links pas te detecteren als hij niet te snel na een versnelling naar rechts komt, etcetera. Ik meet de tijd sinds de laatste keer met behulp van de functie millis(), en vergelijk het verschil met een constante als INTERVAL_DELAY. Je moet een beetje spelen met de Arduino code.

Het uiteindelijke signaal doorgeven als een keystroke naar het spel is met de Teensy heel eenvoudig: het indrukken van de letter “R” is voor de Teensy hetzelfde als het uitvoerden van de code

Keyboard.print(“R”);

Maar dan moet je bij het compileren van de Teensy code in de Arduino omgeving wel aangeven Tools > USB Type > Serial + Keyboard + Mouse + Joystick. (Zie hier).

Kortom, met behulp van deze code, de Teensy en wat simpele elektronica kun jij ook een spel als Wii Sports Tennis maken!