Shake, rattle ’n’ roll

Mikrocontroller-Programmierung mit dem gewissen Dreh

Praxis & Tipps | Praxis

Die Entwicklerwerkzeuge für die Mikrocontroller-Plattform Arduino sind so einfach gehalten, dass auch Leute ohne Elektrotechnik-Diplom damit beispielsweise einen 3D-Controller bauen können.

Aufmacher

Die Arbeit mit Mikrocontrollern und die Ansteuerung von Hardware hat selbst für viele hochsprachlich gebildete Informatiker immer etwas Geheimnisvolles an sich – dafür müsse man wochenlang Datenblätter lesen und dann kryptischen Code in Assembler schreiben, so die Vorstellung. Aber es geht auch anders, jedenfalls seit 2005: Da waren es die Studierenden des Interaction Design Institute im italienischen Ivrea leid, mit ihren Computern nur über Tastatur und Maus zu kommunizieren. Sie suchten nach einer einfachen Möglichkeit, um ihre Ideen für neuartige Interaktionen zwischen Mensch und Maschine, ihre Kunst- und Roboterprojekte in funktionsfähige Prototypen umzusetzen. Ihr Dozent Massimo Banzi entwickelte daraufhin mit einer Handvoll Mitstreitern ein einfaches, günstiges Mikrocontroller-Board samt Programmiersprache und Entwicklungswerkzeug und nannte es Arduino, nach einem lokalen König aus dem elften Jahrhundert (andere erzählen, nach einer Kneipe um die Ecke).

Das kleine Board mit dem großen Namen trat schnell einen Siegeszug an – gerade weil es sich nicht so sehr an lötende Nerds, sondern an Quereinsteiger wie Designer oder Künstler richtete, die vorher nur in extremen Ausnahmefällen Software entwickelt oder gar eigene Hardware gebaut hatten. Das Netz ist voller Bauanleitungen für die Plattform, die von der Laserharfe über twitternde Topfpflanzen bis zu autonom fliegenden Luftschiffen reichen. Arduino macht aber auch an der USB-Leine eine gute Figur: Mit Sensoren und Aktoren versehen und über eine emulierte serielle Schnittstelle an einen Computer gekoppelt dient es als Messfühler, Sinnesorgan oder Eingabegerät – je nachdem, ob man Protoypen für Tangible Interfaces baut [1] oder einen für Beschleunigung sensiblen Spiele-Controller, wie er im Folgenden beschrieben wird. Damit steuert man mittels Gesten im Raum das Geschehen auf dem Bildschirm, ähnlich wie bei der Konsole Wii.

Vom Arduino-Board stehen mittlerweile verschiedene Bauformen zur Wahl (siehe Kasten). Für den Einstieg benötigt man ferner ein USB-Kabel für den Anschluss an den Rechner. Hilfreich ist zusätzlich ein Steckbrett (englisch breadboard), mit dessen Hilfe man zusätzliche Bausteine wie Leuchtdioden, Taster, Beschleunigungs- und Abstandssensoren, Servos oder Motoren ganz ohne Lötkolben an den Controller anschließt. Um nacheinander die im Folgenden vorgestellte erste Testschaltung und anschließend unseren 3D-Spiele-Controller zu bauen, braucht man einen kleinen Taster, eine Leuchtdiode (20 mA), je einen Widerstand zu 1 kΩ und 10 kΩ sowie einen Beschleunigungssensor ADXL330 mit Platine. Als komplettes Paket bietet Segor Electronics alle benötigten Teile für rund 90 Euro an (inklusive Arduino Nano). Links zu diesem Angebot, zu weiteren Bezugsquellen für die Hardware, Software-Downloads und den Code aller beschriebenen Beispielprogramme finden Sie auf unseren Arduino-Seiten auf heise online, die Sie über den Link am Ende des Artikels erreichen. Weiterhin finden Sie dort ein Wiki und ein Diskussionsforum, die wir zum Austausch von Erfahrungen, Schaltplänen und Code eingerichtet haben.

Der Name Arduino bezeichnet nicht nur das Mikrocontroller-Board, sondern auch die zugehörige kompakte integrierte Entwicklungsumgebung (IDE) für den Steuercode. In der IDE entwickelt man kleine Programme, sketches genannt, und sendet sie über USB als Hex-Dateien mit Maschinencode an das Arduino-Board. Dieses schreibt das Programm selbst dauerhaft in seinen Flash-Speicher und führt es sofort danach aus.

Bestückungsplan
Vergrößern Der Bestückungsplan für die LED-Schaltung zeigt den Aufbau auf dem Steckbrett in allen Einzelheiten. Hinzudenken muss man sich die in der Grundplatte verborgenen Verbindungen zwischen den Steckkontakten - waagerecht und über die ganze Länge jeweils bei den oberen und unteren beiden Längsreihen, senkrecht bei den Fünferreihen dazwischen.

Die IDE steht im Netz kostenlos für Mac OS X, Windows und Linux zur Verfügung. Sie ist nach Auspacken des ZIP-Archivs sofort gebrauchsfertig. Um die USB-Verbindung zum Rechner gegenüber dem Board als serielle Schnittstelle auszugeben, benötigt man allerdings noch einen USB-Treiber für den Rechner. Den findet man zwar auch im Arduino-Paket selbst im Verzeichnis namens drivers, allerdings nur in einer älteren Version. Besser installiert man sich den aktuellen Virtual-COM-Port-Treiber (VCP) des Chip-Herstellers FTDI.

Die Arduino-Programmiersprache ist ein Dialekt von C/C++, den die IDE per GCC (Gnu C Compiler) für das Board kompiliert. Die Sprache ist sehr einfach zu erlernen, selbst wenn man sich eher bei anderen Programmiersprachen zu Hause fühlt. Wer bereits mit Processing [2] gearbeitet hat, dem kommt zudem die Arduino-IDE selbst bekannt vor – sie basiert auf jener von Processing.

Auch die Codestruktur ähnelt der von Processing: Ein Arduino-Programm besteht immer aus zwei Teilen, einem Initialisierungsblock setup(), der bei Beginn einmal durchlaufen wird, und einer anschließenden Endlosschleife loop().

Um seine Programme leichter lesen und ändern zu können, definiert man für die benutzten Pins des Arduino-Boards sprechende Namen – in unserem ersten Beispiel hört Pin 2 (auf dem Nano über dem Stift mit D2 beschriftet) auch auf den Namen inputPin. Die wichtigsten Arduino-Funktionen kümmern sich um die Pins. So erklärt pinMode() Pins entweder zum Eingang oder zum Ausgang. Als Parameter erwartet diese Funktion die Pin-Bezeichnung und eine der Konstanten INPUT und OUTPUT. Von einem Eingangs-Pin p liest digitalRead(p), digitalWrite(q, HIGH) schreibt auf einen als Ausgang konfigurierten Pin q den Wert HIGH, was 1 (anliegende Spannung 5 Volt) entspricht. LOW hingegen stünde für 0 (0 Volt).

Der Bestückungsplan unten zeigt, wie Sie die Teile für eine erste Testschaltung anordnen. Beim Steckbrett sind jeweils die oberen und die unteren beiden Lochreihen längs miteinander verbunden; sie werden mit der Versorgungsspannung (+) und Masse (–) beschaltet. Die Reihen im Inneren sind hingegen untereinander quer verbunden, wobei die Längskerbe des Steckbretts wiederum die obere und die untere Hälfte zu je fünf Löchern trennt. Die schwarze Drahtbrücke in der Beispielschaltung schließt den Massepin (GND) an die unterste Lochleiste an, die rote beschaltet die Reihe darüber mit 5 Volt. Die orangenen Leitungen koppeln die Pins D13 und D2 mit der LED und dem Taster. Während im Plan die Farben der Kabel deren Funktion kodieren, bestimmt beim fürs Foto verwendeten Drahtbrückensatz die Länge der Leitung deren Farbe, weshalb es zu Abweichungen zwischen beiden Bildern unten kommt. Falls Sie mit unserem Beispiel die erste elektronische Schaltung Ihres Lebens aufbauen, beachten Sie bitte auch die ausführlichen Hinweise auf unserer Webseite.

Stecken alle Teile am richtigen Platz, öffnen Sie die Arduino-IDE, laden das Beispielprogramm button.pde von unserer Webseite, wählen unter Tools/Board „Arduino Nano“ aus, falls Sie mit dem Segor-Materialpaket arbeiten (ansonsten picken Sie Ihr verwendetes Board heraus). Dann schicken Sie den Code über einen Mausklick auf das eckige Symbol mit dem Pfeil nach rechts (Upload to I/O Board) an den Microcontroller. Die LED sollte jetzt leuchten und immer dann verlöschen, wenn Sie den Taster drücken. Klappt das Hochladen nicht, überprüfen Sie bitte, ob unter „Tools/Serial Port“ die korrekte Schnittstelle gewählt ist. Auf dem Mac ist jene die richtige Wahl, die /dev/tty.usbserial im Namen führt, unter Windows hilft oft ein Blick in den Gerätemanager.

Viele der Sensoren, die man an ein Arduino anschließen kann, arbeiten nicht mit digitalen Werten, sondern mit analogen. Beispielsweise liefert ein Entfernungssensor wie der Sharp GP2D12, den auch der c't-Bot zur Orientierung im Raum benutzt, Spannungen zwischen 0,45 und 2,45 Volt, um gemessene Entfernungen zwischen 10 und 80 Zentimetern zu kodieren [3]. Auch mit solchen Werten kommt das Board klar. Acht der Pins eines Arduino Nano (A0 bis A7) hängen an einen Analog-Digital-Umsetzer (Analog Digital Converter, ADC). Das Standard-Board hingegen verfügt nur über sechs solcher Pins, die mit ANALOG IN gekennzeichnet sind. Der ADC übersetzt die analogen Werte zwischen 0 und 5 Volt in digitale zwischen 0 und 1023.

Entsprechend den digitalen Operationen gibt es auch Funktionen, um analoge Werte zu verarbeiten, analogRead() und analogWrite(); die Parameter entsprechen jenen bei den digitalen Funktionen. analogWrite() ist für die sechs PWM-Pins gedacht (Nummer 3, 5, 6, 9, 10 und 11, auf dem Nano-Board jeweils mit vorgestelltem D gekennzeichnet). PWM steht für Pulsweitenmodulation, denn über die Pins wird kein echter Analog-Wert ausgegeben. Stattdessen wird die Spannung am Pin sehr schnell an- und abgeschaltet. Das Verhältnis von Einschalt- zu Ausschaltdauer bildet einen Pseudowert für die Spannung. Auf diese Weise kann man etwa eine LED dimmen – das Auge ist zu träge, um die einzelnen Schaltvorgänge zu registrieren. Stattdessen scheint die LED heller oder dunkler zu leuchten. Für einen sauberen Analogwert ist allerdings ein Pufferkondensator nötig.

Eigentlich ist die Pulsweitenmodulation jedoch dafür gedacht, über das Verhältnis von An- zu Abschaltzeit eine Information zu übertragen, etwa, wie schnell ein angeschlossener Motor laufen oder welche Position der Arm eines Servos einnehmen soll. Ganz trivial ist die Servosteuerung allerdings nicht – Servos erwarten eine feste Grundfrequenz. Voraussetzung dafür ist eine Timer-Einheit auf dem Mikrocontroller, und die steht beim für Arduino verwendeten ATmega168 nur paarweise für je zwei Pins zur Verfügung. Leichter geht die Servo-Ansteuerung mit einer passenden Bibliothek, die die Arduino-Entwickler gleich mitliefern. In unserem zweiten Beispiel holt die erste Code-Zeile #include<Servo.h> Funktionen für die Ansteuerung von RC-Servos ins Boot. Welche weiteren Bibliotheken dem Programmierer noch mit fertigen Funktionen für spezielle Aufgaben zu Diensten stehen, sieht man auf der Arduino-Webseite unter der Rubrik Reference in der Kategorie Libraries.

Servo-Experiment
Vergrößern Die Schaltung für das Servo-Experiment ist simpel: Man verbindet einfach die Steuerleitung des Servo mit Pin 9 und beschaltet die anderen beiden mit 0 und 5 Volt. Achtung: Die Hersteller kodieren die Kabel ihrer Servos unterschiedlich, bei falschem Anschluss stirbt möglicherweise der Servo.

Im Beispiel sollen die Steuerbefehle für den Servo von der PC-Tastatur kommen. Die nötige Kommunikation zwischen Rechner und Mikrocontroller benötigt nur wenige Zeilen Code. Das Programm initialisiert die vom USB-Chip emulierte serielle Schnittstelle auf Board-Seite mit Serial.begin(9600), wobei 9600 für die Baudrate (Verbindungsgeschwindigkeit) steht. Danach schreibt es per Serial.print() auf die Schnittstelle. Die Arduino-IDE enthält ein einfaches Terminal, über das Sie mit dem Board kommunizieren können. Klicken Sie dafür einfach auf das Icon „Serial Monitor“ und wählen Sie als Baudrate ebenfalls 9600 aus. Wenn Sie über den Eingabeschlitz anschließend ein ASCII-Zeichen eintippen und es per Send-Knopf auf die Reise schicken, wird es auf dem Board als Byte-Wert interpretiert, der etwas normalisiert wird und dann die gewünschte Stellung des Servo-Ärmchens angibt – von 0 bei der Leertaste bis 180 bei z. Je größer der Wert, umso weiter dreht der Servo gegen den Uhrzeigersinn.

Die serielle Schnittstelle steht für die Anbindung von Anwendungen auf PC-Seite prinzipiell so gut wie jeder Programmiersprache offen. Auf dem Arduino-Playground, dem offiziellen Wiki der Arduino-Fans, gibt es Beispielcode unter anderem in Java, Ruby, Perl und Processing, aber auch Pure Data und Matlab. Adobe Flash hingegen bietet zwar keinen direkten Zugriff auf die serielle Schnittstelle, kann aber mit einem Netzwerk kommunizieren und durch diverse Serial-To-Network-Proxies eine serielle Schnittstelle als Socket zur Verfügung gestellt bekommen.

In Python und mit pySerial, einer Bibliothek für den Zugriff auf die serielle Schnittstelle, funktioniert die Servoansteuerung wie folgt:

import time
import serial
ser = serial.Serial('/dev/tty.usbserial-A4001JAh', 9600)
while (True):
ser.write(chr(0))
time.sleep(1)
ser.write(chr(180))
time.sleep(1)

Manche Sensoren sind durch ihre massenhaften Verwendung in Unterhaltungselektronik sehr günstig geworden – beispielsweise der 3-Achsen-Beschleunigungssensor ADXL330 von Analog Devices, der in der Wii-Fernbedienung (Wiimote) steckt. Dabei handelt es sich um einen Chip, der die Beschleunigung bis ±3 g für jede Achse messen kann. Da auch auf den ruhenden Chip stets die Erdbeschleunigung von 1 g wirkt, zeigt der ruhende Sensor gleichzeitig seine Neigung bezogen auf die X-, Y- und Z-Achse und damit seine Lage an. Die gemessene Beschleunigung stellt er als analoge Werte für die drei Richtungen bereit. Segor bietet den Sensor fertig auf einem Sockel montiert an, der sich einfach auf das Steckbrett stöpseln lässt.

Drei Anschlussstellen mit Unterstützung durch einen Analog-Digital-Wandler wickeln den eigentlichen Sensor-Input ab. In der Funktion loop() liest die Zeile Serial.print(analogRead(xPin)); die Beschleunigung in X-Richtung aus und schickt den Wert direkt an die serielle Schnittstelle. Nach dem gleichen Strickmuster meldet das Programm die Y- und Z-Beschleunigungen an den angeschlossenen Rechner. Ein vierter (digitaler) Pin wird für den Taster aus dem ersten Beispiel benötigt – und schon ist der selbstgebaute 3D-Game-Controller fertig.

Jetzt fehlt nur noch ein Spiel zum Ausprobieren. Hierfür bietet sich Processing als einfache Entwicklungsumgebung an: Sie läuft unter Windows, Mac OS X und Linux, ist auf Grafik, Animation und Interaktion spezialisiert und hat eine große Fangemeinde, die ihre Programme in der Regel frei zur Verfügung stellt. Processing und Arduino sind gewissermaßen Schwesterprojekte – mit beiden zusammen ist es möglich, selbstgebaute Hardware an eigene Programme zu koppeln und so die virtuelle Welt im Handumdrehen mit der wirklichen zu verbinden.

Fürs schnelle Erfolgserlebnis mit dem Eigenbau-Game-Controller haben wir LunarLander programmiert, ein kleines Spiel in Retro-Grafik, bei dem man eine Landefähre über die zerklüftete Mondoberfläche navigieren muss. Ziel ist die sichere Landung auf einer der wenigen waagerechten Flächen. Die Lage der Landefähre steuert man über den Beschleunigungssensor, indem man das Steckbrett mit dem USB-Kabel nach links in die Hand nimmt und sanft nach rechts oder links kippt. Der Schalter auf dem Board zündet die Hauptrakete, die den Sinkflug bremst. Das Spiel wird standardmäßig über die Cursortasten gesteuert – sobald Sie Ihren Arduino angeschlossen haben, setzen Sie einfach serialAvailable auf true, um den Controller scharf zu schalten.

3D-Spiele-Controller
Vergrößern Der 3D-Spiele-Controller ist nicht wesentlich komplizierter aufzubauen als die LED-Schaltung. Herzstück bildet der Beschleunigungssensor ADXL330, der auch in der Wiimote steckt.

Da der ADXL330 auf dem Segor-Sockel um 45° gegenüber der Normallage verdreht eingelötet ist, rechnet unser Programm die rohen Messwerte des Sensors in Beschleunigung beziehungsweise Schräglage parallel zu den Kanten des Steckbretts um. Für das eigentliche Spiel berücksichtigt es nur Bewegungen in Längsrichtung (Kippen nach rechts und links, umgerechnete Y-Richtung). Die Datenkommunikation mit Arduino läuft auch von Processing aus über die serielle Schnittstelle. Sie wird wie auf Board-Seite wieder mit der Baudrate initialisiert. Falls Sie nicht sicher sind, an welcher der Schnittstellen das Board angeschlossen ist, können Sie sich per println(Serial.list()); eine Liste ausgeben lassen. Die richtige Schnittstelle ist die gleiche, die auch in der Arduino-IDE für die Kommunikation ausgewählt wurde.

Die setup()-Routine initialisiert die Schnittstelle. Die draw()-Funktion wird in einer Endlosschleife ausgeführt, wie loop() bei Arduino. Ihre Hauptaufgabe ist es, die Bildschirmausgabe zu aktualisieren, daher ihr Name. Zusätzlich prüft port.available() in jedem Durchlauf, ob die Schnittstelle Zeichen empfangen hat. Ist dies der Fall, ruft das Programm die Funktion serialEvent() auf, die als Parameter ein gelesenes Zeichen übergeben bekommt. Aus einzelnen Zeichen setzt sie wieder einen String zusammen. Ist der übergebene Parameter ein Zeilenvorschub (ASCII-Code 10), ist eine Zeile komplett und kann weiterverarbeitet und interpretiert werden. Anschließend leert sie den String, um die nächste Zeile aufzunehmen.

Ein 3D-Eingabegerät wird natürlich erst richtig cool, wenn er nicht mehr an einem Kabel hängt. Für die drahtlose Kommunikation bieten sich etwa die XBee-Module von Digi an. Diese ermöglichen unter anderem Point-to-Point- und Multicast-Kommunikation. Zwei dieser Module ersetzen das USB-Kabel, wenn man sie als serielle Schnittstelle konfiguriert. Um CRC (Prüfsummen) und Fehlerkorrektur muss man sich nicht kümmern, das erledigen bereits die Module. Der Programmcode bleibt identisch, trotzdem funktioniert der Spiele-Controller anschließend drahtlos.

Unsere Beispiele aus diesem Artikel können natürlich nur an der Oberfläche dessen kratzen, was mit Arduino möglich ist – Topfpflanzen warten auf die Wasserstandsprüfung per Mikrocontroller, elektronisches Spielzeug will auch nicht dumm sterben und selbst die Steuerung manch einer Kaffeemaschine kann mit Arduinos Hilfe vorangebracht werden. Bauanleitungen, Anregungen und reichlich Hilfe gibt es im Netz in Foren und Blogs. Zu fast jedem Baustein oder Sensor findet man dort ein Beispiel inklusive Schaltplan und Programm. Durch den Quasi-Standard von Arduino-Hardware und -Software kann man praktisch alle Beispiele ohne viel Re-Design umsetzen. Rund um das Board sind weitere Projekte entstanden, etwa der Schaltungsplaner Fritzing vom Interaction Design Lab in Potsdam, mit dessen Hilfe wir die Bestückungspläne für diesen Artikel gezeichnet haben.

Über den Link unten gelangen Sie auf die Arduino- und Processing-Seiten auf heise online. Dort finden Sie neben dem Quellcode aller Beispielprogramme und nützlichen Links ebenso ein Forum und ein Wiki. Über das Wiki können Sie Ihre eigenen Programme und Projekte auch anderen Lesern zur Verfügung stellen – wir sind selbst schon sehr gespannt, auf welche Ideen Sie kommen und freuen uns über jede Code-Skizze, die uns erreicht.

Literatur

[1] Peter König, Tangible Interfaces, Schnittstellen machen Daten anfassbar, c't 21/08, S. 86

[2] Peter König, Kleinkunstprogramm, Algorithmische Bilder und Animationen mit Processing, c't 24/07, S. 206

[3] Benjamin Benz, Nervensystem, Programmierung des c't-Bot von der Pike auf, c't 6/06, S. 264

www.ct.de/0916164

Arduino-Anatomie

Das Herz des Arduino-Boards bildet ein ATmega168 der Firma Atmel. Dieser 8-Bit-Mikrocontroller läuft mit 16 MHz Taktfrequenz und besitzt 16 KByte Flash für das Programm und 1 KByte SRAM für Variablen. Damit ist er genauso schnell wie der Controller auf dem c't-bot, hat allerdings nur halb so viel Speicher und nur 23 statt 32 Leitungen für Ein- und Ausgabe (I/O). Auf dem Arduino-Standard-Board stehen 20 Pins für digitale Ein- und Ausgabe zur Verfügung. Davon sind sechs Pins als Analog-Eingänge (ADC) verwendbar, sechs weitere können über Pulsweitenmodulation analogen Output simulieren. Laut Beschreibung auf der Arduino-Webseite soll jeder Pin bis zu 40 mA Strom liefern – schaut man in die Fußnoten der Datenblätter des verbauten Mikrocontrollers, garantiert dessen Hersteller allerdings nur für bis zu ±20 mA; zudem darf die Summe der Stromstärken an bestimmten Ports nicht mehr als 150 mA beziehungsweise –100 mA betragen. Das reicht trotzdem, um kleinere Verbraucher wie Leuchtdioden direkt zu betreiben. Stärkere Ströme steuert man per nachgeschaltetem Transistor. Im Betrieb wird der Arduino entweder per USB, per Netzteil oder per Batterie mit 7 bis 12 Volt versorgt.

Da die Arduino-Hardware unter einer Open-Source-Lizenz (Creative Commons Attribution Share-Alike) veröffentlicht wird, gibt es mittlerweile eine kaum überschaubare Menge an Bauvarianten. Neue Boards benutzen oft einen ATmega328 mit 32 KByte Speicher. Für das Arduino-Standard-Board, dessen aktuelle Revision auf den Namen Duemilanove (italienisch für 2009) hört, sprechen hingegen dessen weite Verbreitung, der günstige Preis von unter 30 Euro und die Möglichkeit, es über sogenannte Shields zu erweitern. Das sind Platinen, die einfach auf die Buchsenleisten des Arduino gesteckt werden und die es beispielsweise für die Ausgabe von Wave-Dateien, zur Kommunikation per TCP/IP oder zum Empfang von GPS-Daten befähigen oder einen OLED-Bildschirm mit Touchscreen nachrüsten.

Duemilanove kommt fertig montiert ins Haus, man muss also nicht selbst zum Lötkolben greifen. Allerdings ist seine Bauform nicht besonders praktisch, wenn man es mit einem Steckbrett kombinieren will, denn die Buchsenleisten passen nicht auf dessen Lochraster. Als günstiger erweist sich hier die kompakte Variante Arduino Nano, deren nach unten gerichtete Pins für festen Halt auf dem Steckbrett sorgen, weshalb wir in diesem Artikel das Nano-Board für die Beispiele verwendet haben. Die deutlich kompaktere Bauform (43 mm x 18 mm) schlägt sich im etwas höheren Preis von rund 50 Euro nieder. Prinzipiell kann man alle hier vorgestellten Schaltungen aber auch mit einem Standard-Board umsetzen. Fotos und Bestückungspläne dafür finden Sie auf unseren Online-Seiten zu diesem Artikel, die Sie über den Link am Ende des Textes erreichen.

Ebenfalls auf Steckbretter passen der Boarduino von Adafruit Industries oder das RBBB (Really Bare Bones Board) von Modern Device. Das RBBB hat allerdings keinen USB-Anschluss, man braucht zusätzlich ein USB-Kabel mit Seriell-Umsetzer. Viele Arduino-Klone werden als Bausatz vertrieben und sind günstiger als das Nano-Board, mit einem (Standard-)Lötkolben muss man dann aber umgehen können. Die Bausätze enthalten keine SMD-Komponenten (Surface Mounted Device), sind also recht einfach zu bestücken.

Weiterhin gibt es spezielle Arduino-Versionen für besondere Umgebungen, die etwa für knappen Platz oder für besonders niedrigere Versorgungsspannungen von 3,3 Volt optimiert sind. Ein besonderer Exot ist Lilypad, ein Arduino für „Wearable Computing“, der mit leitfähigem Garn in Kleidung eingenäht wird.

Listing: Servo-Steuerung per Tastaturbefehl

  1 #include <Servo.h>		 // Servo-Bibliothek einbinden
2
3 Servo servo; // Servo-Objekt erzeugen
4 int servoPin = 9; // Servo wird an Pin 9 angeschlossen
5 int pos = 0; // Variable zum Speichern der Position
6
7 void setup() { // Initialisierung
8 Serial.begin(9600); // Serielle Verb., 9600 baud
9 servo.attach(servoPin); // Servo mit servoPin verbinden
10 }
11
12 void loop() {
13 if (Serial.available()) { // Zeichen verfuegbar?
14 pos = Serial.read(); // Zeichen lesen
15 // nur Zeichen zwischen " " und z auswerten
16 if ((pos >= 32) && (pos <= 122)) {
17 pos = (pos-32)* 2; // Z.bereich auf Vollausschlag strecken
18 servo.write(pos); // Position an Servo senden
19 delay(500); // Warten, bis Position erreicht wurde
20 Serial.println(pos); // Position bestaetigen
21 }
22 }
23 }

Arduino rüstet den PC per USB und serielle Verbindung für die Interaktion mit seiner Umwelt aus - hier bewegt sich das Ärmchen eines Servo auf Tastaturbefehl.

Listing: Kommunikation mit dem Arduino-Board

  1 import processing.serial.*;
2
3 Serial port;
4 String buffer = "";
5 int NEWLINE = 10;
6
7 void setup() {
8 println("Available serial ports:");
9 println(Serial.list());
10 port = new Serial(this, Serial.list()[0], 9600);
11 [...]
12 }
13
14 void draw() {
15 [...]
16 while (serialAvailable && port.available() > 0) {
17 serialEvent(port.read());
18 }
19 }
20
21 void serialEvent(int serial) {
22 if (serial != NEWLINE) {
23 // Store all the characters on the line.
24 buffer += char(serial);
25 }
26 else {
27 [...]
28 String bufs[] = buffer.split(" ");
29 int yval = Integer.parseInt(bufs[1]);
30 boolean buttonPressed = bufs[3].equals("1");
31 buffer = "";
32
33 if (buttonPressed) {
34 lander.rocketOn();
35 }
36 else {
37 lander.rocketOff();
38 }
39 lander.rotateAngle((344 - yval)/50.0);
40 }
41 }

Die Kommunikation mit dem Arduino-Board aus der Programmierumgebung Processing heraus erfolgt über die serielle Schnittstelle und erfordert nur wenige Zeilen Code.

Anzeige