Die Arbeit mit der quelloffenen Hardware Arduino bietet einen unkomplizierten Einstieg in die Welt der Mikrocontroller und elektronischen Schaltungen. Erweiterte Funktionen wie Netzwerkzugang lassen sich über vorkonfektionierte Zurüst-Boards schnell ergänzen.

Ursprünglich entstand das Arduino-Projekt [1] an einem mittlerweile geschlossenen Design-Institut [2] im italienischen Turin und verdankt seinen Namen einem Studentencafé in dessen Nähe. Arduino hat es sich zum Ziel gesetzt, die Einstiegshürde in die Welt des Physical Computing zu senken. Unter Physical Computing versteht man die Verbindung von Software mit ihrer physischen Umwelt durch das Ansteuern von Sensoren, Motoren und diversen Ausgaben wie LEDs.

Computer bieten durch eine Fülle von Schnittstellen bereits viele Möglichkeiten, mit Sensoren und Geräten zu kommunizieren, jedoch lässt sich ein Motor oder Temperaturfühler nicht ohne Weiteres anschließen und steuern. Dazu braucht man zum einen Adapter und zum anderen gilt es von Fall zu Fall zu prüfen, in welcher Programmiersprache sich das System am einfachsten anzusprechen lässt. Weniger ist daher mehr.

Die Arduino-Plattform verbindet die freie Architektur eines Mikrocontroller-Boards mit analogen und digitalen Schnittstellen sowie einer zugehörigen Entwicklungsumgebung. Sie schließen das Board bequem über eine USB-Schnittstelle an den PC an, mit einer eigenen Stromquelle läuft es jedoch alternativ auch autark. Ein Bootloader ermöglicht es, Programme direkt per USB auf das Board zu schreiben.

Zur Programmierung dient eine C++-Implementation der eigentlich Java-basierten Sprache Processing. Bei Processing handelt es sich um eine vereinfachte Form von Java, die sich an den pragmatischen Anforderungen von Künstlern, Gestaltern und Einsteigern orientiert. Bei der integrierten Arduino-Entwicklungsumgebung handelt es sich um eine relativ schlanke Java-basierte IDE, die Ihnen alle notwendigen Hilfsmittel zu Verfügung stellt: Syntax-Highlighting, Codebeispiele, Kompilieren und das Übertragen von Programmen. Weitere Bibliotheken erweitern die Sprache um Treiber für elektronische Bauteile und zusätzliche Funktionen.

Erstausstattung

Für die Arbeit mit Arduino benötigen Sie ein Arduino-Board und ein USB-Kabel zur Programmierung und Kommunikation. Am besten greifen Sie zu einem der angebotenen Einsteiger-Sets, die in der Regel aus einem Board, einem USB-Kabel, verschiedenen elektronischem Komponenten sowie einer Steckplatine bestehen [3].

Es gibt verschiedene Varianten und Generationen von Arduino. Die beste Wahl für Einsteiger ist das aktuelle Arduino Duemilanove (Abbildung 1). Auf ihm befinden sich ein ATmega328-Mikrocontroller von Atmel, ein Reset-Schalter, 14 digitale I/O Pins, sechs analoge Eingänge, eine USB-Schnittstelle, ein Anschluss für eine Stromversorgung, je eine Tx/Rx-LED (Senden/Empfangen), eine Power-LED und eine Test-LED.

Abbildung 1: Italienische Leckerei: Das Arduino Duemilanove ist nach dem Jahr seines Entstehens benannt, 2009.

Die Entwicklungsumgebung laden Sie für verschiedene Betriebssysteme auf Arduino.cc [4] herunter. Sie müssen das Archiv lediglich entpacken. Neben einer Java-Laufzeitumgebung benötigt die IDE auf dem Rechner einen Compiler für den AVR Atmel sowie einige Build-Werkzeuge. Die notwendigen Programme und Bibliotheken richten Sie auf einem aktuellen Ubuntu-Desktop mithilfe der Paketverwaltung schnell ein:

# apt-get install gcc-avr binutils-avr avr-libc librxtx-java avrdude

Weitere Informationen und Hilfe für Problemfälle (etwa mit Ubuntu “Hardy” oder 64-Bit-Versionen) finden Sie im Arduino-Wiki [5]. Es gibt zudem inoffizielle Paket-Repositories für verschiedenste Distributionen.

Nach dem Starten der Arduino-IDE und dem Anschließen des Boards müssen Sie in der Entwicklungsumgebung noch über Tools | Serial Port den korrekte Anschluss konfigurieren. Meist handelt es sich um /dev/ttyUSB0.

Hallo Welt

Das “Hallo Welt” des Physical Computing ist das Blinken einer Leuchtdiode (LED). Erfreulicherweise befindet sich auf dem Arduino eine Test-LED am digitalen Pin 13, die Sie für einen ersten Versuch ohne weiteren Aufwand ansteuern können. Listing 1 zeigt das entsprechende Programm und verdeutlicht gleichzeitig die generelle Struktur eines Arduino-Processing-Programms: Es gibt eine setup()-Methode, die beim Start einmal zum Einsatz kommt, und eine loop()-Methode, die das Programm kontinuierlich durchläuft. Variablen gilt es vor Gebrauch unter Zuweisen eines Datentyps zu deklarieren.

// Hallo Welt, Physical-Computing-Variante:
// Test-LED zum Blinken bringen
int ledPin = 13;           // LED am digitalen Pin 13
void setup() {
  pinMode(ledPin, OUTPUT); // setze Modus auf Ausgabe
}
void loop() {
  digitalWrite(ledPin, HIGH);   // schalte LED ein
  delay(1000);                  // warte eine Sekunde
  digitalWrite(ledPin, LOW);    // schalte LED aus
  delay(1000);                  // warte eine Sekunde
}

Die setup()-Methode des Beispielprogramms legt fest, dass es sich bei Pin 13 um eine Ausgabe handelt. Die loop()-Methode setzt abwechselnd den Status HIGH (Strom an) und LOW (Strom aus) für den Pin, dazwischen wartet sie jeweils eine Sekunde. Mittels eines Mausklicks auf Upload kompilieren Sie das Programm und übertragen es gleich zum Arduino. Während der Übertragung flackern die Tx/Rx-LEDs, kurz danach startet das Programm automatisch. Die Test-LED blinkt dann kontinuierlich im Sekunden-Takt. Hallo, Arduino!

Blinkeblinke

Im nächsten Schritt sollen drei ans Arduino angeschlossene externe LEDs zufällig blinken. Für den schnellen Aufbau solcher Schaltungen hat sich der Gebrauch von Steckplatinen (auch Steckbretter oder Breadboards genannt) durchgesetzt. Sie ermöglichen das lötfreie Entwerfen und Testen von Schaltungen.

Allerdings gibt es keinen Standard für solche Steckplatinen – vor dem Einsatz müssen Sie daher erst einmal prüfen, wie sie intern verbunden sind. Meist gibt es am Rand eine oder zwei durchgehende Reihen für die Stromversorgung. Die Quer-Reihen – oft nummerierte Zeilen – sind in der Regel verbunden. Gibt es in der Mitte eine Spalte, stehen die Reihen links und rechts davon nicht direkt miteinander in Verbindung (Abbildung 2).

Abbildung 2: Ein typisches Breadboard, wie es sich zum lötfreien Aufbau von Schaltungen einsetzen lässt.

Auf dem Arduino befinden sich zwei mit GND (“Ground”) beschriftete Eingänge. Dabei handelt es sich um die Massepunkte, die als Minuspol für die Stromkreise dienen. Da am oberen Rand 13 Ein/Ausgänge auf einen GND kommen, müssen Aufbauten mehrere Verbindungen über eine Leitung gesammelt zum GND führen, wie Sie im folgenden Beispiel sehen werden.

LEDs weisen wie alle elektronischen Bauteile gewisse physikalische Eigenschaften auf, die Sie beim Einsatz beachtet müssen, um Defekte zu vermeiden. So sollten Sie die Leuchtdioden beispielsweise nicht direkt vom Arduino aus ansteuern, sondern über einen Widerstand mit Strom versorgen. Dieser wandelt Strom in Wärme um und erhöht dabei die Spannung. Die Stärke eines Widerstandes lässt sich anhand eines aufgebrachten farbigen Strichcodes erkennen [6].

In der Beispielschaltung werden drei farbige LEDs über je einen Widerstand an die digitalen Pins 8, 10 und 12 angeschlossen. Abbildung 3 zeigt den einfachen Aufbau mit Steckbrett. Hier gilt es zu beachten, dass LEDs gerichtet sind: Obwohl sie auf den ersten Blick gleichmäßig aussehen, verraten die unterschiedlich langen Beinchen, wie sie Sie polen müssen: Das kurze Beinchen gehört an GND, das lange Beinchen verbinden Sie mit dem digitalen Ausgang des Arduino. Polen Sie eine Diode falsch, blockiert sie den Stromfluss und leuchtet nicht. Drei Widerstände verbinden die digitalen Ausgänge mit je einem langen Bein einer Diode. Die kurzen Beine der LEDs verbinden Sie miteinander und führen Sie gemeinsam zum GND.

Abbildung 3: So sieht der Aufbau der Schaltung für die einfache Lichtorgel aus Listing 2 aus.

Lade Sie Listing 2 hoch, beginnen die drei LEDs zufällig zu blinken. Im Code kommen Arrays zum Einsatz, um die Dioden und deren Zustände verwalten. Das einfache Durchlaufen von For-Schleifen ermöglicht so das Ansteuern aller LEDs, ohne Codeteile unnötig wiederholen zu müssen. Die praktische Methode random() liefert ganzzahlige Zufallswerte bis zu einem vorgegeben Höchstwert zurück und eignet sich damit bestens für den Zugriff auf die numerischen Arrays.

// Lichtorgel mit drei LEDs
// definiere LEDs
int led[3] = {8, 10, 12};
// alle LEDs sind aus
int ledOldMode[3]= {LOW,LOW,LOW};
void setup() {
 for (int i=0;i<3;i++) {
  // setze Pins auf Ausgang
  pinMode(led[i], OUTPUT);
 }
}
void loop() {
  // wähle Zufallszahl
  int rand = random(3);
  if (ledOldMode[rand]==LOW) {
    // wechsle Status der LED
    digitalWrite(led[rand], HIGH);
    ledOldMode[rand]=HIGH;
  } else {
    digitalWrite(led[rand], LOW);
    ledOldMode[rand]=LOW;
  }
  // warte 1/10 Sekunde
  delay(100);
}

Interaktion

Um die Schaltung interaktiv zu gestalten, bauen Sie nun noch einen einfacher Tastschalter ein. Sie fragen ihn bequem über einen digitalen Ein/Ausgang ab. Dazu verbinden Sie auch ihn mit einem Pin nach GND und mit einem Pin an einen digitalen Ein/Ausgang. Listing 3 demonstriert, wie sich der Schalter – ähnlich wie LEDs – konfigurieren lässt.

// Lichtorgel-Variante mit Taster
// definiere LEDs
int led[4] = {8, 10, 12};
// setze Schalter
int ledOldMode[3]= {LOW,LOW,LOW};
int schalter = 5;
void setup() {
  for (int i=0;i<4;i++) {
    pinMode(led[i], OUTPUT);
  }
  // setze Eingabe-Modus
  pinMode(schalter, INPUT);
  // aktiviere Widerstand
  digitalWrite(schalter, HIGH);
}
void loop() {
  int rand = random(3);
  if (ledOldMode[rand]==LOW) {
    digitalWrite(led[rand], HIGH);
    ledOldMode[rand]=HIGH;
  } else {
    digitalWrite(led[rand], LOW);
    ledOldMode[rand]=LOW;
  }
  if (digitalRead(schalter) == LOW) {
    digitalWrite(led[3], HIGH);
    delay(50);
  } else {
    digitalWrite(led[3], LOW);
    delay(250);
  }
}

Eigentlich müssten Sie auch den Schalter über einen Widerstand an das Arduino anschließen. In diesem Fall können Sie aber statt eines echten Widerstands auch einen sogenannten Pullup-Widerstand verwenden. Diese Widerstände lassen sich per Software für Eingänge am Board aktivieren. Die Zeile digitalWrite(schalter, HIGH); aktiviert den internen Widerstand. Sobald Sie das Programm hochladen, beginnen die LEDs zu blinken. Ein Drücken und Halten des Tastschalters verdoppelt nun die Blinkgeschwindigkeit.

Bei der Arbeit mit Tastschaltern und ähnlichen Eingabegeräten kann ein ungewolltes Federn das einmalige Betätigen wie ein schnelles Ein- und Ausschalten wirken lassen. Stört dieser Effekt, gilt es, mit einem sogenannten Debounce den Effekt zu minimieren. Dazu fragen Sie beispielsweise den Schalter entweder nur in Intervallen ab (siehe auch Listing 3) oder speichern den Zeitpunkt des letzten Zustandswechsels und geben eine Mindestzeit für einen erneuten Statuswechsel vor.

Das Arduino-Wiki erklärt diese Methode genauer [7]. Zudem steht in der Arduino-IDE unter File | Examples | Digital | Debounce ein entsprechendes Beispiel zur Verfügung.

Weite Welt

Die effektivste Methode zum Debugging laufender Programme und Schaltpläne ist die direkte Interaktion mit dem Arduino-Board. Die per USB angesprochene serielle Schnittstelle dient nicht nur zum Hochladen von Programmen, sondern lässt sich auch als bidirektionaler Kommunikationsweg nutzen. Über die Serial-Bibliothek lassen sich Statusinformationen zur Laufzeit ausgeben und Tastatureingaben abfragen.

Die Serial-Schnittstelle arbeitet typischerweise mit einer Transferrate von 9600 Baud. Es gibt mehrere Möglichkeiten, auf das Interface zuzugreifen. Arduino selbst bietet unter Tools | Serial Monitor einen einfachen Zugang. Als mindestens ebenbürtig erweist sich der Einsatz des beliebten Terminalmultiplexers Screen, der zum Beispiel über screen /dev/ttyUSB0 9600 eine bidirektionale serielle Konsole aufmacht.

Listing 4 gibt den Status eines Tastschalters über die serielle Schnittstelle aus. Mit Textausgaben dieser Art lassen sich auf ideale Weise Informationen über ein laufendes Arduino-Programm sammeln, ohne dazu weitere Status-LEDs verbauen zu müssen. Letztlich bietet die Serial-Bibliothek jedoch deutlich mehr: Über Ein- und Ausgabe kommunizieren Sie direkt vom Rechner aus manuell oder automatisiert mit dem Arduino. Vom Sammeln von Daten bis zum Ansteuern von Schaltungen ist hier alles möglich.

// Kommunikation ueber serielles Interface
// Taster an Pin 7
int tastSchalter = 7;
int alterStatus;
void setup() {
  //starte serielle Ausgabe
  Serial.begin(9600);
  // setze Pin auf Eingang
  pinMode(tastSchalter, INPUT);
  // aktiviere Widerstand
  digitalWrite(tastSchalter, HIGH);
  // speichere aktuellen Status
  alterStatus = digitalRead(tastSchalter);
}
void loop() {
  // lese Status
  int aktuellerStatus = digitalRead(tastSchalter);
  // vergleiche mit altem Status
  if (aktuellerStatus!=alterStatus) {
    // gib aktuelle Systemzeit aus
    Serial.print(millis());
    // gib aktuelle Systemzeit aus
    Serial.print("ms: Schalter-Status geaendert: ");
    // gib Status aus
    Serial.println(aktuellerStatus);
    // speichere aktuellen Status
    alterStatus = aktuellerStatus;
  }
  // warte 20ms
  delay(20);
}

Leider wurde der Arduino-Proxy Gobetwino [8] noch nicht nach Linux portiert: Er fungiert als Schnittstelle zwischen PC und Arduino, um auf Rechnerseite automatisiert mit dem Arduino zu kommunizieren und auf Ereignisse zu reagieren. Eine leistungsstarke Alternative bietet das Entwickeln mit dem Java-basierten Processing, das über Bibliotheken mit dem Arduino sprechen kann. Ein einfaches Beispiel findet sich im Arduino-Wiki [9].

Speicherriese

Neben der seriellen Schnittstelle verfügt das Arduino über einen kleinen persistenten EEPROM-Speicher. Der nur 512 Byte große Speicherbereich behält seine Daten auch dann, wenn Sie das Arduino von der Stromversorgung trennen. Damit eignet sich das EEPROM bestens, um hier Sensordaten und Status-Informationen zu speichern.

Auch wenn 512 Byte recht wenig erscheinen, lässt sich doch durch überlegten Einsatz des Speichers dessen Nutzen maximieren. Ein Byte umfasst mit acht Bit 256 mögliche Werte (0 bis 255). Speichern Sie beispielsweise nur Raumtemperaturen, die in einem Bereich zwischen 15° C und 30° C liegen, lassen sich problemlos zwei Werte quasi nebeneinander in einem Byte unterbringen.

Listing 5 zeigt exemplarisch das kontinuierliche Beschreiben des EEPROM mit Zufallswerten über EEPROM.write(). Zum Auslesen der Daten dient entsprechend EEPROM.read(). Beachten Sie, dass bei EEPROMs genau wie bei Speicherkarten die Anzahl der Schreibzyklen die Lebensdauer limitiert. Beim Speichern im Sekundentakt erreicht man die typischerweise 100?000 verfügbaren Zyklen schon nach knapp 28 Stunden. Fortgeschrittene Nutzer messen bei batteriebetriebenen Systemen den Ladestandund beginnen erst beim Unterschreiten eines bestimmten Werts mit dem regelmäßigen Speichern von Messdaten.

// Arduino-EEPROM beschreiben
// lade Bibliothek
#include <EEPROM.h>
// setze Startadresse auf 0
int addr = 0;
void setup() {
}
void loop() {
 // erzeuge Zufallszahl
  int val = random(255);
  // speichere Zufallszahl
  EEPROM.write(addr, val);
  // gehe zur nächsten Speicheradresse
  addr = addr + 1;
  // Zum Anfang, falls Ende erreicht
  if (addr == 512) addr = 0;
  // eine Sekunde warten
  delay(1000);
}

Schilde hoch!

Wer weiter hinaus möchte, denkt vielleicht schon über das Anbinden des Arduino ans Internet nach. Mit einem Steckbrett, Bauteilen und später vielleicht Platinen und einem Lötkolben lassen sich mit dem Arduino zwar auch komplexe Schaltungen realisieren, manche Aufbauten möchte man dann aber doch einfach gern fertig kaufen.

Dazu gibt es beim Arduino für bestimmte Aufgabenbereiche Shields genannte Steckmodule, die das Board um nützliche Funktionen erweitern. Das Ethernet-Shield bindet das Board in 10/100-Mbit/s-Netzwerke ein, das Danger-Shield wartet mit einer Vielzahl an Sensoren, einem Segment-Display, einem Lautsprecher und vielem anderen mehr auf [10].

Abbildung 4 zeigt ein Arduino mit aufgestecktem Ethernet- und LCD-Display-Shield. Der Vorteil der Shields liegt in ihrer kompakten und auf Arduino abgestimmten Bauweise. Beim Kauf sollten Sie darauf achten, ob Sie ein fertiges Shield oder einen Bausatz kaufen, den Sie noch zusammenlöten müssen. Letztere kommen zwar deutlich preiswerter, setzen aber zumindest das rudimentäre Beherrschen eines Lötkolbens voraus.

Abbildung 4: Hochgestapelt: Ein Arduino-Board mit aufgesteckten Shields – in der Mitte Ethernet, ganz oben ein LC-Display.

Auch sollten Sie vor dem Kauf genau prüfen, welche Funktionen die Shields und die entsprechenden Bibliotheken bieten. Das Ethernet-Shield beispielsweise kann aktuell seine IP-Adresse noch nicht per DHCP beziehen und hat auch Schwierigkeiten mit DNS-Abfragen. Dadurch können Sie mit externen Diensten lediglich auf der Basis von IP-Adressen kommunizieren und nicht über Hostnamen. Hier handelt es sich um mehr als nur ein kosmetisches Problem, etwa bei Gegenstellen, deren Hostname sich regelmäßig ändert. Dies hindert jedoch nicht daran, mit wenigen Zeilen Code beispielsweise Nachrichten per Twitter zu versenden.

Die Anwendungsfälle fallen dabei meist pragmatischer aus, als man zunächst denkt: So lassen sich etwa via Ethernet-Shield beim Erreichen bestimmter Sensorenwerte bequem Warnungen verschicken. Das auf Arduino basierende Botanicall-Kit misst den Feuchtigkeitsgrad von Blumenerde und meldet den Wunsch nach Wasser per Tweet [11]. Für Hobby-Bastler tut sich hier ein großes Feld an Einsatzmöglichkeiten auf, etwa bei der Überwachung von Aquarien oder Terrarien.

Fazit

Die Arbeit mit Arduino bietet einen unkompizierten Einstieg in die Welt der Mikrocontroller und elektronischen Schaltungen – und macht obendrein einen Riesen-Spaß. Die Arduino-IDE ist schlicht gehalten, das Durcharbeiten der mitgelieferten Code-Beispiele hilft ebenso weiter wie der Blick ins Arduino.cc-Wiki und weitere Online-Quellen.

Zwar macht Arduino die Arbeit mit elektronischen Bauteilen nicht zum Kinderspiel, aber zumindest deutlich übersichtlicher. Vor dem ersten Projekt sollten Sie sich aber auf jeden Fall mit Sicherheitsmaßnahmen und der Notation von Schaltplänen vertraut machen.