Elektronik mit Arduinos

Arduinos sind kleine Entwickler-Boards, die einen programmierbaren Mikrocontroller enthalten; sie lassen sich via USB mit einem Computer verbinden und lassen sich bei entsprechender Programmierung für vielseitige Elektronik-Projekte einsetzen.

fig-arduino-uno

Das Entwicklerboard Arduino UNO.

Einen Mikrocontroller kann man sich allgemein als einen winzigen Computer vorstellen; er vereinigt eine Recheneinheit (CPU), einen Arbeitsspeicher, einen permanenten Speicher, eine USB-Schnittstelle, einen Display-Controller sowie einen Analog-Digital-Wandler auf einem einzigen Bauteil. Selbstverständlich ist ein Mikrocontroller, was die Performance anbelangt, nicht mit einem “echten” Computer zu vergleichen; für einfache Sensor- oder Steuerungs-Schaltungen reichen Mikrocontroller jedoch meist völlig aus.

Im folgenden werden verschiedene Projekte für Arduino-UNO-Boards vorgestellt. Diese “klassischen” Arduinos enthalten den Mikrocontroller “ATmega328”, der optional sogar vom Arduino-Board entnommen und direkt in elektronische Schaltungen eingebaut werden kann. Da ein ATmega328 als Baustein nur etwa drei Euro kostet, kann man Arduino-Boards also auch als Programmier-Hilfe für diese Bausteine nutzen.

Aufbau eines Arduino UNO im Detail

In der folgenden Abbildung sind die wichtigsten Komponenten eines Arduino UNO mit kurzen Beschreibungen aufgelistet.

fig-arduino-uno mit-beschreibung

Das Entwicklerboard Arduino UNO im Detail.

Über die Pin-Leisten auf beiden Seiten des Arduinos kann dieser mittels Jumper-Kabeln mit externen Elektronik-Komponenten beziehungsweise einer Steckplatine verbunden werden:

  • Die analogen Pins A0 bis A5 sind als Sensor-Eingänge zum Messen von Spannungswerten zwischen \unit[0]{V} und \unit[5]{V} geeignet; durch einen eingebauten Analog-Digital-Wandler werden die gemessenen Spannungswerte auf einem Zahlenbereich von 0 (keine Spannung) bis 1023 (maximale Spannung, also \unit[5]{V}) abgebildet.

  • Die digitalen Pins 0 bis 13 können ebenfalls als Sensor-Eingänge festgelegt werden: Eine anliegende Spannung von \unit[>2,5]{V} wird als HIGH (Zahlenwert 1), eine niedrigere Spannung als LOW (Zahlenwert 0) interpretiert.

  • Die digitalen Pins 0 bis 13 können zudem als digitale Spannungs-Ausgänge festgelegt werden: Sie geben im Modus HIGH eine Spannung von etwa \unit[5]{V}, im Modus LOW eine Spannung von \unit[0]{V} aus. Die Stromstärke ist dabei allerdings auf \unit[40]{mA} begrenzt; gegebenenfalls wird die Spannung der Pins automatisch herab geregelt, um diese Begrenzung zu erreichen.

    Eine Besonderheit stellt der Digital-Pin 13 dar: Dort ist der Ausgabe-Strom auf nur \unit[20]{mA} begrenzt, so dass dort eine LED direkt (ohne Vorwiderstand) angeschlossen werden kann (direkt neben Pin 13 ist ein GND-Pin, so dass dafür nicht einmal eine Steckplatine nötig ist). Bei neueren Versionen des Arduino UNO ist zwischen Pin 13 und GND sogar eine SMD-LED fest eingebaut.

  • Die mit dem Tilde-Zeichen ~ versehenen Pins (3, 5, 6, 9, 10, 11) können, wenn sie als Ausgabe-Pins festgelegt werden, zudem mittels einer so genannter Pulsweiten-Modulation (PWM) sehr schnell zwischen \unit[0]{V} und \unit[5]{V} hin und her wechseln. Man kann dabei Werte zwischen 0 und 255 angeben, wobei 0 für “immer aus” und 255 für “immer an” steht.[1]

Die übrigen Anschlüsse des Boards (AREF- und ICSP-Header) sind für eine normale Benutzung nicht von Bedeutung.

Installation der Arduino-Software

Damit ein Arduino die gewünschte Funktion erfüllen kann, muss er programmiert werden. Dafür benötigt man lediglich die gleichnamige Arduino-Entwicklungsumgebung und/oder das Programm “Fritzing” (optional, aber empfohlen). Unter Linux Mint / Ubuntu lassen sich diese beiden Programme folgendermaßen installieren:

# Software-Pakete installieren:
sudo aptitude install arduino fritzing

# Benutzer zur Gruppe "dialout" hinzufügen:
sudo usermod -aG dialout BENUTZERNAME

Das Hinzufügen des angegebenen Benutzers zur Gruppe dialout ist nötig, damit dieser vom Linux-System notwendige Schreibrechte erhält: Schließt man ein Arduino-Board via USB am Computer an, so benötigt man diese Schreibrechte, um mittels des so genannten “Seriellen Ports” Code an den Arduino senden zu können.[2]

Wichtig: Die Rechte-Anpassung erfordert einen erneuten Login des Benutzers, um wirksam zu werden!

Nach der Installation kann die Arduino-Software aus einer Shell heraus mittels arduino oder über Startmenü -> Entwicklung -> Arduino IDE gestartet werden.

fig-arduino-ide

Die Arduino-Entwicklungsumgebung.

Im Hauptfenster des Programms kann wie mit einem Texteditor Quellcode eingegeben werden. Unten links wird die Nummer der aktuellen Zeile im Quellcode eingeblendet, unten rechts das derzeit ausgewählte Arduino-Board (Standard: Arduino UNO); ein anderes Arduino-Board über das Menü Tool -> Boards ausgewählt werden.

  • Hat man den gewünschten Quellcode eingegeben, so kann man diesen mittels des Überprüfen-Icons in der Symbolleiste auf Syntax-Fehler testen.

    _images/arduino-symbol-check.png
  • Wurde der Syntax-Check ohne Fehlermeldung durchlaufen, so kann man den Code kompilieren und an das Arduino-Board senden. Hierzu genügt ein Klick auf das Upload-Icon in der Symbolleiste: “Überprüfen”-Icons in der Symbolleiste auf Syntax-Fehler testen.

    _images/arduino-symbol-upload.png

Der Syntax-Check ist optional, man kann auch unmittelbar auf das Upload-Icon klicken, wenn man den Code kompilieren und an das Arduino-Board senden möchte. Falls während des Kompilierens oder des Sendens ein Fehler auftritt, so werden im unteren Teil des Arduino-Fensters entsprechende Meldungen ausgegeben, die bei der Fehlersuche hilfreich sein können.

INO: Arduino aus einer Shell heraus ansteuern (optional)

Die Arduino-IDE ist zwar einfach zu bedienen; wer allerdings einen so komfortablen Editor wie Vim in Kombination mit dem Vicle-Plugin und tmux gewohnt ist, der wird auf seine gewohnte Umgebung kaum verzichten wollen.

Unter Linux müssen hierfür folgende Pakete installiert werden:

sudo aptitude install picocom python-setuptools

sudo easy_install ino

Das Hauptprogramm, das die Kommunikation mit dem Arduino übernimmt, heißt Ino; momentan gibt es allerdings nur eine Variante für Python2. Hat man die obigen Pakete installiert, so kann man, wie im Quickstart-Tutorial (en.): ausführlich beschrieben, ein neues Projekt anlegen:

# Projekt-Ordner erstellen:
mkdir arduino-projekte

# In den Projekt-Ordner wechseln:
cd arduino-projekte

# Projekt initiieren:
ino init -t blink

Durch die obigen Anweisungen wird im Projekt-Ordner ein lib-Verzeichnis für mögliche externe Programm-Bibliotheken sowie ein src-Verzeichnis für den eigentlichen Quellcode des Projekts angelegt. In diesem Verzeichnis wird durch den Aufruf von ino init automatisch die Datei sketch.ino neu angelegt; durch die optionale Angabe von -t blink enthält diese Datei ein minimales Beispielprogramm; bei einem Aufruf von ino init ohne weitere Argumente enthält diese Datei lediglich eine leere setup() und loop()-Funktion als Template.

Um ein Arduino-Programm (häufig auch “Sketch” genannt) zu kompilieren, kann man im Projekt-Ordner folgendes eingeben:

# Projekt kompillieren:
ino build

Wurde der Kompilierungs-Vorgang erfolgreich durchlaufen, so kann man das Programm anschließend auf den Arduino hochladen:

# Projekt auf Arduino hochladen:
ino upload

Fertig! Wurde der oben optional gewählte Beispielcode blink nicht verändert, so beginnt die im Arduino am Pin 13 fest eingebaute LED zu blinken.

Möchte man ein anderes Arduino-Board als ein Arduino-UNO nutzen, so kann man die unterstützten Typen mittels ino list-models anzeigen und beispielsweise bei Verwendung eines Arduino Mega 2560 mittels ino build -m mega2560 als Ziel festlegen; das gleiche gilt für die Einstellung einen anderen seriellen Ports, der beispielsweise mittels ino upload -m mega2560 -p /dev/ttyACM1 festgelegt werden kann. Wie im Quickstart-Tutorial beschrieben, kann hierfür auch eine Konfigurations-Datei im Projektordner angelegt werden.

Weitere Hilfe zu Ino erhält man, indem man ino --help oder beispielsweise ino build --help für eine Beschreibung des Build-Subprogramms eingibt.

Erste Arduino-Programmbeispiele

Das erste Beispiel in jeder Programmiersprache ist es, einfach den Text “Hallo Welt” auf dem Bildschirm auszugeben. Arduinos kommunizieren allerdings weniger mit dem Computer-Bildschirm als vielmehr bevorzugt mit anderen elektronischen Komponenten. Ein einfaches Minimal-Beispiel ist also beispielsweise eine einzelne LED zum Blinken zu bringen.

Blinken einer LED

In der Arduino-IDE kann man über das Menü Datei -> Beispiele einige Beispiel-Quellcode-Dateien laden. Unter der Rubrik 01.Basics findet sich beispielsweise der Eintrag “Blink” mit folgendem Inhalt:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 13;

// the setup routine runs once when you press reset:
void setup() {
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second
}

Jeder Text, der hinter einem doppelten Schrägstrich-Zeichen // erscheint, wird vom Compiler ignoriert und dient somit lediglich als Kommentar für sich selbst und/oder andere Programmierer. Allgemein werden die Arduino-Programme mit einer Syntax geschrieben, die auf der Programmiersprache C aufbaut; beispielsweise muss daher jede einzelne Anweisung mit einem Strichpunkt-Zeichen beendet werden.

Eine Besonderheit ist, dass jedes Arduino-Programm eine Funktion setup() und eine Funktion loop() beinhalten muss:

  • Die Funktion setup() wird einmalig nach dem Aufspielen eines neuen Programms sowie bei jedem Neustart des Arduinos ausgeführt.
  • Die Funktion loop() beinhaltet Code, der anschließend in einer Endlos-Schleife ausgeführt wird: Ist die letzte Zeile der loop()-Funktion erreicht, so wird anschließend wieder die erste Zeile dieser Funktion ausgeführt.

Die Funktionsblöcke der setup()- beziehungsweise loop()-Funktion müssen nicht zwingend Code beinhalten; lässt man beide Blöcke leer und überträgt dieses Programm auf den Arduino, so wird jedes vorherige Programm gelöscht, und der Arduino ist “wie neu”.[3]

Im obigen Beispiel wird innerhalb der setup()-Funktion mittels der vordefinierten pinMode()-Funktion der Digital-Pin 13 als Ausgabe-Pin festgelegt (OUTPUT). Innerhalb der loop()-Funktion wird an diesem dann mittels der ebenfalls vordefinierten digitalwrite()-Funktion die Ausgangs-Spannung abwechselnd an- und ausgeschaltet. Damit dies für das menschliche Auge wahrnehmbar wird – ein Arduino kann rund 20\,000 Zeilen Code je Sekunde ausführen – wird mittels der delay()-Funktion das Programm immer wieder um die angegebene Anzahl an Milli-Sekunden unterbrochen.

Einfache Sensor-Schaltungen

In diesem Abschnitt soll zunächst die Verwendung eines Tasters als digitalem Sensor, später dann die Verwendung eines Potentiometers als analogem Sensor kurz vorgestellt werden.

Taster als Digital-Sensor

In der Arduino-IDE kann man über das Menü Datei -> Beispiele ein Beispielprogramm für die Verwendung eines Eingabe-Tasters laden Unter der Rubrik 01.Basics findet sich ein Eintrag “DigitalReadSerial” mit folgendem Inhalt:[4]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/*
  DigitalReadSerial
 Reads a digital input on pin 2, prints the result to the serial monitor

 This example code is in the public domain.
 */

// digital pin 2 has a pushbutton attached to it. Give it a name:
int pushButton = 2;

// the setup routine runs once when you press reset:
void setup() {
  // initialize serial communication at 9600 bits per second:
  Serial.begin(9600);
  // make the pushbutton's pin an input:
  pinMode(pushButton, INPUT);
}

// the loop routine runs over and over again forever:
void loop() {
  // read the input pin:
  int buttonState = digitalRead(pushButton);
  // print out the state of the button:
  Serial.println(buttonState);
  delay(1);        // delay in between reads for stability
}

Die zugehörige Schaltung sieht etwa folgendermaßen aus:

_images/digitalsensor-taster.png

Der digitale Pin 2, der in diesem Beispiel als Sensor-Eingang verwendet werden soll, ist einerseits über einen \unit[10]{k
\Omega}-Widerstand mit GND, andererseits über den Eingabetaster mit der Spannung VCC (\unit[5]{V}) verbunden. Diese Schaltung stellt letztlich einen Spannungsteiler dar, wobei der Taster die Rolle des ersten Widerstands R_1 übernimmt:

  • Ist der Taster gedrückt, so beträgt sein Widerstandswert nahezu R_1 =
\unit[0]{\Omega}; fast die gesamte die gesamte anliegende Spannung fällt somit über dem Widerstand R_2 = \unit[10]{k \Omega}, also zwischen dem mit Pin 2 verbundenen Punkt und GND ab. Am Pin 2 wird somit eine Spannung von \unit[>2,5]{V} gemessen, was beim Einlesen mittels der digitalRead()-Funktion den Wert HIGH beziehungsweise 1 liefert.
  • Ist der Taster nicht gedrückt, so beträgt sein Widerstandswert nahezu R_1 = \infty. Würde man den Pin 2 nicht über einen Widerstand mittels GND verbinden, so hinge der Anschluss gewissermaßen “in der Luft” – die digitalRead()-Funktion würde dann zufällig entweder den Wert HIGH (1) oder LOW (0) ausgeben. Durch den Widerstand und den so geschlossenen Stromkreis ist Pin 2 hingegen mit GND verbunden, und die digitalRead()-Funktion gibt verlässlich den Wert LOW beziehungsweise 0 aus.

Potentiometer als Analog-Sensor

Über das Menü Datei -> Beispiele kann man unter der Rubrik 01.Basics ebenfalls ein Beispielprogramm für die Verwendung eines Potentiometers als Analog-Sensors abrufen. Das Beispiel “AnalogReadSerial” hat folgenden Inhalt:

/*
  AnalogReadSerial
  Reads an analog input on pin 0, prints the result to the serial monitor.
  Attach the center pin of a potentiometer to pin A0, and the outside pins
  to +5V and ground.

  This example code is in the public domain.
*/

// the setup routine runs once when you press reset:
void setup() {
    // initialize serial communication at 9600 bits per second:
    Serial.begin(9600);
}

// the loop routine runs over and over again forever:
void loop() {
    // read the input on analog pin 0:
    int sensorValue = analogRead(A0);
    // print out the value you read:
    Serial.println(sensorValue);
    delay(1);        // delay in between reads for stability
}

Die zugehörige Schaltung sieht etwa folgendermaßen aus:

_images/analogsensor-potentiometer.png

INO: Ausgabe des seriellen Monitors in einer Shell (optional)

Auch der so genannte “Serielle Monitor” ist über die Shell erreichbar. Um dies zu testen, kann man hierfür das Beispiel-Programm in der Datei src/sketch.ino durch folgenden Code ersetzen:

void setup()
{
    Serial.begin(9600);
}

void loop()
{
    Serial.println(millis());
    delay(1000);
}

Ruft man wiederum ino build und ino upload auf, so kann man sich anschließend über folgenden Aufruf die Ausgabe des seriellen Monitors anzeigen lassen:

# Programm kompillieren und hochladen:
ino build && ino init

# Seriellen Monitor starten
ino serial

Man bekommt mit dem obigen Beispielcode damit angezeigt, wie viele Millisekunden seit dem letzten Aufruf des seriellen Monitors vergangen sind. Der serielle Monitor kann durch die Tastenkombination Ctrl a Ctrl x wieder beendet werden.

Arduino-Programmierung

Im folgenden Abschnitt wird die für das Programmieren eines Arduinos notwendige Syntax schrittweise, aber möglichst knapp vorgestellt.

Definition von Variablen

Variablen sind dafür da, um bestimmte Werte (Zahlen oder Zeichenketten) zu speichern und an einer oder mehreren anderen Stellen im Programm wieder abrufen zu können. Bei der Definition einer Variablen wie in Zeile 3 des obigen Programmbeispiels muss angegeben werden, welchen Datentyp die Variable speichern soll.

Typ Bits/Bytes Umfang Beschreibung
boolean 1 Bit 0 bis 1 Falsch oder Wahr
byte 1 Byte 0 bis 255 Natürliche Zahl
int 2 Bytes -32\,768 bis +32\,767 Ganze Zahl mit Vorzeichen
unsigned int 2 Bytes 0 bis 65\,535 Ganze Zahl ohne Vorzeichen
float 4 Bytes -3.4028235E+38 bis +3.4028235E+38 Rationale Zahl
double 8 Bytes 10E-308 bis 10E+308 Rationale Zahl mit doppelter Genauigkeit
char 1 Byte -128 bis 127 Ein einzelnes Zeichen (ASCII)

Im Unterschied zur Programmiersprache C können Variablen auch lokal, also innerhalb einer Funktion definiert werden; sie haben dann allerdings auch nur innerhalb dieser Funktion ihre Gültigkeit: Beispielsweise kann eine Variable, die innerhalb der setup()-Funktion definiert wurde, nicht innerhalb der loop()-Funktion verwendet werden. Erfolgt die Definition einer Variablen hingegen am Beginn der Datei (noch vor der setup()-Funktion), so kann diese in allen Programm-Teilen genutzt werden.

Ist der Datentyp einer Variablen (einmalig) festgelegt, so kann dieser mittels des Zuweisungs-Operators = ein neuer Wert zugewiesen werden.

Zeichenketten (“Strings”) lassen sich als Listen (“Arrays”) von char-Variablen abspeichern; die Syntax dafür lautet beispielsweise:

char string1[] = "Arduino";     // Definition einer konkreten Zeichenkette
char string2[50] ;              // Deklaration einer Zeichenkette
                                // (mit maximal 49 Zeichen)

Wird bei der Deklaration einer Zeichenkette die Länge mittels eines Zahlenwerts explizit angegeben, so muss beachtet werden, dass stets ein Zeichen weniger als angegeben genutzt werden kann, da jede Zeichenkette automatisch mit dem “String-Ende”-Zeichen \0 beendet wird.

Mehrere Zahlen lassen sich ebenfalls in Form einer Liste speichern; die Syntax hierfür lautet beispielsweise:

int numbers[5] = {0, 5, 10, 15};    // Definition eines Zahlen-Arrays

In einem Zahlen-Array können maximal genauso viele Werte gespeichert werden, wie bei der Deklaration beziehungsweise Definition angegeben wurden.

Standard-Funktionen

Zum Programmieren eines Arduinos können standardmäßig, also auch ohne ein Einbinden von zusätzlichem Quellcode, folgende Funktionen genutzt werden:

  • pinMode(pinnumber, wert) legt

Operatoren

Kontrollstrukturen

... to be continued soon ...