Hallo, Arduino!

Was macht ein technikafiner Historiker, wenn er nicht Quellen durcharbeitet oder kleine Skripte schreibt? Er bastelt an Mikrocontrollern und anderen Computern. In diesem Beitrag stelle ich den Arduino Uno, die dazu gehörige IDE und ein kleines Programm vor, mit dem sich ein LCD ansprechen lässt.

Arduino – eine historische Einführung

Arduin von Ivrea kam vermutlich im Jahr 955 zur Welt und war von 1002 bis kurz vor seinem Tod 1015 König von Italien.¹ Auf ihn geht der Name einer Kneipe zurück, in der sich Massimo Banzi mit einigen anderen Mitgliedern des Interaction Design Institute Ivrea knapp tausend Jahre später regelmäßig traf. Banzi suchte zu dieser Zeit nach einem günstigen Mikrocontroller, also einem Halbleiterchip mit Prozessor und Peripheriefunktionen, den seine Design- und Kunststudenten für elektronische Werke und Projekte nutzen konnten, ohne umfassende Kenntnisse der Elektronik und des Ingenieurwesens besitzen zu müssen. Weil er bereits Erfahrungen mit der quelloffenen Programmiersprache Processing gesammelt und einer seiner Studenten die Entwicklungsplattform Wiring im Zuge seiner Abschlussarbeit geschaffen hatte, entschlossen sich Banzi und einige Mitstreiter, selbst ein Board zu entwerfen. Es sollte nicht nur einfach zu programmieren sein, sondern auch zahlreiche Möglichkeiten bieten, elektronische Bauteile, also Sensoren und Aktoren anzuschließen.

Der erste Arduino, bestehend aus einem Mikocontroller auf ATmega8-Basis und einem Fork von Wiring, erschien in einer Auflage von zweihundert Stück. Fünfzig davon gingen an eine Schule. Von Anfang an verfolgte das Entwicklerteam einen open-source- und open-hardware-Ansatz. Das heißt, sowohl der Programmcode als auch die Schalt- und Baupläne des Arduino sind frei zugänglich und können von jedermann nachgenutzt und verändert werden.

Nicht zuletzt aus diesem Grund ist der Arduino, der inzwischen in jedem gut sortierten Elektronikladen für etwa 30 Euro zu haben ist, zum Standard für Künstler, Hobby-Bastler und Maker geworden. Inzwischen gibt es zahlreiche Varianten. Die verbreitetste ist der Arduino Uno.

Arduino IDE

Den Mikrocontroller schließt man zunächst per USB-Kabel an seinen Rechner an. Programmiert wird der Chip mithilfe der Arduino IDE, einer auf Java basierenden Entwicklungsumgebung, die für alle gängigen Betriebssystem zur Verfügung steht. Für gewöhnlich schreibt man die Arduino-Programme, sogenannte Sketche, in einem Dialekt von C++. Anschließend kompiliert die Arduino IDE das Programm und lädt es auf das Board hoch. Danach benötigt der Arduino nur noch Strom, funktioniert aber ansonsten autonom.

Die Arduino-IDE mit dem Blink-Sketch.

Im oberen Teil des Fensters schreibt der Bastler seinen Programmcode, die untere Konsole berichtet vom Fortschritt und Ergebnis des Kompiliervorgangs. Ein serieller Monitor erlaubt es zudem, Statusmeldungen anzuzeigen und Nachrichten zwischen Arduino und dem Benutzer auszutauschen.

Ein Sketch weist immer mindestens zwei Funktionen auf: In void setup() werden die Schnittstellen definiert und die Ausgangseinstellungen vorgenommen. Die Funktion void loop() wird anschließend aufgerufen. Hier steht die eigentliche Programmlogik drin. Wie der Name schon sagt, handelt es sich dabei um eine Schleife, die immer wieder von vorne durchlaufen wird.

Das Standardbeispiel für den Einstieg ist, anders als beim reinen Programmieren, nicht ‘Hello, World!’, sondern die Steuerung einer kleinen LED, einer Light Emitting Diode, also einer Licht ausstrahlenden Diode:

// Zunächst wird das Arduino-Board mit seinen Anschlüssen konfiguriert.
void setup() {
  /*
    Anschließend wird Pin Nummer 13, der mit der
    eingebauten LED des Arduino-Boards verbunden ist,
    als Ausgang festgelegt
  */
  pinMode(LED_BUILTIN, OUTPUT);
}

// Jetzt folgt die Schleifenfunktion.
void loop() {
  // Schalte die LED ein (am Ausgang wird die Spannung auf HIGH gesetzt).
  digitalWrite(LED_BUILTIN, HIGH);
  // Warte eine Sekunde, also 1000 Milisekunden.
  delay(1000);
  // Setze den Ausgang auf Low, d.h. schalte die LED aus.
  digitalWrite(LED_BUILTIN, LOW);
  // Warte wieder für eine Sekunde.
  delay(1000);
}

“Hallo, Arduino”

Das Spannende am Arduino und vergleichbaren Mikrocontrollern besteht in meinen Augen darin, dass sie die tragische Aufsichbezogenheit der meisten Programme zu vermeiden helfen. Ich meine damit Folgendes: Wenn man eine neue Programmiersprache lernt, beginnt man meist mit einem Programm, das “Hello, World!” auf dem Bildschirm ausgibt. Aber hat jemals die Welt zurück gegrüßt? Nein, hat sie nicht. Tragisch, ich sag es ja.

Beim Arduino ist das anders. Um das zu zeigen, stelle ich kurz eine Schaltung vor, die einen Arduino Uno mit einem herkömmlichen LC-Display verbindet.

Ein LCD an einem Arduino.

Der Arduino wird mithilfe eines USB-Kabels mit Strom versorgt. Auf einer Steckplatine befindet sich ein LCD mit 16 x 2 Zeichen. Vom 5V- und vom GND-Pin des Arduino jeweils eine Leitung auf die Platine. Ein Potentiometer und insgesamt vier weitere Verbindungen versorgen das LCD mit Strom. Das Potentiometer dient lediglich dazu, den Kontrast am Display einzustellen. Die übrigen Leitungen führen zu den digitalen Pins 7-12 des Microcontrollers. Hierüber wird dem Display mitgeteilt, was es wie und wo anzeigen soll.

Der entsprechende Sketch sieht so aus:

/*
  Zunächst wird die Bibliothek eingebunden, mit der sich
  das LCD ansprechen lässt.
*/
#include <LiquidCrystal.h>

/*
  Anschließend wird ein LCD-Objekt mit den Pins
  initialisiert.
*/
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

/*
  Dann legen wir die Länge der Anzeige und der zu
  empfangenen Daten fest.
*/
int laenge = 16;
// Jetzt kommt ein Array aus Buchstaben.
char empfangeneDaten[16];

void setup() {
  /*
    Öffnen einer seriellen Schnittstellen zum
    angeschlossenen Computer.
  */
  Serial.begin(9600);
  // Das LCD besitzt 16 Zeichen auf 2 Reihen.
  lcd.begin(16, 2);
  // Schreibe "Hallo, Welt!"
  lcd.print("Hallo, Welt!");
}

// Jetzt startet die Hauptfunktion.
void loop() {
  int i = 0;
  // Falls eine Schnittstelle vorhanden ist...
  if (Serial.available()) {
    // ... setze den Cursor auf Spalte 1, Zeile 2 (beginnt mit 0)
    lcd.setCursor(0, 1);
    // Lösche die Anzeige...
    lcd.print("                 ");
    // Warte auf die serielle Schnittstelle...
    delay(100);
    // Setze den Cursor wieder auf Spalte 1, Zeile 2...
    lcd.setCursor(0, 1);
    // Solange etwas empfangen wird...
    while (Serial.available()) {
      // Speichere die Daten im Buchstaben-Array ab...
      empfangeneDaten[i++] = Serial.read();
      delay(2);
    }
    // Und dann schreibe den Array auf das Display!
    lcd.print(empfangeneDaten);
    // Dann lösche den Array mit einer Schleife...
    for (int x = 0; x < laenge; x++) {
      empfangeneDaten[x] = NULL;
    }
  }
  // Und beginne von vorne...
}

Das Schöne daran ist, wenn der Arduino die Welt grüßt, kann die Welt über die Leitung zum Arduino zurück grüßen!

Die Welt grüßt zurück! Happy Ending!

Oder anders gesagt: Der Arduino befreit die Software und koppelt sie an die äußere Wirklichkeit. Er stellt also eine Schnittstelle zwischen Außenwelt und Innenwelt des Rechners zur Verfügung. Viel Spaß beim Basteln!

PS: Für den Einstieg eignen sich am besten möglichst umfangreiche Kits, in denen sich nicht nur ein Arduino befindet, sondern auch gleich eine Menge an unterschiedlichen Sensoren, Aktoren und Verbindungsdrähten.