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.

Das Entwicklerboard Arduino UNO.

SVG: 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.

Das Entwicklerboard Arduino UNO im Detail.

SVG: Arduino UNO mit Beschreibung

Ü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.

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.
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.

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:

// 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]

/*
  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:

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:

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 ...

Links¶

Anmerkungen:

[1]

Hat man ein Arduino-Board angeschlossen, kann man in einer Shell folgende Zeile eingeben:

ls -l /dev/ttyACM*

Der serielle USB-Port wird vom Linux-System automatisch als “Device” erkannt; die Kommunikation findet über eine sich im /dev/-Verzeichnis befindende Datei dort befindende Datei namens ttyACM0, ttyACM1 o.ä. statt (tty bezeichnet dabei die serielle Schnittstelle und acm das Datenübertragungs-Verfahren). Man erhält dabei also folgende Ausgabe:

crw-rw---- 1 root dialout 188, 0 5 apr 23.01 ttyACM0

Man kann daran erkennen, dass sowohl der Eigentümer als auch die Gruppe Lese- und Schreibrechte haben rw-, alle anderen Benutzer hingegen keine Rechte haben (---). Der Eigentümer ist root, die Gruppe ist dialout. Ein Benutzer kann also nur auf die serielle Schnittstelle zugreifen, wenn er die Arduino-Software mit SuperUser-Rechten startet oder (besser) wenn er Mitglied in der dialout-Gruppe ist.

[2]

Beispielsweise kann man mittels PWM einen Motor oder eine Glühbirne bei einem Wert von 128 mit nur “halber Leistung” ansteuern, da er nur die Hälfte der Zeit mit Spannung versorgt wird und sich die andere Hälfte der Zeit im Leerlauf befindet.

Eine LED lässt sich so ebenfalls “dimmen”: Die LED ist zwar schnell genug, um in der gleichen Frequenz mitzublinken, unser Auge jedoch nicht. Da wir nur 25 Einzelbilder je Sekunde wahrnehmen können, erscheint uns eine LED, die nur die Hälfte der Zeit an ist, gegenüber einer permanent hellen LED als dunkler.

[3]	Allgemein kann der Mikrocontroller Atmega328 eines Arduino-UNO-Boards gut $10\,000$ mal neu beschrieben werden; zudem kann auf dem Board jederzeit der Mikrocontroller durch einen neuen ersetzt werden.

[4]	Als Alternative zu diesem Programm kann auch unter der Rubrik `02.Digital` das Beispielprogramm `Button` gewählt werden. Dieses ist strukturell sehr ähnlich, bietet umfangreichere Erklärungen zum Aufbau der Schaltung, lässt andererseits jedoch den seriellen Monitor außen vor.

Inhalt

Vorheriges Thema

Nächstes Thema

Diese Seite