6 Ein bewegungsgesteuerter Game-Controller

Transkript

1 103 6 Ein bewegungsgesteuerter Game-Controller Es ist verblüffend, wie schnell wir uns an neue Technologien gewöhnen. Vor einem Jahrzehnt hätten nicht viele Menschen gedacht, dass wir unsere Bewegungen einfach mit kleinen Geräten mitverfolgen könnten. Heute ist es für uns völlig normal, ein Smartphone zu drehen, wenn wir von der Hoch- in die Queransicht wechseln möchten. Selbst kleine Kinder verstehen intuitiv, wie die Bewegungssteuerung für Spielkonsolen, z. B. Nintendo Wii, funktioniert. Sie können Ihre eigenen bewegungsgesteuerten Geräte mit Arduino bauen, und in diesem Kapitel lernen Sie, wie. Wir arbeiten mit einem der bekanntesten Bewegungssensoren: Dem Beschleunigungsmesser. Beschleunigungsmesser erkennen Bewegungen in allen Richtungen. Sie erkennen, ob man sie nach oben, unten, links oder rechts bewegt. Viele bekannte Gadgets, wie das iphone und das Nintendo Wii enthalten Beschleunigungsmesser. Weil sie also in zahlreichen Geräten verwendet werden, sind sie auch so günstig. Spielprojekte profitieren genauso von Beschleunigungsmessern wie kommerzielle. Wenn Sie sie mit Ihrem Computer koppeln, denken Sie wahrscheinlich zuerst an Game-Controller oder andere Eingabegeräte. Sie können sie aber auch beim Training oder für die Steuerung eines echten Brettspiels verwenden. Sie können damit auch mehr oder weniger indirekte Beschleunigung messen, z. B. in einem Auto. Sie lernen, wie Sie Daten des Beschleunigungsmessers richtig interpretieren und wie Sie die genauesten Ergebnisse bekommen. Dann verwenden Sie einen Beschleunigungsmesser, um Ihren eigenen bewegungsgesteuerten Game-Controller zu bauen und implementieren ein Spiel, das ihn verwendet. 6.1 Was Sie benötigen ein Breadboard halber Baugröße oder noch besser ein Proto-Shield mit einem kleinen Breadboard 1 einen ADXL 335-Beschleunigungsmesser 2 einen Taster 3 Einen 10-kOhm-Widerstand 4 einige Kabel 5 sowie

2 104 6 Ein bewegungsgesteuerter Game-Controller ein Arduino-Board wie das Uno, Duemilanove oder Diecimila ein USB-Kabel, um Arduino mit Ihrem Computer zu verbinden einen 6-Pin-Pfostenverbinder, 2,54 mm Abb. 6 1 Die für dieses Kapitel benötigten Bauteile 6.2 Den Beschleunigungsmesser verdrahten Es gibt viele verschiedene Beschleunigungsmesser, die sich hauptsächlich in der Anzahl der messbaren Achsen unterscheiden (normalerweise zwei oder drei). Wir verwenden den ADXL 335 von Analog Devices. Er ist einfach in der Anwendung und leicht zu bekommen. 1 In diesem Abschnitt schließen wir den ADXL 335 an Arduino an und erstellen ein kleines Demo-Programm, das die vom Sensor gelieferten Rohdaten anzeigt. Dabei werfen wir einen kurzen Blick auf die Spezifikation des Sensors und interpretieren die Daten. In Abbildung 6 2 sehen Sie ein Breakout-Board, auf dem sich rechts ein ADXL 335-Sensor befindet. Der Sensor ist ein schwarzer integrierter Schaltkreis (IC), und der Rest dient nur zum Anschließen von Leitungen. Oben sehen Sie einen 6-poligen Pfostenverbinder in 2,54 mm. Der Sensor hat sechs Anschlüsse mit den Bezeichnungen GND, Z, Y, X, 3 V und TEST. Um den Sensor auf einem Breadboard zu verwenden, löten Sie die Pfostenleiste an die Anschlüsse. Dadurch ist es nicht nur einfacher, den Sensor an das Breadboard anzuschließen, der Sensor wird 1

3 6.2 Den Beschleunigungsmesser verdrahten 105 auf diese Weise auch stabilisiert, so dass er sich nicht versehentlich bewegt. Sie sehen das Ergebnis links im Foto (das Breadboard links entspricht nicht genau dem rechts, ist aber sehr ähnlich). Seien Sie unbesorgt, auch wenn Sie vorher noch nie gelötet haben. Im Abschnitt Ein Lötkurs im Anhang A.2 erfahren Sie, wie das geht. Abb. 6 2 Ein ADXL 335-Sensor auf einem Breakout-Board Sie können den Anschluss TEST erst einmal ignorieren. Die Bedeutung der restlichen Anschlüsse dürfte offensichtlich sein. Um den Sensor mit Strom zu versorgen, schließen Sie GND an den Masseanschluss von Arduino an und 3 V an die 3,3-V- Stromversorgung. X, Y und Z liefern die Beschleunigungsdaten für die X-, Y- und Z-Achsen. Wie der Temperatursensor TMP 36, den wir im Abschnitt 5.6, Die Genauigkeit mithilfe eines Temperatursensors erhöhen, verwendet haben, ist auch der ADXL 335 ein Analogbauteil. Es liefert die Messungen als Spannung, die in Beschleunigungswerte konvertiert werden müssen. Die Anschlüsse X, Y, und Z müssen also mit den Analogeingängen von Arduino verbunden werden. Wir schließen Z an Analog-Pin 0, Y an Analog-Pin 1 und X an Analog-Pin 2 an (siehe Abbildung 6 3) und prüfen noch einmal genau, ob es auch die richtigen Anschlüsse am Breakout-Board sind!

4 106 6 Ein bewegungsgesteuerter Game-Controller Abb. 6 3 Anschluss des ADXL 335 an Arduino Nachdem wir den ADXL 335 an Arduino angeschlossen haben, legen wir los. 6.3 Den Beschleunigungsmesser zum Leben erwecken Ein pragmatischer Ansatz, mit neuen Geräten vertraut zu werden, ist es, sie anzuschließen und zu sehen, welche Daten sie liefern. Das folgende Programm liest Eingabewerte für alle drei Achsen und gibt sie über die serielle Schnittstelle aus. MotionSensor/SensorTest/SensorTest.pde const unsigned int X_AXIS_PIN = 2; const unsigned int Y_AXIS_PIN = 1; const unsigned int Z_AXIS_PIN = 0; const unsigned int BAUD_RATE = 9600; void setup() { Serial.begin(BAUD_RATE); void loop() { Serial.print(analogRead(X_AXIS_PIN)); Serial.print( );

5 6.4 Eckwerte finden und korrigieren 107 Serial.print(analogRead(Y_AXIS_PIN)); Serial.print( ); Serial.println(analogRead(Z_AXIS_PIN)); delay(100); Unser Testprogramm ist recht einfach. Wir definieren für die drei Analog-Pins Konstanten und initialisieren die serielle Schnittstelle in der Funktion setup. Wir haben die Analog-Pins nicht explizit auf Input gesetzt, da es sich um die Voreinstellung handelt. In der Funktion loop geben wir laufend die von den Analog-Pins gelesenen Werte am seriellen Port aus. Öffnen Sie den seriellen Monitor und bewegen Sie den Sensor etwas herum. Neigen Sie ihn um die verschiedenen Achsen. Die Ausgabe sollte so oder ähnlich aussehen: Diese Werte zeigen die Daten der X-, Y- und Z-Achse an. Wenn Sie den Sensor z. B. nur um die X-Achse bewegen, sehen Sie, dass sich der erste Wert entsprechend verändert. Im nächsten Abschnitt werfen wir einen genaueren Blick auf diese Werte. 6.4 Eckwerte finden und korrigieren Die physische Welt ist oft weit von Perfektion entfernt. Das gilt besonders für die Daten, die viele Sensoren ausgeben, und Beschleunigungsmesser sind keine Ausnahme. Sie variieren geringfügig bei ihren Mini- und Maximalwerten und unterliegen häufig leichten Schwankungen. Sie verändern ihre Ausgabewerte, obwohl Sie den Sensor nicht bewegt haben, oder sie aktualisieren ihre Werte nicht wie erwartet. In diesem Abschnitt ermitteln wir die Mini- und Maximalwerte und glätten das Zittern. Die Eckwerte des Sensors festzustellen ist einfach, kann aber nicht leicht automatisiert werden. Sie müssen die Sensorwerte stetig auslesen, während Sie ihn bewegen. Hier ist ein Beispielprogramm dafür: MotionSensor/SensorValues/SensorValues.pde const unsigned int X_AXIS_PIN = 2; const unsigned int Y_AXIS_PIN = 1; const unsigned int Z_AXIS_PIN = 0; const unsigned int BAUD_RATE = 9600; int min_x, min_y, min_z; int max_x, max_y, max_z;

6 108 6 Ein bewegungsgesteuerter Game-Controller void setup() { Serial.begin(BAUD_RATE); min_x = min_y = min_z = 1000; max_x = max_y = max_z = -1000; void loop() { const int x = analogread(x_axis_pin); const int y = analogread(y_axis_pin); const int z = analogread(z_axis_pin); min_x = min(x, min_x); max_x = max(x, max_x); min_y = min(y, min_y); max_y = max(y, max_y); min_z = min(z, min_z); max_z = max(z, max_z); Serial.print( x( ); Serial.print(min_x); Serial.print( / ); Serial.print(max_x); Serial.print( ), y( ); Serial.print(min_y); Serial.print( / ); Serial.print(max_y); Serial.print( ), z( ); Serial.print(min_z); Serial.print( / ); Serial.print(max_z); Serial.println( ) ); Wir deklarieren Variablen für die Mini- und Maximalwerte aller drei Achsen und wir initialisieren sie mit Werten, die definitiv außerhalb des Messbereichs des Sensors liegen (-1000 und 1000). In der loop-funktion messen wir stetig die Beschleunigung aller drei Achsen und stellen die Mini- und Maximalwerte entsprechend ein. Kompilieren und laden Sie das Programm hoch, bewegen Sie dann das Breadboard mit dem Sensor in alle möglichen Richtungen und neigen Sie es. Bewegen Sie es langsam und schnell, neigen Sie es langsam und schnell. Verwenden Sie lange Anschlussleitungen und seien Sie beim Bewegen des Breadboards vorsichtig, damit Sie nicht versehentlich eine Verbindung lösen. Nach einem kurzen Zeitraum werden sich die Mini- und Maximalwerte stabilisieren und Sie erhalten eine Ausgabe wie diese: x(247/649), y(253/647), z(278/658) Schreiben Sie diese Werte auf, denn wir benötigen sie später, und Sie werden sie auch für eigene Sensorexperimente verwenden. Lassen Sie uns nun sehen, wie wir das Zittern loswerden. Das Prinzip ist einfach. Statt die Beschleunigungswerte sofort auszulesen, sammeln wir die letzten Werte und bilden ihren Mittelwert. So werden kleine Veränderungen ausgeblendet. Der Code sieht wie folgt aus: MotionSensor/Buffering/Buffering.pde Line 1 const unsigned int X_AXIS_PIN = 2; - const unsigned int Y_AXIS_PIN = 1; - const unsigned int Z_AXIS_PIN = 0; - const unsigned int NUM_AXES = 3;

7 6.4 Eckwerte finden und korrigieren const unsigned int PINS[NUM_AXES] = { - X_AXIS_PIN, Y_AXIS_PIN, Z_AXIS_PIN - ; - const unsigned int BUFFER_SIZE = 16; - const unsigned int BAUD_RATE = 9600; 10 - int buffer[num_axes][buffer_size]; - int buffer_pos[num_axes] = { 0 ; - - void setup() { 15 Serial.begin(BAUD_RATE); int get_axis(const int axis) { - delay(1); 20 buffer[axis][buffer_pos[axis]] = analogread(pins[axis]); - buffer_pos[axis] = (buffer_pos[axis] + 1) % BUFFER_SIZE; - - long sum = 0; - for (int i = 0; i < BUFFER_SIZE; i++) 25 sum += buffer[axis][i]; - return round(sum / BUFFER_SIZE); int get_x() { return get_axis(0); 30 int get_y() { return get_axis(1); - int get_z() { return get_axis(2); - - void loop() { - Serial.print(get_x()); 35 Serial.print( ); - Serial.print(get_y()); - Serial.print( ); - Serial.println(get_z()); - Wie üblich definieren wir einige Konstanten für die verwendeten Pins. Diesmal definieren wir eine Konstante namens NUM_AXES, die die Anzahl der gemessenen Achsen enthält. Wir definieren auch ein Array namens PINS, das die Liste der verwendeten Pins enthält. Dadurch halten wir den Code für spätere Anwendungen einheitlicher. In Zeile 11 deklarieren wir für alle Achsen Puffer. Sie werden mit den gemessenen Sensordaten gefüllt, so dass wir die Mittelwerte bilden können, wenn wir sie benötigen. Wir müssen unsere aktuelle Position in den Puffern ablegen, deshalb definieren wir in Zeile 12 ein Array für gepufferte Positionen. Setup initialisiert nur den seriellen Port. Der Rest passiert in der Funktion get_axis. Sie beginnt mit einer kleinen Verzögerung, damit Arduino zwischen den Analog-Pins umschalten kann, was die Datenqualität verbessert. Dann liest sie die Beschleunigung für die übergebene Achse und speichert sie in der aktuellen Pufferposition. Sie inkrementiert die Pufferposition und setzt sie auf 0, wenn das Ende des Puffers erreicht ist. Schließlich geben wir den Mittelwert der ausgewerteten Daten für die aktuelle Achse zurück.

8 110 6 Ein bewegungsgesteuerter Game-Controller Das ist alles. Um den Effekt zu sehen, lassen Sie den Sensor still auf Ihrem Tisch liegen und lassen Sie das Programm mit verschiedenen Puffergrößen laufen. Wenn Sie den Sensor nicht bewegen, sollten sich auch die Werte des Programms nicht verändern. Setzen Sie die Puffergröße auf 1, so sehen Sie die Änderungen sofort. Die Werte werden einheitlich, sobald der Puffer groß genug ist. Die gemessenen Beschleunigungswerte sind jetzt hinreichend genau, und wir können endlich einen Game-Controller bauen, der den Benutzer nicht mit unerwarteten Bewegungen überrascht. 6.5 Ihren eigenen Game-Controller bauen Um einen kompletten Game-Controller zu bauen, benötigen wir nur noch einen Taster auf dem Breadboard. In Abbildung 6 4 sehen Sie, wie der Taster angeschlossen wird (prüfen Sie genau, welche Pins Sie auf dem Breadboard verwenden). Abb. 6 4 Game-Controller mit Beschleunigungsmesser und Taster So sieht es auch in einem typischen modernen Game-Controller aus. Unser aktueller Aufbau ist aber nicht sonderlich robust, und wir können das Board nicht herumwirbeln, wenn es mit dem Arduino verbunden ist. Früher oder später löst sich ein Kabel, und der Controller funktioniert nicht mehr.

9 6.5 Ihren eigenen Game-Controller bauen 111 Um dieses Problem zu lösen, sollten Sie das Breadboard mit einigen Gummibändern am Arduino befestigen. Das funktioniert, sieht aber nicht besonders hübsch aus und liegt nicht gut in der Hand. Eine bessere Lösung ist die Verwendung eines Arduino- Proto- Shields (siehe Abbildung 6 5). Es handelt sich um ein ansteckbares Breadboard, mit dem Sie schnell Prototypen erstellen können. Das Breadboard ist von den Arduino-Pins eingefasst, so dass Sie keine langen Kabel mehr benötigen. Shields sind eine tolle Erweiterung für Arduino, und Sie können sie für die unterschiedlichsten Anwendungen bekommen, z. B. Ethernet, Sound, Anzeigegeräte usw.. 2 Abb. 6 5 Ein Arduino-Proto-Shield Mit dem Proto-Shield sieht unser Game-Controller aus wie in Abbildung 6 6. Toll, nicht? Abb. 6 6 Der vollständige Game-Controller auf dem Proto-Shield 2 Unter finden Sie eine umfassende Liste mit Arduino-Shields.

10 112 6 Ein bewegungsgesteuerter Game-Controller Nachdem die Hardware fertig ist, benötigen wir die endgültige Version der Controllersoftware. Sie unterstützt den Taster, den wir eingebaut haben, und führt eine Glättung des Zitterns aus, wie im Abschnitt 6.4, Eckwerte finden und korrigieren, beschrieben. MotionSensor/Controller/Controller.pde #include <Bounce.h> const unsigned int BUTTON_PIN = 7; const unsigned int X_AXIS_PIN = 2; const unsigned int Y_AXIS_PIN = 1; const unsigned int Z_AXIS_PIN = 0; const unsigned int NUM_AXES = 3; const unsigned int PINS[NUM_AXES] = { X_AXIS_PIN, Y_AXIS_PIN, Z_AXIS_PIN ; const unsigned int BUFFER_SIZE = 16; const unsigned int BAUD_RATE = 19200; Int buffer[num_axes][buffer_size]; Int buffer_pos[num_axes] = { 0 ; Bounce button(button_pin, 20); void setup() { Serial.begin(BAUD_RATE); pinmode(button_pin, INPUT); Int get_axis(const int axis) { delay(1); buffer[axis][buffer_pos[axis]] = analogread(pins[axis]); buffer_pos[axis] = (buffer_pos[axis] + 1) % BUFFER_SIZE; long sum = 0; for (int i = 0; i < BUFFER_SIZE; i++) sum += buffer[axis][i]; return round(sum / BUFFER_SIZE); Int get_x() { return get_axis(0); Int get_y() { return get_axis(1); Int get_z() { return get_axis(2); void loop() { Serial.print(get_x()); Serial.print( ); Serial.print(get_y()); Serial.print( ); Serial.print(get_z()); Serial.print( ); if (button.update()) Serial.println(button.read() == HIGH? 1 : 0 ); else Serial.println( 0 );

11 6.6 Ihr eigenes Spiel 113 Wie im Abschnitt 3.7, Ein Würfelspiel, verwenden wir die Klasse Bounce, um den Taster zu entprellen. Der Rest des Codes ist eigentlich Standard. Das einzig Erwähnenswerte ist, dass wir eine Baudrate von verwenden, um die Daten hinreichend schnell zu übertragen. Kompilieren und laden Sie den Code, öffnen Sie das serielle Terminal und spielen Sie mit dem Controller herum. Bewegen Sie ihn, drücken Sie ein paar Mal auf den Taster, und die Ausgabe sollte so ähnlich wie die folgende aussehen: Ein selbstgebauter Controller ist toll, aber wäre es nicht noch besser, ein Spiel dafür zu haben? Das machen wir im nächsten Abschnitt. 6.6 Ihr eigenes Spiel Um unseren Game-Controller zu testen, programmieren wir ein einfaches Breakout-Spiel 3. Ziel des Spiels ist es, alle Steine oben im Bildschirm mit einem Ball zu zerstören. Sie steuern den Ball mit dem Schläger unten auf dem Bildschirm, den Sie wiederum bewegen, indem Sie den Controller um die X-Achse neigen. Das sieht ungefähr so aus: 3

12 114 6 Ein bewegungsgesteuerter Game-Controller Auch wenn dies kein Buch über Spieleprogrammierung ist, schadet es nicht, einen Blick auf die Interna zu werfen, denn Spiele zu programmieren, macht einen Riesenspaß! Laden Sie das Spiel von der Website zum Buch herunter 4 und spielen Sie es, bevor Sie sich mit dem Code beschäftigen. Da wir den Controller an den seriellen Port anschließen, müssen wir ihn initialisieren. import processing.serial.*; Serial arduinoport; Dann definieren wir einige Konstanten, die uns dabei helfen, das Spiel einfach anzupassen. final int COLUMNS = 7; final int ROWS = 4; final int BALL_RADIUS = 8; final int BALL_DIAMETER = BALL_RADIUS * 2; final int MAX_VELOCITY = 8; final int PADDLE_WIDTH = 60; final int PADDLE_HEIGHT = 15; final int BRICK_WIDTH = 40; final int BRICK_HEIGHT = 20; final int MARGIN = 10; final int WIDTH = COLUMNS * BRICK_WIDTH + 2 * MARGIN; final int HEIGHT = 300; final int X_AXIS_MIN = 252; final int X_AXIS_MAX = 443; final int LINE_FEED = 10; final int BAUD_RATE = 19200; Die meisten dieser Werte erklären sich selbst. Sie definieren die Größe des auf dem Bildschirm angezeigten Objekts. Zum Beispiel ist PADDLE_WIDTH die Schlägerbreite in Pixeln, und COLUMNS und ROWS legen das Layout der Steine fest. Sie sollten X_AXIS_MIN und X_AXIS_MAX durch die Minimal- und Maximalwerte ersetzen, die Sie im Abschnitt 6.4, Eckwerte ermitteln und korrigieren, herausgefunden haben. Dann wählen wir die Darstellung der Spielobjekte aus: int px, py; int vx, vy; int xpos = WIDTH / 2; int[][] bricks = new int[columns][rows]; Die aktuellen X- und Y-Koordinaten speichern wir in px und py. Für die aktuelle X- und Y-Geschwindigkeit verwenden wir vx und vy. Die X-Schlägerposition speichern wir in xpos. 4

13 6.6 Ihr eigenes Spiel 115 Bricks ist ein zweidimensionales Array und enthält den aktuellen Status der Steine auf dem Bildschirm. Ist ein Array-Element auf 1 gesetzt, befindet sich der dazugehörige Stein noch auf dem Bildschirm. 0 bedeutet, dass er bereits zerstört wurde. Schließlich müssen wir die möglichen Zustände des Spiels speichern: boolean buttonpressed = false; boolean paused = true; boolean done = true; Es überrascht nicht, dass wir buttonpressed auf true setzen, wenn der Taster auf dem Controller gedrückt wird. Sonst ist der Zustand false. Paused zeigt an, ob das Spiel zurzeit pausiert wird, und done wird true, wenn das aktuelle Level abgeschlossen ist, d. h., wenn alle Steine zerstört sind. Jedes Programm benötigt eine setup-funktion. Hier ist unsere: void setup() { size(width, HEIGHT); nocursor(); textfont(loadfont( Verdana-Bold-36.vlw )); initgame(); println(serial.list()); arduinoport = new Serial(this, Serial.list()[0], BAUD_RATE); arduinoport.bufferuntil(line_feed); void initgame() { initbricks(); initball(); void initbricks() { for (int x = 0; x < COLUMNS; x++) for (int y = 0; y < ROWS; y++ ) bricks[x][y] = 1; void initball() { px = width / 2; py = height / 2; vx = int(random(-max_velocity, MAX_VELOCITY)); vy = -2; Die setup-funktion initialisiert den Bildschirm, versteckt den Mauszeiger mit no- Cursor und setzt die Schriftart für die auszugebenden Meldungen (erstellen Sie den Zeichensatz in Processing mit Tools > Create Font). Dann rufen wir initgame auf, um das Array bricks und die aktuelle Ballposition und -geschwindigkeit zu initialisieren. Damit die Sache spannender wird, wird die Geschwindigkeit für die X-Achse auf einen Zufallswert gesetzt. Wir setzen die Geschwindigkeit für die Y- Achse auf -2, so dass der Ball langsam fällt.

14 116 6 Ein bewegungsgesteuerter Game-Controller Nachdem alles initialisiert ist, implementieren wir die Hauptschleife des Spiels. Dazu bietet sich die draw-methode an: 5 void draw() { background(0); stroke(255); strokeweight(3); done = drawbricks(); if (done) { paused = true; printwinmessage(); if (paused) printpausemessage(); else updategame(); drawball(); drawpaddle(); Wir löschen den Bildschirm und färben ihn mittels background schwarz. Dann setzen wir die Schlägerfarbe auf Weiß und die Schlägerstärke auf drei Pixel. Danach zeichnen wir die verbleibenden Steine. Sind keine Steine mehr übrig, halten wir das Spiel an und geben eine Siegesmeldung aus. Wird das Spiel angehalten, geben wir eine entsprechende Meldung aus. Wenn nicht, aktualisieren wir den aktuellen Spielstand. Schließlich zeichnen wir Ball und Schläger an den aktuellen Positionen mit den folgenden Funktionen: boolean drawbricks() { boolean allempty = true; for (int x = 0; x < COLUMNS; x++) { for (int y = 0; y < ROWS; y++) { if (bricks[x][y] > 0) { allempty = false; fill(0, 0, y * 8); rect( MARGIN + x * BRICK_WIDTH, MARGIN + y * BRICK_HEIGHT, BRICK_WIDTH, BRICK_HEIGHT ); return allempty; 5 bietet eine exzellente Dokumentation für alle Processing-Klassen.

15 6.6 Ihr eigenes Spiel 117 void drawball() { strokeweight(1); fill(128, 0, 0); ellipse(px, py, BALL_DIAMETER, BALL_DIAMETER); void drawpaddle() { int x = xpos - PADDLE_WIDTH / 2; int y = height - (PADDLE_HEIGHT + MARGIN); strokeweight(1); fill(128); rect(x, y, PADDLE_WIDTH, PADDLE_HEIGHT); Wie Sie sehen, ist der Ball ein einfacher Kreis und die Steine und der Schläger sind einfache Rechtecke. Damit sie besser aussehen, haben wir sie mit einem hübschen Rand versehen. Die Meldungen des Spiels auszugeben, ist ebenfalls einfach: void printwinmessage() { fill(255); textsize(36); textalign(center); text( YOU WIN!, width / 2, height * 2 / 3); void printpausemessage() { fill(128); textsize(16); textalign(center); text( Press Button to Continue, width / 2, height * 5 / 6); Die Funktion update ist sehr wichtig, denn sie aktualisiert den Spielstand. Sie prüft auf Kollisionen, bewegt den Ball usw.: void updategame() { if (balldropped()) { initball(); paused = true; else { checkbrickcollision(); checkwallcollision(); checkpaddlecollision(); px += vx; py += vy; Wenn der Spieler den Ball nicht mit dem Schläger trifft und der Ball das Spielfeld verlässt, hält das Spiel an und der Spieler darf nach einem Tastendruck weitermachen. Im endgültigen Spiel würden Sie einen»lebenszähler«herunterzählen und eine»spielende«-meldung ausgeben, wenn der Zähler die 0 erreicht.

16 118 6 Ein bewegungsgesteuerter Game-Controller Solange der Ball im Spiel ist, prüfen wir verschiedene Möglichkeiten der Kollision. Wir prüfen, ob der Ball einen oder mehrere Steine trifft und ob er eine Wand oder den Schläger berührt. Dann berechnen wir die neue Ballposition. Die Kollisionsprüfung sieht kompliziert aus, ist aber recht einfach und vergleicht nur die Koordinaten des Balls mit denen aller anderen Objekte auf dem Bildschirm. boolean balldropped() { return py + vy > height - BALL_RADIUS; boolean inxrange(final int row, final int v) { return px + v > row * BRICK_WIDTH && px + v < (row + 1) * BRICK_WIDTH + BALL_DIAMETER; boolean inyrange(final int col, final int v) { return py + v > col * BRICK_HEIGHT && py + v < (col + 1) * BRICK_HEIGHT + BALL_DIAMETER; void checkbrickcollision() { for (int x = 0; x < COLUMNS; x++) { for (int y = 0; y < ROWS; y++) { if (bricks[x][y] > 0) { if (inxrange(x, vx) && inyrange(y, vy)) { bricks[x][y] = 0; if (inxrange(x, 0)) // Hit top or bottom of brick. vy = -vy; if (inyrange(y, 0)) // Hit left or right side of brick. vx = -vx; void checkwallcollision() { if (px + vx < BALL_RADIUS px + vx > width - BALL_RADIUS) vx = -vx; if (py + vy < BALL_RADIUS py + vy > height - BALL_RADIUS) vy = -vy; void checkpaddlecollision() { final int cx = xpos; if (py + vy >= height - (PADDLE_HEIGHT + MARGIN + 6) && px >= cx - PADDLE_WIDTH / 2 && px <= cx + PADDLE_WIDTH / 2) { vy = -vy; vx = int( map( px - cx,

17 6.6 Ihr eigenes Spiel 119 -(PADDLE_WIDTH / 2), PADDLE_WIDTH / 2, -MAX_VELOCITY, MAX_VELOCITY ) ); Achten Sie darauf, dass die Kollisionsprüfung auch die Ballgeschwindigkeit verändert, wenn es nötig ist. Weitere Experimente mit Bewegungssensoren Da Bewegungssensoren beliebt und kostengünstig sind, wurden damit unglaublich spannende und lustige Projekte erstellt. Ein tolles Beispiel ist Brushduino a. Ein Vater hat es entwickelt, damit seine jungen Kinder ihre Zähne richtig putzen. Die Hauptkomponente ist abgesehen von Arduino ein dreiachsiger Bewegungssensor. Brushduino zeigt mittels LEDs an, welcher Mundbereich als nächstes geputzt werden soll, und immer, wenn das Kind einen Bereich erfolgreich beendet hat, spielt Brushduino ein paar Takte aus Super Mario Brothers. Sie benötigen jedoch keinen Beschleunigungssensor, um tolle neue Elektronikspielzeuge zu bauen. Ein einfacher Neigungssensor reicht aus, um ein interaktives Hacky-Sack-Spiel zu erstellen. b Der Sack blinkt und piepst, wenn Sie ihn treten, und nach 30 erfolgreichen Tritten spielt er ein Lied ab. a b Nachdem sich der Ball jetzt bewegt, ist es nur fair, wenn der Schläger es auch tut. Wie schon gesagt, steuern Sie den Schläger durch Neigen des Controllers um die X-Achse. Hier ist der Code, der die Controllerdaten über den seriellen Port abruft. Line 1 void serialevent(serial port) { - final String arduinodata = port.readstringuntil(line_feed); - - if (arduinodata!= null) { 5 final int[] data = int(split(trim(arduinodata), )); - if (data.length == 4) { - buttonpressed = (data[3] == 1); - if (buttonpressed) { - paused =!paused; 10 if (done) { - done = false; - initgame();

18 120 6 Ein bewegungsgesteuerter Game-Controller - if (!paused) - xpos = int(map(data[0], X_AXIS_MIN, X_AXIS_MAX, 0, WIDTH)); Die Funktion serialevent wird immer dann aufgerufen, wenn am seriellen Port neue Daten verfügbar sind. Der Controller sendet die Daten zeilenweise. Jede Zeile enthält eine aktuelle Beschleunigung für die X-, Y- und Z-Achsen und den aktuellen Status des Tasters. Sie trennt die Werte mit Leerzeichen. In serialevent lesen wir also eine neue Zeile ein, trennen sie an den Leerzeichen und konvertieren die resultierenden Zeichenketten in int-werte. Das geschieht alles in Zeile 5. Wir prüfen, ob wir alle vier Attribute empfangen haben, und dann prüfen wir, ob der Spieler den Taster auf dem Controller betätigt hat. Wenn ja, schalten wir in den Pausenstatus um. Ist das Spiel bereits in der Pause, geht es weiter. Ansonsten halten wir das Spiel an. Außerdem prüfen wir, ob das Spiel beendet wurde. Wenn ja, starten wir ein neues. Schließlich lesen wir die aktuelle X-Beschleunigung in Zeile 17 und übertragen sie auf die möglichen X-Positionen unseres Schlägers. Das ist alles, was notwendig ist, um den Schläger mit unserem eigenen Game-Controller zu steuern. Es spielt außerdem keine Rolle, ob Sie mit dem Controller ein Spiel oder ein völlig anderes Programm steuern. Sie müssen nur die vier int-werte vom seriellen Port lesen, wenn Sie sie benötigen. Spiele mit Arduino Sie können Arduino für mehr als nur für coole eigene Game-Controller verwenden. Sie können damit auch richtig spannende Spiele basteln. Mit den passenden Erweiterungs-Shields können Sie aus Arduino eine leistungsfähige Spielekonsole machen. a Es ist nicht ganz billig, aber plötzlich hat Ihr Arduino einen 320 x 200-Pixel OLED-Touchscreen, einen Analog-Joystick, zwei Taster und sogar einen Vibrationsmotor für Force-Feedback-Effekte. Auf der Suche nach einer preiswerteren Lösung hat jemand Super Mario Bros mit minimaler Hardware nachgebaut. b Das ist ein wunderbares Beispiel für die unglaubliche Kreativität, die Arduino freisetzen kann. a b In diesem Abschnitt haben Sie viel mehr über Spieleprogrammierung gelernt als über Arduino-Programmierung oder Hardware. Ihnen ist aber auch klar geworden, wie einfach es ist, gut konstruierte Elektronik in normale Softwareprojekte einzubinden. Die Analogwerte des Beschleunigungsmessers wurden sorgfältig

19 6.7 Weitere Projekte 121 analysiert, und dann haben wir unerwünschte Schwankungen eliminiert. Dieses Verfahren werden Sie oft in eigenen Projekten anwenden und es taucht auch im kommenden Kapitel wieder auf. 6.7 Weitere Projekte Wenn Sie Ihre Augen offen halten, finden Sie schnell mehr Anwendungen für Beschleunigungsmesser, als Sie dachten. Es folgt eine Auswahl kommerzieller und kostenfreier Produkte: Der ipod-sport-kit von Nike hilft beim täglichen Training und basiert ebenfalls auf einem Beschleunigungsmesser. Sie können viel aus seinem Aufbau lernen. 6 Es macht großen Spaß, ein Brettspiel (wie Marble Maze) auf dem Computer zu programmieren und es über den in diesem Kapitel gebauten Controller zu steuern. Wie viel spannender muss dann ein richtiges Marble Maze sein? 7 In diesem Kapitel haben wir nur die direkte Beschleunigung gemessen. Wir halten den Beschleunigungssensor also in der Hand und bewegen ihn. Sie können jedoch auch spannende Projekte bauen, die indirekt die Beschleunigung messen, z. B. wenn Sie Auto fahren Wenn es nicht funktioniert Alle Ratschläge aus dem Abschnitt 5.10, Wenn es nicht funktioniert, gelten auch für das Projekt hier. Allerdings haben wir einige Besonderheiten, wie das Proto- Shield. Achten Sie darauf, dass es richtig oben auf dem Arduino befestigt ist und dass keine der Anschlüsse versehentlich neben der Verbindung liegen. Manchmal sind Pfostenleisten verbogen, so dass etwas passieren kann. Prüfen Sie, ob Sie die Leiste richtig mit dem Breakout-Board verlötet haben. Nehmen Sie eine Lupe und prüfen Sie jede Lötstelle genau. Haben Sie genug Lötzinn verwendet? Haben Sie zu viel genommen und zwei Verbindungen kurzgeschlossen? 6.9 Übungen Erstellen Sie Ihre eigene Maus mit dem ADXL 335- Beschleunigungssensor. Sie sollte im freien Raum funktionieren und die aktuellen Beschleunigungswerte an X- und Y-Achse übermitteln. Sie sollte eine linke und eine rechte Taste haben. Schreiben Sie ein Programm (in der Programmiersprache Ihrer Wahl), um den Mauszeiger auf dem Bildschirm zu steuern