View
216
Download
1
Category
Preview:
Citation preview
LeseprobeDiese Leseprobe gibt Ihnen einen ersten Einblick die Welt des Ardui-no. Sie lernen den Microcontroller kennen und entdecken einige der Bastelprojekte, die Sie mit ihm umsetzen können. Die verständliche Einführung und der umfangreiche Index zeigen Ihnen, wie einfach das Programmieren, Basteln und Lernen mit dem Arduino sein kann.
Benjamin Kappel
Arduino – Elektronik, Programmierung, Basteln672 Seiten, broschiert, in Farbe, März 2016 29,90 Euro, ISBN 978-3-8362-3648-5
www.rheinwerk-verlag.de/3797
»Programmieren lernen mit dem Arduino« »Die 7-Segment-Anzeige«
Inhaltsverzeichnis
Index
Der Autor
Leseprobe weiterempfehlen
Know-how für Kreative.Wissen, wie’s geht.
Programmieren lernen mit dem Arduino
15
Programmieren lernen mit dem ArduinoIch begrüße Sie herzlich auf Ihrer Reise in die Welt der Elektronik. Mein Name ist Benja-
min Kappel, und ich freue mich, dass Sie sich für dieses Buch entschieden haben.
Was werden Sie in diesem Buch erleben?
Die Projekte sind so ausgelegt, dass sie Ihnen die Grundlagen der Elektronik vermitteln,
aber durchaus auch Herausforderungen darstellen. Ich möchte Sie nicht nur unterhal-
ten, sondern Ihnen zeigen, dass Sie an Ihren Aufgaben wachsen werden.
Die Welt der Elektronik und des Bastelns bietet uns die Möglichkeit, Projekte durchzu-
führen, bei denen wir nicht zwangsläufig nach dem Praxisnutzen fragen müssen. Ist es
beispielsweise sinnvoll oder nützlich, auf einer kleinen Anzeige das Spiel Snake zu ent-
wickeln? Vielleicht nicht, aber es macht Spaß, weil es möglich ist! Und nebenbei lernt
man noch eine Menge.
Bei allen in diesem Buch vorgestellten Projekten wird uns der Arduino begleiten. Und
damit Sie wissen, was der Arduino von Haus aus alles mitbringt, werde ich Ihnen diesen
Microcontroller im ersten Kapitel genau vorstellen.
Abbildung 1 Der Arduino
An dieses Vorwort schließen sich drei Kapitel zu den Grundlagen an. In Kapitel 1
schauen wir uns an, was alles in einem Prozessor steckt. Damit wir bei unseren Experi-
menten nicht unnötig viele Bauteile zerstören, werden wir uns in Kapitel 3 die elemen-
taren Grundlagen der E-Technik anschauen. Zwischen diesen beiden Themen stelle ich
den Arduino genauer vor.
Programmieren lernen mit dem Arduino
16
Böse Zungen würden Kapitel 4 vielleicht auch noch als Theorie bezeichnen, ich be-
trachte es eher als praktischen Einstieg. Wir werden uns dort die Grundlagen der Pro-
grammierung anschauen und dabei die eine oder andere Lampe ansteuern.
Der ganze Rest des Buches beschreibt Projekte. Zu Anfang erstellen wir noch kleine Auf-
bauten wie den in Abbildung 2.
Abbildung 2 Der Aufbau des ersten Projekts
Mit der Zeit werden die Schaltungen dann etwas größer. Abbildung 3 vermittelt Ihnen
einen ersten Eindruck davon, wie es auch aussehen kann. Keine Sorge: Sie werden se-
hen, dass das alles einfacher zu verstehen ist, als es hier den Anschein hat.
Abbildung 3 Viele Drähte für zwei 7-Segment-Anzeigen
Was werden Sie in diesem Buch erleben?
17
Auch der Arduino selbst wird mit der Zeit wachsen (siehe Abbildung 4).
Abbildung 4 Der Arduino mit aufgestecktem Zubehör
Wir werden auch mit Schere und Kleber basteln, wie es sich für richtige Bastler, die sich
übrigens auch als Maker bezeichnen, gehört (siehe Abbildung 5).
Abbildung 5 Das »Gehäuse« für das Katzenspielzeug
Programmieren lernen mit dem Arduino
18
Abbildung 6 Unser eigenes Snake-Spiel
Am Anfang morsen wir, am Ende spielen wir Snake.
Zwischendurch messen wir Temperaturen, und ein wenig später lassen wir uns die
gemessenen Temperaturen vom Arduino per E-Mail zuschicken.
Es werde Licht – jetzt mit Schnellschalter
Für diejenigen unter Ihnen, die bereits einen Arduino haben (vermutlich die meisten)
und die es sprichwörtlich in den Fingern juckt, gibt es schon hier ein erstes Erlebnis der
Erleuchtung.
Alle anderen können diesen Abschnitt auch überspringen. Die Installation des Arduino
finden Sie in Kapitel 2, und die ersten Gehversuche machen Sie in Kapitel 4. Sie verpas-
sen also nichts, wenn Sie den Abschnitt hier noch überspringen. Aber wenn Sie schon
über erste Erfahrungen im Elektronikbereich (eventuell sogar schon mit dem Arduino)
verfügen, dann lesen Sie hier bitte weiter.
Los geht’s: Packen Sie Ihren Arduino aus, und laden Sie die Treiber und Programme von
der offiziellen Webpräsenz http://arduino.cc/ herunter. Ist die Installation abgeschlos-
sen oder haben Sie die Treiber bereits installiert, dann verbinden Sie den Arduino über
ein USB-Kabel mit Ihrem PC.
Die Schaltung, die Sie hier aufbauen, ist ganz einfach. Sie benötigen lediglich zwei LEDs
in zwei verschiedenen Farben und jeweils einen Vorwiderstand. Der Widerstand sollte
größer sein als 100 Ω. Die Schaltung sollte ungefähr so aussehen wie in Abbildung 7.
Es werde Licht – jetzt mit Schnellschalter
19
Abbildung 7 Aufbau der Schaltung für den ersten »Turbo-Sketch«
Damit Sie im Detail sehen, wie die Bauteile geschaltet werden, ist der Aufbau in Abbil-
dung 8 schematisch dargestellt.
Abbildung 8 Schematischer Aufbau der Schaltung
Die Reihe aus Widerstand und LED verbinden Sie jeweils per Kabel bzw. Steckverbinder
am Arduino mit den Eingängen 11 und 10. Die LED hat zwei Beinchen. Das lange Bein-
Programmieren lernen mit dem Arduino
20
chen muss in Richtung Widerstand zeigen. Das andere Beinchen muss über ein Kabel
mit der blauen Schiene verbunden werden. Von dieser Schiene führen Sie ein Kabel
zum GND-Pin. Das ist der Pin links neben Pin 13.
Nun werden wir die LEDs abwechselnd hell aufleuchten und dann wieder dunkel wer-
den lassen. Öffnen Sie dazu die Arduino-IDE, indem Sie die heruntergeladene Datei
arduino.exe auf Ihrem PC z. B. per Doppelklick aufrufen.
Dort sehen Sie standardmäßig ein leeres Programm bzw. das Grundgerüst, aus dem
jedes Arduino-Programm bestehen muss:
void setup() {// put your setup code here, to run once:
}
void loop() {// put your main code here, to run repeatedly:
}
Listing 1 Ein leeres Programm für den Arduino
Nun ersetzen Sie einfach die Zeile
// put your main code here, to run repeatedly:
durch:
for(int i = 0, j = 254; i < 255; i++,j--){analogWrite(11,i);analogWrite(10,j);
delay(30);}
Listing 2 Damit wird die eine LED heller, die andere dunkler.
Haben Sie die Zeilen wie in Listing 2 eingetragen, probieren Sie es einmal aus. Mit der
Schaltfläche aus der Arduino-IDE können Sie das Programm auf Ihren Arduino
laden und gewissermaßen den Programmspeicher des Arduino »befüllen«.
Der von uns gewünschte Effekt lässt sich nun beobachten: Die eine LED wird hell, die
andere dunkel. Nun machen wir diesen Effekt noch etwas weicher, indem wir die Lam-
Datenblätter, Zeichnungen und Sketches: Zusatzmaterialien herunterladen
21
penhelligkeit für jede LED wieder in die andere Richtung steuern. Fügen Sie dazu die fol-
gende Zeile genau darunter ein:
for(int i = 0, j = 254; i < 255; i++,j--){analogWrite(11,j);analogWrite(10,i);
delay(30);}
Listing 3 Nun haben wir schon effektvolle Lichter.
Laden Sie das Programm hoch, und beobachten Sie die LEDs. Diese werden langsam hel-
ler und dann wieder langsam dunkler bzw. genau umgekehrt: Sie haben eine schöne,
pulsierende Beleuchtung erstellt. So einfach kann man mit dem Arduino spielen und
mit vergleichsweise geringen Mitteln tolle Effekte erzielen. Das soll zur praktischen Ein-
stimmung erst einmal genügen.
Datenblätter, Zeichnungen und Sketches: Zusatzmaterialien herunterladen
Dieses Buch kommt nicht nur sowohl in gedruckter als auch in elektronischer Form
daher, sondern darüber hinaus mit einer Menge an Programmen für den Arduino – den
sogenannten Sketches – sowie mit Übersichten und Abbildungen. Und damit Sie nie
lange suchen müssen, wo Sie diese Arbeitshilfen herunterladen können, finden Sie im
folgenden Kasten die genauen Angaben, wo Sie die Dateien bekommen können.
Die Dateien zum Buch
Alle im vorigen Absatz genannten Materialien können Sie von der Website zum Buch
herunterladen: https://www.rheinwerk-verlag.de/3797
Dort finden Sie am Ende einen Kasten Materialien zum Buch. Durch Klicken auf den
Link Zu den Materialien gelangen Sie in den Download-Bereich.
In ihm finden Sie unter anderem alle Programme, die im Buch besprochen werden. Sie
finden dort außerdem ein aus mehreren Schablonen bestehendes Motorgehäuse. Als
Hilfe für den Schaltungsaufbau habe ich einige Abbildungen zum Ausdrucken entwi-
ckelt. Auch diese finden Sie dort. Im weiteren Verlauf des Buches werde ich immer von
den »Dateien zum Buch« sprechen. Nun wissen Sie, wo sich diese befinden.
307
Kapitel 10
Die 7-Segment-AnzeigeIn diesem Kapitel werden wir sowohl die größte Schaltung als auch den längsten
Quellcode bisher entwickeln. Immerhin mündet beides in ein Spiel – klein, aber fein.
Dieses Kapitel dient unter anderem der Vorbereitung auf das nächste Kapitel, das das
Messen zum Thema hat. Wenn wir allerdings etwas wie die Temperatur gemessen ha-
ben, wohin mit dem Ergebnis?
Nach könnten wir die Ergebnisse einem Rechner mitteilen, aber ein Thermometer, bei
dem man einen Rechner braucht, um es auszulesen, wird sich wohl nicht durchsetzen.
Das Problem besteht in der Darstellung. Die einzige Darstellung, die wir bis jetzt gewählt
haben, waren LEDs. Wir haben mit diesen LEDs Dualzahlen abgebildet. Das mag zwar für
technikaffine Menschen amüsant sein, aber es bestätigt dem Rest der Welt, dass wir doch
einen leicht anderen Humor haben. Intel hatte daraus mal einen sehr lustigen Werbespot
gemacht. (https://www.youtube.com/watch?v=Gzi4xfMWMuw) Nach ein paar Jahren
E-Technikstudium findet man es wirklich witzig. Der Clip ist also eine gute Gelegenheit,
herauszufinden, wie weit Sie bereits in »Nerdistan« sind.
Wenn wir an Anzeigen denken, stellen wir uns oft ein Display vor. Displays sind derart
billig geworden, dass sie nahezu überall vorkommen. Mit einem richtigen Display wer-
den wir uns am Ende des Buches beschäftigen.
In »Vergessenheit« geraten ist noch eine andere Technologie zum Darstellen von Wer-
ten: die gute alte 7-Segment-Anzeige. Ich kann mich noch gut an einen Wecker aus mei-
ner Kindheit erinnern. Mit dem Uhrzeiger-System konnte ich nie viel anfangen. Aber
dieser Wecker zeigte die Zeit »digital« mithilfe von 7-Segment-Anzeigen an: Endlich
wusste ich, wie spät es war. In vielen Haushaltsgeräten gibt es sie immer noch.
7-Segment-Anzeigen sind heute immer noch wesentlich billiger als Displays, denn im
Endeffekt bestehen sie nur aus einem Gehäuse und 7 bzw. 8 LEDs. In der E-Technik setzt
sich oft die günstigste Möglichkeit durch, nicht die beste.
Genau eine solche Segment-Anzeige wollen wir für verschiedene Zwecke nutzen. Zum
einen bauen wir den Countdown aus Kapitel 8 wieder auf und modifizieren ihn leicht,
und zum anderen bauen wir mit dem Arduino ein kleines Geschicklichkeitsspiel.
10 Die 7-Segment-Anzeige
308
10.1 Die 7-Segment-Anzeige näher betrachtet
7-Segment-Anzeigen gibt es schon recht lange. Man konnte sie fertigen, nachdem man
LEDs erfunden hatte. Sie prägten das »Kantige und Eckige des Digitalen«. Für gewöhnlich
bezeichnet man die einzelnen LEDs mit Buchstaben. Auch wenn jeder Hersteller eigene
Bezeichnungen einführen könnte, sind die Bezeichnungen dennoch recht homogen.
Bei den Angaben in diesem Abschnitt stütze ich mich auf das Datenblatt der 7-Segment-
Anzeige, die ich vorgeschlagen habe. Gegebenenfalls sollten Sie nach dem Datenblatt für
Ihre 7-Segment-Anzeige suchen. Die einzelnen Segmente sind von a bis g durchnumme-
riert (siehe Abbildung 10.1). Das a ist der oberste Balken, und von da an werden im Uhr-
zeigersinn die weiteren Buchstaben vergeben. Der Balken in der Mitte ist der letzte und
bekommt dementsprechend ein g.
Bei manchen Anzeigen gibt es dazu noch einen Punkt, um ein Komma oder Ähnliches
darzustellen. (Das deutsche Komma ist bei einer Zahl der englische Punkt.) Er wird mit
DP bezeichnet. DP steht für decimal point.
Abbildung 10.1 7-Segment-Anzeige mit Buchstaben
für die einzelnen »Balken«
Die Idee hinter diese Anzeige ist, dass man mit ihr verschiedene Zahlen und Buchstaben
darstellen kann – je nachdem, welche »Balken« leuchten und welche nicht. Nehmen wir
einmal die Zahl 3. Wir können sie darstellen, indem alle Balken außer e, f und DP leuch-
ten (siehe Abbildung 10.2).
a
g
d
bce
f
DP
10.1 Die 7-Segment-Anzeige näher betrachtet
309
Abbildung 10.2 Eine 3 kann man auf einer 7-Segment-Anzeige
so darstellen, dass alle Balken außer »e« und »f« leuchten.
Auch könnte man Buchstaben oder Ähnliches darstellen. Bei manchen Buchstaben
braucht man zwar eine Menge Fantasie, wie etwa bei einem »Q«, aber denkbar wäre es.
Wenn wir in eine solche Anzeige hineinschauen, dann gibt es sie in zwei verschiedenen
Varianten (siehe Abbildung 10.3).
Bei der Variante mit der gemeinsamen Anode werden alle LEDs mit ihrer Anode (positi-
ver Teil, langes Beinchen) an die gleiche Quelle angeschlossen. Ob sie dabei leuchten,
entscheidet die Logik, die zwischen der Kathode (negativer Teil, kurzes Beinchen) und
der Masse liegt. Eine solche Logik müsste aus »Schaltern« bestehen, die einen Weg zur
Masse schalten können. So etwas mit dem Arduino zu erzeugen ist relativ schwer.
Geeigneter für den Arduino ist die Variante mit der gemeinsamen Kathode. Dabei sind
die Kathoden alle miteinander verbunden. Die Logik müsste dann nur eine Quelle an-
bzw. ausschalten, also genau das, was wir mit dem Arduino bis jetzt immer gemacht
haben. Eigentlich könnte es sich bei der rechten Schaltung in Abbildung 10.3 auch um
ein Lauflicht handeln. In dieser Abbildung habe ich alle LEDs nur als Dioden dargestellt,
um Platz zu sparen. Dennoch sind dort natürlich LEDs verbaut.
a
g
d
bce
f
DP
10 Die 7-Segment-Anzeige
310
Abbildung 10.3 Die zwei Varianten, wie sie für gewöhnliche 7-Segment-Anzeigen
ausgelegt sind
Wir brauchen dementsprechend – Masse und den Punkt einmal weggedacht – sieben
Anschlüsse auf dem Arduino für eine 7-Segment-Anzeige. Wenn wir eine zweistellige
Anzeige anschließen wollten, dann würden wir 14 Pins benötigen. Leider haben wir auf
dem Uno nur 13 Pins, also einen zu wenig.
Um genau dieses Problem zu lösen, kann man ein Schieberegister verwenden. Zur
Erinnerung: Ein Register ist ein kleiner und sehr schneller Speicher. Das Register, das
wir verwenden werden, hat einen Dateneingang und acht Ausgänge. Das klingt doch
schon einmal nach einer richtig guten Lösung. Manchmal wird ein solches Schiebe-
register auch als Seriell-zu-parallel-Wandler bezeichnet. Auf dem Markt gibt es einige
verschiedene Modelle. Ziemlich günstig und für unsere Zwecke hervorragend geeig-
net ist das Modell 74HC595. Werfen Sie mal einen Blick in das Datenblatt unter http://
www.nxp.com/documents/data_sheet/74HC_HCT595.pdf.
In einem Datenblatt stehen immer eine Menge Angaben und Werte. Wichtig für uns
sind erst einmal nur die Pin-Belegung (siehe Abbildung 10.4) und deren Beschreibung.
Davon ausgehend werde ich erklären, wie so ein Ding funktioniert und warum es uns
bei der 7-Segment-Anzeige hilft.
a b c d e f g DPa b c d e f g DP
Gemeinsame
Kathode
Gemeinsame
Anode
Log
ik
Log
ik
Log
ik
Log
ik
Log
ik
Log
ik
Log
ik
Log
ik
Log
ik
Log
ik
Log
ik
Log
ik
Log
ik
Log
ik
Log
ik
Log
ik
10.1 Die 7-Segment-Anzeige näher betrachtet
311
Abbildung 10.4 Pin-Belegung des 74HC595-Schieberegisters
In Orange sind jeweils die Bezeichnungen aus dem Datenblatt dargestellt. Damit Sie
besser erkennen können, was die Pins für Bedeutungen haben, habe ich manche von
ihnen »eingedeutscht« und zweckbezogen benannt.
Am einfachsten zu erkennen sind die Datenausgänge. Im Datenblatt sind diese jeweils
mit einem Q und einer Nummer bezeichnet. In Anlehnung an die 7-Segment-Anzeige
habe ich die Datenausgänge mit den jeweiligen Buchstaben für den Balken versehen.
Beachten Sie dabei, dass Q0 auf der rechten Seite liegt. Fragen Sie mich nicht, wieso.
VCC und GND sollten Ihnen mittlerweile bekannt sein. VCC ist die Versorgungsspan-
nung, und GND ist die Masse.
Wenn Reset aktiviert wird, sind alle Ausgänge auf LOW. Bei »Reset« sehen Sie einen klei-
nen Balken über den Buchstaben. Damit möchte man ausdrücken, dass dieser Eingang
null aktiv ist. Wenn Reset also LOW ist, werden die Ausgänge zurückgesetzt.
Darüber hinaus bietet mir dieser Baustein die Möglichkeit, einen Ausgang nicht nur auf
HIGH oder LOW zu setzen, sondern noch auf einen dritten Zustand. Dieser wird wahl-
weise High Impedance (hoher Widerstand) oder einfach nur Tristate (dritter Zustand)
genannt. In diesem Zustand haben die Ausgänge einen sehr hohen Widerstand. Damit
ist es möglich, die Ausgänge zu »deaktivieren«. Dementsprechend gibt es den Pin Out-
put enable (OE) – also um den Ausgang anzuschalten. Auch OE ist null aktiv. Damit die
Ausgänge also aktiviert werden, muss ein LOW anliegen.
Nun kommen wir zur eigentlichen Idee hinter diesem Baustein, die ich in Abbildung
10.5 visualisiert habe.
Fangen wir einmal mit dem oberen Teil an: Alle Kästchen mit einem schwarzen Rah-
men sind Bausteine des Schieberegisters. Das Schieberegister hat einen Eingang mit
dem Namen Serial Data Input (DS), was der Pin 14 ist, und einen Ausgang namens Serial
1b (Q1)
2c (Q2)
3d (Q3)
4e (Q4)
5f (Q5)
6g (Q6)
7DP (Q7)
8GND
16 VCC
15 a (Q0)
14 Serial Data Input (DS)
13 Output enable (OE)
12 Speichertakt (STCP)
11 Schiebetakt (SHCP)
10 Reset (MR)
9 Serial Data Output (Q7S)
10 Die 7-Segment-Anzeige
312
Data Output (Q7S). Der Ausgang befindet sich an Pin 9. Wenn der Schiebetakt eine stei-
gende Flanke hat, wird der Eingang auf das erste Speicherelement übernommen. Wenn
die nächste steigende Flanke kommt, wandert das Bit um eine Position weiter.
Abbildung 10.5 Das Prinzip des Schieberegisters 74HC595
Nehmen wir an, wir möchten, dass an der 7-Segment-Anzeige eine 3 steht. Dann wissen
wir, dass alles außer e, f und DC leuchten muss. Die Bitfolge ist in Abbildung 10.6 darge-
stellt.
Abbildung 10.6 Erforderliche Bitfolge, damit eine 3 angezeigt wird
Dazu machen wir Folgendes: An DS (Serial Data Input) legen wir 0 an. Dies ist für den
Ausgang DC. Nun erzeugen wir eine Taktflanke vom Schiebetakt und setzen danach DS
auf 1 (g). Wir erzeugen wieder einen Schiebetakt. So geht es weiter:
� DS auf 0 setzen (f), Schiebetakt
� DS auf 0 setzen (e), Schiebetakt
� DS auf 1 setzen (d), Schiebetakt
� DS auf 1 setzen (c), Schiebetakt
� DS auf 1 setzen (b), Schiebetakt
� DS auf 1 setzen (a), Schiebetakt
Nun haben wir in den oberen schwarzen Kästchen genau die Bitfolge aus Abbildung
10.6. Damit diese dann auch auf den Ausgang gelegt werden, brauchen wir den zweiten
abcdefg
DC
Schiebetakt
Serial
Data
Output
Serial
Data
InputSpeichertakt
0 1 0 0 1 1 1 1
DC g f e d c b a
10.2 Schaltung für den Countdown
313
Takt, nämlich den Speichertakt. In dem Moment, wo beim Speichertakt eine steigende
Flanke kommt, werden die Werte aus den schwarzen Kästchen in die orangefarbenen
übernommen und liegen damit am Ausgang an. Die 7-Segment-Anzeige würde eine 3
anzeigen.
Wenn wir auf die Spielereien wie Output enable und Reset verzichten, brauchen wir also
nur 3 Eingänge (Serial Data Input, Speichertakt und Schiebetakt), um 8 Ausgänge zu steu-
ern. Wenn wir mehrere 7-Segment-Anzeigen steuern, die ein »Display« ergeben sollen,
so könnten wir für alle den gleichen Takt verwenden. Wir bräuchten also pro Anzeige nur
noch den Serial Data Input. 13 Pins haben wir, zwei brauchen wir für die Takte, verbleiben
11 Pins für Dateneingänge, und damit könnte man 11 Anzeigen ansteuern. Allerdings
wird der Arduino wohl nicht genug Strom für alle diese Anzeigen liefern können.
Wir können allerdings noch einen anderen Effekt nutzen. Man kann diese Bausteine
kaskadieren. Damit ist gemeint, dass die Anzeigen derart verbunden werden, dass der
Serial Data Output des einen Bausteins auf den Serial Data Input des nächsten zeigt.
Abbildung 10.7 Kaskadieren der Schieberegister
In Abbildung 10.7 sind nur die Datenleitungen gezeigt. Damit dies funktioniert, müss-
ten auch alle Bausteine den gleichen Schiebetakt und den gleichen Speichertakt haben.
Der Übersichtlichkeit halber habe ich diese Anschlüsse jedoch weggelassen.
10.2 Schaltung für den Countdown
Der Aufbau dieser Schaltung ist wirklich »anders«. Er ist nicht direkt kompliziert, son-
dern nur aufwendig, und Sie müssen sehr achtsam vorgehen. Wirklich übersichtlich ist
er aber weder in der Darstellung noch auf dem Board.
1
2
3
4
5
6
7
8
16
15
14
13
12
11
10
9
1
2
3
4
5
6
7
8
16
15
14 Serial DataInput (DS)13
12
11
10
9 Serial DataOutput (Q7S)
1
2
3
4
5
6
7
8
16
15
14 Serial DataInput (DS)13
12
11
10
9 Serial DataOutput (Q7S)
Arduino
Serial DataOutput (Q7S)
Serial Data Input (DS)
10 Die 7-Segment-Anzeige
314
Abbildung 10.8 Aufbau der Schaltung auf dem Steckbrett für die 7-Segment-Anzeigen
Der Schaltplan in Abbildung 10.9 sieht ein wenig übersichtlicher aus.
Abbildung 10.9 Schaltplan für zwei 7-Segment-Anzeigen
10.2 Schaltung für den Countdown
315
Lassen Sie sich davon nicht abschrecken. Wir bauen diese Schaltung Stück für Stück.
Zuerst nehmen Sie sich das Steckbrett und legen es vor sich hin. Die Minus- und Plus-
schienen auf beiden Seiten verbinden Sie miteinander. Von einer Minusschiene führen
Sie eine Leitung zum GND-Pin des Arduino. Von der Plusschiene aus setzen Sie eine
Steckbrücke in die +5-V-Buchse (siehe Abbildung 10.10).
Abbildung 10.10 Schritt 1: Minus- und Plusschienen verbinden (Minus → GND, Plus → 5 V)
Nun platzieren Sie die Schiebregister an den Enden des Steckbretts. Wenn Sie diese genau
anschauen, erkennen Sie, dass sie eine runde Vertiefung haben. Diese Vertiefung muss bei
beiden nach außen zeigen. Die »Käfer« müssen Sie mit ein wenig Gefühl platzieren, damit
sie richtig passen. Die 7-Segment-Anzeigen kommen in die Mitte des Steckbretts. Der
Punkt zeigt dabei zu Ihnen. Damit Sie die Mitte treffen, setzen Sie die obere linke Ecke der
ersten Anzeige in G28. Die andere platzieren Sie direkt daneben (siehe Abbildung 10.11).
Abbildung 10.11 Schritt 2: Schieberegister und 7-Segment-Anzeigen platzieren
10 Die 7-Segment-Anzeige
316
In den Dateien zum Buch finden Sie Abbildung 10.12 zum Ausdrucken. Sie hilft immens,
die Übersicht zu behalten.
Abbildung 10.12 Hilfestellung, damit mit der Verkabelung nichts schiefgeht
Im nächsten Schritt verbinden Sie alles, was eine feste Verdrahtung hat. Damit meine
ich die Kathode (M) der beiden 7-Segment-Anzeigen sowie VCC und GND von den Schiebe-
registern. Wir möchten die Reset-Funktion nicht nutzen. Da diese null aktiv ist, muss
Reset dauerhaft mit einem HIGH verbunden sein, also mit der Plusschiene.
Wir möchten, dass der Ausgang immer aktiv ist. Da Output Enable auch null aktiv ist,
muss also hier dauerhaft ein LOW anliegen – also die Minusschiene. Beachten Sie dabei
auch, dass die beiden Schieberegister zueinander spiegelverkehrt sind (siehe Abbil-
dung 10.12).
Nun geht es an den Dateneingang (siehe Abbildung 10.14). Dies ist das erste Signal, das
zum Arduino führt. Ich würde keine Kaskadierung vorschlagen, also brauchen wir zwei
Pins beim Arduino für die Datenleitungen. Die Datenleitung beim Schieberegister ist
Pin 14. Ich habe den linken Käfer auf Pin 13 vom Arduino führen lassen. Beim rechten
Käfer ist es Pin 12.
1b
(Q
1)
2c
(Q2
)
3d
(Q
3)
4e
(Q
4)
5f
(Q5)
6g
(Q
6)
7D
P (
Q7)
8G
ND
16V
CC
15a
(Q
0)
14S
eri
al
Da
ta I
np
ut
(DS
)
13 12S
pe
ich
ert
ak
t (S
TC
P)
11 10
Sch
ieb
eta
kt
(SH
CP
)
Re
set
(MR
)
9S
eri
al
Da
ta O
utp
ut
(Q7S
)
Ou
tpu
t e
na
ble
(O
E)
1b
(Q1)
2c (Q
2)
3d
(Q3
)
4e
(Q4
)
5f (Q
5)
6g
(Q6
)
7D
P (Q
7)
8G
ND
16V
CC
15a
(Q0
)
14S
eria
l Da
ta In
pu
t (DS
)
1312S
pe
iche
rtak
t (ST
CP
)
11S
chie
be
tak
t (SH
CP
)
109S
eria
l Da
ta O
utp
ut (Q
7S)
Re
set (M
R)
Ou
tpu
t en
ab
le (O
E)
a
ag
d
bce
f
DP
e d M c DP
g f M a b
10.2 Schaltung für den Countdown
317
Abbildung 10.13 Schritt 3: Alles was »fest« ist, wurde verbunden. Schwarz (GND), rot (VCC),
grün (OE), weiß (Reset)
Abbildung 10.14 Schritt 4: Datenleitung zum Arduino (orange)
Im nächsten Schritt nehmen wir uns die Takte vor (siehe Abbildung 10.15). Beginnen wir
beim Speichertakt. Das ist Pin 12 beim Register. Beide Register sollen dieselben Takte
haben. Der Speichertakt verlässt den Arduino an Pin 8 und wird mittels Steckbrücke auf
den Pin 12 des linken Registers geführt. Von dort aus wird der Takt »verlängert« zum Pin
12 des rechten Käfers. Genauso gehen Sie auch beim Schiebetakt vor, nur dass die Ver-
bindung von Pin 7 des Arduino zum Pin 11 des Registers führt.
10 Die 7-Segment-Anzeige
318
Abbildung 10.15 Schritt 5: Verbinden der Takte – Schiebetakt (blau), Speichertakt (gelb)
Jetzt brauchen Sie ein wenig Fingerspitzengefühl. Wir brauchen jeweils 8 Widerstände
links und rechts neben den 7-Segment-Anzeigen (siehe Abbildung 10.16). Ich empfehle
Ihnen, eine Reihe neben den Anzeigen Platz zu lassen, so wie auch eine Reihe zwischen
den Widerständen.
Abbildung 10.16 Schritt 6: Platzieren der Widerstände
Nun folgt die Verbindung von der 7-Segment-Anzeige zu einem Widerstand und von
dort aus zu dem Ausgang des entsprechenden ICs (siehe Abbildung 10.17). Widerstände
links von den Anzeigen nehmen den linken IC, die rechts davon den rechten IC. Ich
würde die Widerstände von a nach DC gedanklich nummerieren, und zwar beginnend
ab der 7-Segment-Anzeige.
10.2 Schaltung für den Countdown
319
Für das a bei der rechten 7-Segment-Anzeige gilt beispielsweise:
1. Nehmen Sie sich eine Steckbrücke, platzieren Sie sie genau eine Reihe neben dem
schwarzen Kabel für die Masse der 7-Segment-Anzeige (a).
2. Führen Sie das Kabel nach rechts zum ersten Widerstand.
3. Nehmen Sie eine zweite Steckbrücke – am besten in derselben Farbe –, und befesti-
gen Sie sie auf der anderen Seite des Widerstandes.
4. Nun schauen Sie, an welchem Pin des Registers der Ausgang a liegt. Das ist die 15.
Genau dort stecken Sie das andere Ende der Steckbrücke ein.
Dasselbe Verfahren gilt für die linke Seite.
Abbildung 10.17 Schritt 7: Verbindung zwischen 7-Segment-Anzeige und IC
Das machen Sie nun mit allen weiteren Segmenten der Anzeige (siehe Abbildung 10.18).
Abbildung 10.18 Hier sind schon drei Segmente verbunden.
10 Die 7-Segment-Anzeige
320
Wenn Sie das geschafft haben, sieht es vor allem nach einer ganzen Menge an Kabeln
aus (siehe Abbildung 10.19).
Abbildung 10.19 Geschafft: Die 7-Segment-Anzeigen sind verbunden.
Für das Geschicklichkeitsspiel aus Abschnitt 10.5 müssen wir die Schaltung später noch
ein klein wenig erweitern, und zwar um zwei Taster und zwei LEDs. Das machen wir aber
zu gegebener Zeit. Erst mal testen wir das Konstrukt.
10.3 Der Countdown
Nachdem der Aufbau geschafft ist, beginnen wir, den Countdown zu bauen und mit der
7-Segment-Anzeige zu interagieren. Wir werden uns auch hier wieder an den fertigen
Sketch herantasten. Sobald Sie die Steuerung der 7-Segment-Anzeige verstanden haben,
werden wir mit dem Spiel anfangen.
Zuerst möchten wir einfach, dass irgendeine Zahl leuchtet. Starten wir ganz vorne, und
definieren wir uns zuerst die Pins und setzen diese als Ausgang:
#define DATEN_EINGANG1 13#define DATEN_EINGANG2 12#define SCHIEBE_TAKT 7#define SPEICHER_TAKT 8
void setup(){
pinMode(DATEN_EINGANG1, OUTPUT);
10.3 Der Countdown
321
pinMode(DATEN_EINGANG2, OUTPUT);pinMode(SCHIEBE_TAKT, OUTPUT);pinMode(SPEICHER_TAKT, OUTPUT);
Serial.begin(9600);}
Listing 10.1 Beginn der Steuerung: Wir definieren die Pins und setzen sie als Ausgang
Sollten bei Ihnen die Pins anders sein (was vollkommen legitim ist), müssen Sie die
#defines entsprechend anpassen. Das Starten der seriellen Verbindung dient nur der
Suche nach potenziellen Fehlern.
Die erste Anzeige soll eine 4 zeigen, und die zweite soll eine 2 zeigen. Dafür müssten wir
zwei Dinge überlegen: Welche Balken müssen dafür leuchten, und wie speichern wir dies?
Wie wir dies übertragen, erkläre ich erst später. Fällt es Ihnen ein? Wir können die Infor-
mation, welche Balken leuchten sollen und welche nicht, wunderbar in ein Array
packen. Das erste Element entspricht dem Punkt (DP) und das letzte Element dem a.
Wenn Sie jetzt noch ein paar Seiten zurückblättern und sich die 7-Segment-Anzeige
anschauen, sollten Sie auch auf die folgenden Arrays kommen:
int vier7Segment[] = { LOW, HIGH, HIGH, LOW, LOW, HIGH, HIGH, LOW };int zwei7Segment[] = { LOW, HIGH, LOW, HIGH, HIGH, LOW, HIGH, HIGH };
Listing 10.2 Diese beiden Arrays stellen eine 4 und eine 2 entsprechend der Balken der
7-Segment-Anzeige dar. Das erste Element ist der Punkt (DP). Das letzte Element ist das »a«.
Nun müssen wir diese Folge von Nullen und Einsen nur noch in das Speicherregister
bekommen. Wie das geht, haben wir vom Prinzip schon geklärt: Wir legen den Pegel an
den Dateneingang, takten das Schieberegister, solange noch nicht jeder Pegel am Ein-
gang war; und wenn wir fertig sind, takten wir das Speicherregister.
Die Beschreibung ist noch etwas dürftig. Ich versuche, sie einmal etwas genauer zu hal-
ten: Zu Beginn ist sowohl der Speichertakt als auch der Schiebetakt auf einem LOW-
Pegel. Wir beginnen damit, das Array zu durchlaufen. Jedes Element im Array entspricht
einem Pegel und wird entsprechend auf den Dateneingang des Registers gelegt. Nun
muss dieser Pegel übernommen werden. Dafür braucht das Schieberegister einen Takt.
Diesen Takt können wir einfach erzeugen, indem wir einen HIGH-Pegel anlegen, kurz
warten und dann wieder auf einen LOW-Pegel umschalten.
Wurden alle Elemente des Arrays durchlaufen, muss der Takt für das Speicherregister
erzeugt werden. Diesen kann man wie auch den Takt des Schieberegisters erzeugen:
10 Die 7-Segment-Anzeige
322
HIGH-Pegel anlegen, kurz warten, LOW-Pegel anlegen. Alles klar? Dann ran an den
Quellcode:
void Schreibe42(){
for (int i = 0; i < 8; i++){
int pegel1 = vier7Segment[i];int pegel2 = zwei7Segment[i];digitalWrite(DATEN_EINGANG1, pegel1);digitalWrite(DATEN_EINGANG2, pegel2);
/* Erzeugen einer steigenden Flanke für das Schieberegister,indem man den Pin für den "Schiebetakt" auf LOW setzt unddanach auf HIGH */
digitalWrite(SCHIEBE_TAKT, LOW);digitalWrite(SCHIEBE_TAKT, HIGH);//delayMicroseconds(100);
}
/* Erzeugen einer steigenden Flanke für das Speicherregister,indem man den Pin für den "Speichertakt" auf LOW setzt unddanach auf HIGH */
digitalWrite(SPEICHER_TAKT, LOW);digitalWrite(SPEICHER_TAKT, HIGH);//delayMicroseconds(100);
}
Listing 10.3 So können wir eine 42 auf die 7-Segment-Anzeige schreiben.
Zuerst habe ich die Funktionalität in eine Funktion ausgelagert und diese Schreibe42
genannt. Da die Funktion nur etwas tut, jedoch nichts zurückgibt, ist der Rückgabetyp
void. Insgesamt müssen wir acht Informationen in den Baustein bringen. Mit anderen
Worten: Wir müssen das Array auslesen. Die Größe des Arrays ist diesmal statisch, da
das Schieberegister nun einmal 8 Bit breit ist. Deswegen arbeiten wir nicht mit sizeof().
Nach dem Auslesen der Pegel an der entsprechenden Stelle und dem Speichern des
Werts in den Variablen pegel1 und pegel2 schreiben wir diese Pegel auf die entsprechen-
den Datenleitungen.
Jetzt müssen wir den Schieberegistern beibringen, dass sie diesen Wert an ihren Eingän-
gen übernehmen. Das erreichen wir, indem wir einen Takt für das Schieberegister ange-
10.3 Der Countdown
323
ben. In der Beschreibung zuvor habe ich noch gesagt, dass wir zwischen dem Wechsel
von HIGH nach LOW warten müssen. De facto ist dieses Schieberegister so schnell, dass
eine kurze steigende Flanke reicht. Hinzu kommt, dass ohnehin Zeit zwischen dem Auf-
ruf der beiden Funktionen vergeht. Der Takt ist hierbei also kein so »schönes« sauberes
Viereck, sondern nur ein »kurzes Zucken«.
Nachdem der Takt erzeugt wurde, müsste man eigentlich eine bestimmte Zeit warten,
um sicherzugehen, dass dieser Wert übernommen wurde. Man nennt diese Zeit auch
Setup-Zeit. Das Schieberegister ist jedoch so schnell, dass die kleine Spitze vollkommen
reicht. Sollte die Schaltung nachher kleine »Macken« haben, können Sie die Haltezeit
(//delayMicroseconds(100);) einfach wieder einkommentieren.
Mit jedem Takt, den wir auf diese Weise erzeugen, wandern die Bits im Schieberegister
genau eine Position weiter. Deswegen fangen wir beim Array mit dem ersten Element
an, das dem Punkt (DP) entspricht. Nach acht Takten liegt genau dies an Q7 an, was mit
unserem Punkt verbunden ist. Das zweite Element im Array liegt an Q6, was bei uns mit
g verbunden ist, usw.
Nachdem im Schieberegister alles so sitzt, wie wir es uns gewünscht haben, müssen wir
noch dafür sorgen, dass diese Bits wirklich als Ausgang fungieren. Dazu müssen wir
dem Speicherregister sagen, dass es die Werte aus dem Schieberegister übernehmen
soll und an den Ports Q0 bis Q7 ausgeben soll. Das passiert auch hier wieder über einen
Takt, diesmal jedoch an dem Speicher-Takt-Pin. Auch hier ist (zumindest in meinen Ver-
suchen) keine weitere Wartezeit erforderlich. (Im Bedarfsfall kann man wie gesagt diese
Wartezeit wieder einkommentieren.)
Hinweis
Denkbar wäre auch gewesen, dass wir die gesamte Verkabelung dahingehend ändern,
dass Q0 mit dem Punkt verbunden wird, und der Rest dementsprechend. Dann hätte
man das Array entweder andersherum aufbauen müssen oder so, dass es vom letzten
zum ersten Element durchlaufen wird. Mir persönlich gefällt die andere Lösung besser.
Diese Funktion rufen wir am besten in der setup-Funktion auf:
void setup(){
Schreibe42();}
Listing 10.4 Aufruf der Funktion, die eine 42 auf der 7-Segment-Anzeige ausgibt,
in der »setup«-Funktion
10 Die 7-Segment-Anzeige
324
Unser Sketch ist reif für einen ersten Test. Im besten Fall sieht es dann so aus wie in
Abbildung 10.20.
Abbildung 10.20 Die 7-Segment-Anzeige zeigt eine 42 an. Somit habe ich
alles richtig aufgebaut.
Für den Fall, dass ein oder mehrere Balken nicht leuchten, ändern Sie den Sketch kurz
ab, indem Sie alle Balken einschalten:
int vier7Segment[] = { HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH };int zwei7Segment[] = { HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH };
Listing 10.5 Um zu testen, ob alles richtig verbunden ist, schalten Sie einfach alle Balken an.
Nun suchen Sie die fehlerhaften Balken und schauen deren Verbindung nach. Entweder
ist die Verbindung vom Käfer zum Widerstand nicht richtig oder die Verbindung vom
Käfer zur 7-Segment-Anzeige. Vielleicht haben Sie auch die »falschen« Pins miteinander
verbunden?
Sollte eine oder sollten beide Anzeigen überhaupt nicht leuchten, prüfen Sie Folgendes:
� Ist die gemeinsame Kathode der 7-Segment-Anzeige richtig mit der Masseschiene
verbunden?
� Kommen vom Arduino überhaupt 5 V und GND an dem Steckbrett an?
� Haben Sie die Schienen auf den beiden Seiten des Steckbretts richtig miteinander
verbunden?
� Liegen 5 V und GND an den Käfern an?
10.4 Den Countdown spannender machen
325
� Reset muss auf Plus liegen.
� Output Enable muss auf Minus liegen.
� Sind die Takte eventuell vertauscht?
� Sind beim Arduino falsche Pins belegt?
Die Schaltung ist eigentlich wirklich nicht schwer, nur leider fehleranfällig. Wenn alle
Stricke reißen und Sie den Fehler einfach nicht finden, bauen Sie alles auseinander. »Lüf-
ten« Sie Ihren Kopf, indem Sie etwas anderes tun, und versuchen Sie es dann noch ein-
mal von vorn mit nur einer Anzeige. Wenn dies klappt, nehmen Sie sich die nächste vor.
10.4 Den Countdown spannender machen
Damit der Countdown etwas spannender wird und um das Thema Zufallszahlen aufzu-
frischen, beginnen wir damit, dass wir eine Zufallszahl generieren. Von dieser Zahl zäh-
len wir dann bis null herunter. Das Generieren der Zufallszahl packen wir dieses Mal in
eine Funktion, da wir es noch für das Spiel in Abschnitt 10.5 brauchen werden.
int GibMirEineZufallszahl(int min, int max){
int zufallsZahl = random();if (zufallsZahl < 0){
zufallsZahl *= -1;}
int differenz = max - min;int ergebnis = (zufallsZahl % differenz) + min;return ergebnis;
}
Listing 10.6 Funktion zu Ermittlung einer Zufallszahl
Die Funktion soll nicht nur etwas machen, sondern diesmal auch etwas zurückgeben,
nämlich eine Zufallszahl. Da wir nur ganzzahlig zählen wollen, ist der Rückgabetyp der
Funktion int. Sprechende Namen helfen Quellcode lesbarer zu machen, deswegen habe
ich die Funktion GibMirEineZufallszahl genannt. Damit wir nicht beliebig große Zahlen
generieren, geben wir der Funktion zusätzlich einen minimalen (min) und einen maxi-
malen (max) Wert mit auf den Weg. Auch die Grenzen sollen logischerweise ganze Zahlen
sein, deswegen ist der Datentyp auch hier int.
10 Die 7-Segment-Anzeige
326
Die nächsten Zeilen sollten Ihnen bekannt vorkommen: Wir generieren eine Zufallszahl
durch die Funktion random(). Wenn die Zahl negativ ist (zufallsZahl < 0), bilden wir den
Betrag dieser Zahl (zufallsZahl *= -1).
Die Zeile danach ist neu. Wir wissen, dass das Ergebnis des Modulo-Operators (%) immer
kleiner als der Divisor ist. Beim Entscheidungshelfer hatten wir am Anfang zwei Mög-
lichkeiten und haben % 2 gerechnet, und die möglichen Ergebnisse waren 0 und 1. Nun
bilden wir zuerst die Differenz aus dem maximalen und dem minimalen Wert (max - min),
und genau diese benutzen wir als Divisor. Wir erhalten also Werte zwischen 0 und dif-
ferenz – 1. Da wir auch einen minimalen Wert vorgegeben haben, müssen wir zu diesem
Ergebnis noch einmal die untere Grenze addieren. Sehen wir uns dazu am besten ein
Beispiel an.
Wir möchten Zahlen zwischen 30 und 50 erzeugen. Sagen wir, die Zufallszahl wäre 60. Die
Differenz aus 50 und 30 ist 20. 60 modulo 20 ist 3 Rest 0. Zu dieser 0 addieren wir nun 30.
Ergebnis: 30. Das Ergebnis ist zwischen 30 und 50. Nehmen wir an, die Zufallszahl wäre
79. Die Differenz ist immer noch 20. 79 modulo 20 ist 3 Rest 19. 19 + 30 ist 49, und wir
befinden uns wieder in den Grenzen. Probieren Sie es ruhig mit anderen Zahlen aus.
Damit es wirklich zufällig wird, müssen wir den Zufallszahlengenerator initialisieren.
Der Wert dafür wurde Seed genannt. Im folgenden Listing lesen wir in der Setup-Funk-
tion einen analogen Pin und setzen diesen Wert als Seed. Darüber hinaus setzen wir
gleich den Wert des Countdowns über diese Funktion.
int countdown = 0;
void setup(){
int rauschen = analogRead(0);randomSeed(rauschen);countdown = GibMirEineZufallszahl(30, 50);
--- Ausgabe gekürzt ---}
Listing 10.7 Mithilfe von »analogRead()« wird Rauschen eingefangen und als Startwert für den
Zufallszahlengenerator verwendet. Anschließend wird dieser verwendet, um den Startwert zu
ermitteln.
Sollten Sie der Funktion GibMirEineZufallszahl() immer noch misstrauen, können Sie
die UART-Schnittstelle und den Serial Monitor nutzen, um diese Zahl zu prüfen. Fügen
Sie einfach in die loop-Funktion ein bisschen Quelltext ein:
10.4 Den Countdown spannender machen
327
void loop(){
int zufaelligeZahl = GibMirEineZufallszahl(30, 50);Serial.println(zufaelligeZahl);delay(1000);
}
Listing 10.8 Einfache Testmöglichkeit für die Zufallszahlen. Jede Sekunde wird
auf dem Serial Monitor eine neue Zufallszahl angezeigt.
Damit haben wir den Startwert des Countdowns. Wie wir eine Sekunde abbilden, hatte
ich schon in Kapitel 8 erklärt. Den Timer können wir einfach wiederverwenden. Da ich
Kapitel 8 aber als optional eingestuft hatte, werde ich nur delay() verwenden.
Nun machen wir uns an die loop-Funktion:
void loop(){
Serial.print("Zeit verbleibend:");Serial.println(countdown);delay(1000);countdown -= 1;
}
Listing 10.9 In der »loop«-Funktion wird auf eine Neuigkeit geprüft, und wenn es eine gibt,
so wird der aktuelle Stand des Countdowns mitgeteilt.
Auch hier passiert nichts Unbekanntes. Zur Fehlersuche wurde schon einmal präventiv
eine Ausgabe über UART gemacht.
Um das eigentliche Problem habe ich mich elegant gedrückt: Wir wollten diese Zahl auf
der 7-Segment-Anzeige haben und nicht auf dem Serial Monitor. Die gute Nachricht ist:
Wir haben so weit alles vorbereitet. Die schlechte Nachricht ist: Jetzt helfen nicht mehr
Copy & Paste und leichte Modifizierung, sondern wir müssen wirklich noch mal über
das Thema nachdenken.
Wir haben eine Funktion, mit der wir »42« darstellen können. Ich denke, es liegt auf der
Hand, dass wir nicht noch 100 weitere derartige Funktionen schreiben, sondern dass
wir uns einen anderen Weg einfallen lassen sollten.
10 Die 7-Segment-Anzeige
328
Offensichtlich haben unsere Zahlen immer zwei Stellen, wenn wir uns eine 0 vor den
einstelligen Zahlen denken. Damit fangen wir einmal an. Wir möchten genau diesen
Zahlenwert der ersten bzw. zweiten Stelle ermitteln. Dies ist wirklich einfach:
int ersteStelle = countdown / 10;int zweiteStelle = countdown % 10;
Listing 10.10 Ermitteln der Stellen einer zweistelligen Zahl
Die letzte Stelle erhalten wir einfach, indem wir eine Restdivision mit 10 durchführen.
Bei der ersten Stelle machen wir uns die Tatsache zunutze, dass die Division von einem
int und int auch ein int ist. Das Ergebnis ist dann immer ohne Kommastellen, und es
findet dabei Runden durch Abschneiden statt. 37 / 10 ist 3,7, also 3. 37 % 10 ist 7. Die erste
und zweite Stelle haben wir ermittelt, oder?
Wie sieht es denn aus, wenn die Zahl kleiner als 10 ist, zum Beispiel 6? Würde man 6 / 10
rechnen, was 0,6 ist, wäre das Ergebnis 0. 6 % 10 ist 6. Auch hier passt das Verfahren.
Glück gehabt!
Jetzt müssen wir diese Ziffern nur noch auf den 7-Segment-Anzeigen ausgeben. Dafür
verallgemeinern wir die Funktion Schreibe42() zunächst in der Art, dass sie ein belie-
biges Array an den IC sendet. Die Änderungen dafür sind marginal. Anstatt die Werte
von festen Arrays auszulesen, werden die Werte aus den übergebenen Arrays ausge-
lesen:
void SchreibeEtwasAnDieRegister(int werte1[], int werte2[]){
for (int i = 0; i < 8; i++){
int pegel1 = werte1[i];int pegel2 = werte2[i];digitalWrite(DATEN_EINGANG1, pegel1);digitalWrite(DATEN_EINGANG2, pegel2);
/* Erzeugen einer steigenden Flanke für das Schieberegister,indem man den Pin für den "Schiebe-Takt" auf LOW setztund danach auf HIGH */
digitalWrite(SCHIEBE_TAKT, LOW);digitalWrite(SCHIEBE_TAKT, HIGH);//delayMicroseconds(100);
}
10.4 Den Countdown spannender machen
329
/* Erzeugen einer steigenden Flanke für das Speicherregister,indem man den Pin für den "Speicher-Takt" auf LOW setztund danach auf HIGH */
digitalWrite(SPEICHER_TAKT, LOW);digitalWrite(SPEICHER_TAKT, HIGH);//delayMicroseconds(100);
}
Listing 10.11 Aus der Funktion »Schreibe42« ist »SchreibeEtwasAnDieRegister« geworden.
Die Änderungen sind fett hervorgehoben.
Jetzt stehen wir nur noch vor dem Problem, entsprechend der Zahl das richtige Array
von den »Balken-Belegungen« auszuwählen. Also legen wir uns für die 10 Ziffern (0 bis 9)
die entsprechenden Arrays an. Das ist ein wenig Fleißarbeit:
int null7Segment[] = { LOW, LOW, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH };int eins7Segment[] = { LOW, LOW, LOW, LOW, LOW, HIGH, HIGH, LOW };int zwei7Segment[] = { LOW, HIGH, LOW, HIGH, HIGH, LOW, HIGH, HIGH };int drei7Segment[] = { LOW, HIGH, LOW, LOW, HIGH, HIGH, HIGH, HIGH };int vier7Segment[] = { LOW, HIGH, HIGH, LOW, LOW, HIGH, HIGH, LOW };int fuenf7Segment[] = { LOW, HIGH, HIGH, LOW, HIGH, HIGH, LOW, HIGH };int sechs7Segment[] = { LOW, HIGH, HIGH, HIGH, HIGH, HIGH, LOW, HIGH };int sieben7Segment[] = { LOW, LOW, LOW, LOW, LOW, HIGH, HIGH, HIGH };int acht7Segment[] = { LOW, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH };int neun7Segment[] = { LOW, HIGH, HIGH, LOW, HIGH, HIGH, HIGH, HIGH };
Listing 10.12 Die Darstellung der Ziffern von 0 bis 9 kann so in die Darstellung der
7-Segment-Anzeige gebracht werden.
Jetzt müssen wir noch eine Abbildung zwischen Array und Zahl haben. Im klassischen
Fall würden wir einfach eine if-Abfrage für die eine Stelle und eine if-Abfrage für die
anderen Stellen machen. Das klingt nach ziemlich vielen if-Abfragen. Wir können dies
aber noch cleverer lösen, indem wir ein mehrdimensionales Array verwenden. Das
klingt komplizierter, als es ist. Betrachten Sie dazu einfach das konkrete Listing:
int zahlenFuer7SegmentAnzeige[10][8] ={
{ LOW, LOW, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH },{ LOW, LOW, LOW, LOW, LOW, HIGH, HIGH, LOW },{ LOW, HIGH, LOW, HIGH, HIGH, LOW, HIGH, HIGH },{ LOW, HIGH, LOW, LOW, HIGH, HIGH, HIGH, HIGH },{ LOW, HIGH, HIGH, LOW, LOW, HIGH, HIGH, LOW },
10 Die 7-Segment-Anzeige
330
{ LOW, HIGH, HIGH, LOW, HIGH, HIGH, LOW, HIGH },{ LOW, HIGH, HIGH, HIGH, HIGH, HIGH, LOW, HIGH },{ LOW, LOW, LOW, LOW, LOW, HIGH, HIGH, HIGH },{ LOW, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH },{ LOW, HIGH, HIGH, LOW, HIGH, HIGH, HIGH, HIGH }
};
Listing 10.13 Erzeugen eines zweidimensionalen Arrays
Bei einem normalen Array haben wir nur eine Dimension. Das erkennen Sie daran, dass
hinter dem Namen nur eine eckige Klammer steht. Bei der Variable zahlenFuer7Segment-
Anzeige[10][8] sind es zwei. Also ist es ein zweidimensionales Array. Die erste Zahl steht
für die erste Dimension, die zweite für die zweite. Wir haben daher 10 Elemente in der
1. Dimension ([10]), da wir genau 10 Ziffern haben. Die zweite Dimension hat 8 ([8]) Ele-
mente, da jede Ziffer genau 8 Balken ansteuern muss. Es ist ein Array in einem Array.
Das sieht man auch an der Initialisierung: Die äußeren geschweiften Klammern gelten
für das gesamte Array, die inneren Klammern stehen für die inneren Arrays.
Wirklich einfach wird jetzt der Aufruf der Funktion SchreibeEtwasAnDieRegister(). Ich
kann verstehen, wenn Sie mir das nicht glauben, nachdem ich Sie mit mehrdimensiona-
len Arrays gequält habe. Aber das nächste Listing macht dies wieder wett, versprochen:
SchreibeEtwasAnDieRegister(zahlenFuer7SegmentAnzeige[ersteStelle],zahlenFuer7SegmentAnzeige[zweiteStelle]);
Listing 10.14 Aufruf der Funktion zum Darstellen der Funktion
auf dem Display – ganz ohne »if«-Anweisung
Nun sind Sie sicherlich auf ganzer Strecke verwirrt. Genau das wollte ich erreichen.
Fangen wir einmal ruhig an: Die Funktion SchreibeEtwasAnDieRegister() erwartet zwei
int-Arrays. Wir haben ein zweidimensionales Array. Das bedeutet: Wenn wir über den
Index-Operator ([]) zugreifen, erhalten wir ein Array mit einer Dimension weniger, also
ein ganz normales eindimensionales Array. Genau so etwas erwartet die Funktion, und
das bekommt sie auch.
In dem zweidimensionalen Array mit dem langen Namen zahlenFuer7SegmentAnzeige
haben wir die Zahlen von 0 bis 9 aufsteigend geschrieben. Wenn wir also den Index 3
wählen würden, so würden wir die vierte Zeile (siehe Listing 10.13) auswählen, und
10.4 Den Countdown spannender machen
331
genau dort befindet sich die Belegung der Balken für die Zahl 3. Es steckt also nur ein
bisschen Magie dahinter und kein böser Voodoo.
Laden Sie den Sketch auf das Board, und probieren Sie ihn aus. Zur Übersicht folgt hier
noch einmal der komplette Sketch:
#define DATEN_EINGANG1 13#define DATEN_EINGANG2 12#define SCHIEBE_TAKT 7#define SPEICHER_TAKT 8
int countdown = 0;
int zahlenFuer7SegmentAnzeige[10][8] ={
{ LOW, LOW, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH },{ LOW, LOW, LOW, LOW, LOW, HIGH, HIGH, LOW },{ LOW, HIGH, LOW, HIGH, HIGH, LOW, HIGH, HIGH },{ LOW, HIGH, LOW, LOW, HIGH, HIGH, HIGH, HIGH },{ LOW, HIGH, HIGH, LOW, LOW, HIGH, HIGH, LOW },{ LOW, HIGH, HIGH, LOW, HIGH, HIGH, LOW, HIGH },{ LOW, HIGH, HIGH, HIGH, HIGH, HIGH, LOW, HIGH },{ LOW, LOW, LOW, LOW, LOW, HIGH, HIGH, HIGH },{ LOW, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH },{ LOW, HIGH, HIGH, LOW, HIGH, HIGH, HIGH, HIGH }
};
int GibMirEineZufallszahl(int min, int max){
int zufallsZahl = random();if (zufallsZahl < 0){
zufallsZahl *= -1;}
int differenz = max - min;int ergebnis = (zufallsZahl % differenz) + min;return ergebnis;
}
void setup(){
10 Die 7-Segment-Anzeige
332
int rauschen = analogRead(0);randomSeed(rauschen);countdown = GibMirEineZufallszahl(30, 80);
pinMode(DATEN_EINGANG1, OUTPUT);pinMode(DATEN_EINGANG2, OUTPUT);pinMode(SCHIEBE_TAKT, OUTPUT);pinMode(SPEICHER_TAKT, OUTPUT);
Serial.begin(9600);}
void SchreibeEtwasAnDieRegister(int werte1[], int werte2[]){
for (int i = 0; i < 8; i++){
int pegel1 = werte1[i];int pegel2 = werte2[i];digitalWrite(DATEN_EINGANG1, pegel1);digitalWrite(DATEN_EINGANG2, pegel2);
/* Erzeugen einer steigenden Flanke für das Schieberegister, indemman den Pin für den "Schiebe-Takt" auf LOW setzt und dann auf HIGH */digitalWrite(SCHIEBE_TAKT, LOW);digitalWrite(SCHIEBE_TAKT, HIGH);//delayMicroseconds(100);
}
/* Erzeugen einer steigenden Flanke für das Speicherregister, indemman den Pin für den "Speicher-Takt" auf LOW setzt und dann auf HIGH */
digitalWrite(SPEICHER_TAKT, LOW);digitalWrite(SPEICHER_TAKT, HIGH);//delayMicroseconds(100);
}
void loop(){
int ersteStelle = countdown / 10;int zweiteStelle = countdown % 10;SchreibeEtwasAnDieRegister(zahlenFuer7SegmentAnzeige[ersteStelle],
zahlenFuer7SegmentAnzeige[zweiteStelle]);
10.5 Ihr erstes Spiel für den Arduino
333
Serial.print("Zeit verbleibend:");Serial.println(countdown);delay(1000);
}}
Listing 10.15 Der komplette Sketch für den Countdown. Das ist wohl der längste Sketch,
den wir je hatten.
Wenn Sie den Sketch nun testen möchten und diese roten Anzeigen mit all den Drähten
sehen, kommen sicherlich Assoziationen mit den Bomben aus Actionfilmen auf. Wenn
Sie besonders kreativ sein möchten, dann verbinden Sie einen Pin vom Arduino mit der
Plusschiene am Steckbrett. Für das nötige Ambiente muss dies ein roter Draht sein. Es
ist immer der rote.
Wenn man diesen Stecker zieht, läuft der Countdown schneller. Das wird der »Knaller«
bei jeder Vorführung. Sollten Sie allerdings neugierige Nachbarn haben, steht vielleicht
bald ein Großaufgebot Polizei vor Ihrer Tür.
10.5 Ihr erstes Spiel für den Arduino
Nachdem wir schon eine riesige Schaltung aufgebaut haben, wollen wir damit auch
etwas Tolles machen. Meine Idee wäre es, dass wir zusammen ein Spiel entwickeln –
klein, aber fein.
Dieses Spiel soll die Reaktionsfähigkeit herausfordern. Zwei Spieler treten gegeneinan-
der an. Jedem Spieler wird eine LED und ein Taster zugeordnet. Leuchtet seine LED,
muss er den Taster drücken. Ist er schneller als sein Gegner, bekommt er für diese
Runde einen Punkt. Es wird über eine bestimmte Anzahl von Runden gespielt. Die
Ergebnisse erscheinen auf dem Display. So viel zur Idee.
Fangen wir einmal mit der Schaltung an. Wir müssen unsere Schaltung noch leicht
erweitern. Am besten eignet sich dazu ein kleines separates Steckbrett. Das kann ein-
fach an das andere Steckbrett angeklickt werden (siehe Abbildung 10.21 und Abbildung
10.22). Zwei Taster, zwei LEDs, zwei Widerstände – der Aufbau sollte Ihnen schon fast
leicht von der Hand gehen. Für die Taster wählen wir später den Zustand INPUT_PULLUP
und sparen uns so die externen Pull-up-Widerstände. Die Taster habe ich mit den Pins 2
und 3 des Arduino verbunden, da wir bei diesen einen Interrupt anfügen können. Für
die LEDs nehmen wir noch zwei PWM-Pins, damit man das Spiel noch leicht um opti-
sche Effekte erweitern kann.
10 Die 7-Segment-Anzeige
334
Abbildung 10.21 Erweiterung der 7-Segment-Anzeige für das Spielfeld
Abbildung 10.22 Ein kleiner Ausschnitt des Spielbretts
Hat man die beiden Steckbretter zusammengesteckt, kann man auch die Minusschie-
nen über die Steckbretter hinweg verbinden.
10.5 Ihr erstes Spiel für den Arduino
335
Ich möchte Ihnen den Spielablauf noch einmal genauer erklären. Selbstverständlich
können Sie diesen Spielplan auch modifizieren – nur dann müssen Sie auch den Quell-
code ändern. Vielleicht fangen Sie erst mit meinem Beispiel an und gehen dann an die
Verwirklichung der eigenen Spielidee.
Das Spiel beginnt, sobald der Arduino gestartet ist. Die beiden LEDs blinken wild, um den
Beginn einer Runde zu symbolisieren. Nach dieser kleinen Showeinlage wird eine zufäl-
lige Zeit gewartet, und eine der beiden LEDs leuchtet kurz. Danach hat der Spieler die
Möglichkeit, den entsprechenden Taster zu drücken. Tut er dies nach einer bestimmten
Zeit nicht, hat er die Chance auf einen Punkt in der Runde vertan. Danach wird wieder
eine zufällige Zeit gewartet, und die andere LED leuchtet kurz. Jetzt hat Spieler 2 die Mög-
lichkeit, seine Reaktionsfähigkeit unter Beweis zu stellen, und kann seinen Taster drü-
cken. Auch hierfür hat er nur eine bestimmte Zeit zur Verfügung. Der Spieler mit der
schnelleren Reaktionszeit erhält einen Punkt. Nach der Runde wird der Punktestand auf
der Anzeige angezeigt, und das wilde Blinken der LEDs signalisiert, dass eine neue Runde
beginnen kann. Sind alle Runden gespielt, leuchten die LEDs dauerhaft und zeigen so das
Ende des Spiels an.
Nun geht es ran ans Programm: Zur Entwicklung des Sketches wählen wir diesmal einen
anderen Ansatz. Anstatt von »oben« auf das Programm zu schauen und einen Plan zu
entwickeln, wie der Ablauf ist, schauen wir uns die folgenden Teile an und überführen
sie in einzelne Funktionen. Sind diese Funktionen fertig, überlegen wir, wie wir das Pro-
gramm aus ihnen zusammensetzen.
� Funktion zur Ausgabe der Punktzahl auf der 7-Segment-Anzeige
� Funktion, die uns eine zufällige Zeit warten lässt
� Funktion, die die LEDs »wild« blinken lässt
� Funktion, die ermittelt, welche LED als nächste leuchtet
� Funktion, die diese LED kurz aufleuchten lässt
� Funktion, die dafür sorgt, dass der nächste Spieler an der Reihe ist, wenn der Taster
nicht gedrückt wurde
� Funktion, die prüft, ob der Taster für die LED gedrückt wurde
� Funktion, die auswertet, welcher Spieler weniger Zeit zum Drücken gebraucht hat,
und entsprechend die Punkte aktualisiert
Wenn wir uns die Teile einmal anschauen, so haben wir schon einiges davon fertig. Die
Ausgabe einer Zahl auf der Anzeige klappt schon. Der erste Punkt ist damit abgehakt.
Eine Funktion, die uns eine Zufallszahl liefert, haben wir auch schon. Für das Warten
können wir einfach ein delay verwenden – wir wollen uns die Welt nicht schwieriger
10 Die 7-Segment-Anzeige
336
machen, als sie ohnehin schon ist. Also ist die zweite Funktion auch schnell hinge-
schrieben:
#define MINIMALE_WARTEZEIT 300#define MAXIMALE_WARTEZEIT 2000
void WarteZufaelligeZeit(){
int warteZeit = GibMirEineZufallszahl(MINIMALE_WARTEZEIT, MAXIMALE_WARTEZEIT); // Angabe in Millisekunden
delay(warteZeit);}
Listing 10.16 Die Funktion, die eine zufällige Zeit wartet
Damit wir das Spiel leicht anpassen können, sollten wir mit #define arbeiten. So können
wir nachher schnell an der Spieldynamik drehen. Die Funktion selbst ruft nur die
Zufallsfunktion aus dem letzten Abschnitt mit der minimalen und maximalen Warte-
zeit als Argumente auf und wartet diese Zeit dann anschließend mit delay ab.
Nun geht es uns um die ungezähmten, wilden LEDs. Beide LEDs sollen immer nur eine
kurze Zeit blinken. Als besonderes Gimmick werden wir auch zufällig bestimmen las-
sen, wie oft die LEDs blinken. Wenn unser Spiel schon nur dünne Charaktere und eine
flache Geschichte hat, dann wollen wir es immerhin gut aussehen lassen.
#define LED_SPIELER1_PIN 6#define LED_SPIELER2_PIN 5
#define MINIMALE_BLINKANZAHL 10#define MAXIMALE_BLINKANZAHL 30#define BLINK_DAUER 50
void LEDsWildBlinkenLassen(){
int blinkAnzahl = GibMirEineZufallszahl(MINIMALE_BLINKANZAHL,MAXIMALE_BLINKANZAHL);
for (int i = 0; i < blinkAnzahl; i++){
digitalWrite(LED_SPIELER1_PIN, HIGH);digitalWrite(LED_SPIELER2_PIN, HIGH);
10.5 Ihr erstes Spiel für den Arduino
337
delay(BLINK_DAUER);digitalWrite(LED_SPIELER1_PIN, LOW);digitalWrite(LED_SPIELER2_PIN, LOW);delay(BLINK_DAUER);
}}
Listing 10.17 Mit dieser Funktion können wir die LEDs blinken lassen.
Zum Blinken muss ich nicht mehr viel sagen, das haben wir ja schon des Öfteren ge-
macht (»an – warten – aus – warten«). Das brauchen wir aber für die beiden LEDs im glei-
chen Takt. Auch hier arbeiten wir wieder mit einer Menge #defines, die wir später
beliebig anpassen können.
Die Funktion, welche LED als nächste leuchtet, klingt vielleicht ein bisschen knifflig, ist
es aber gar nicht. Es handelt sich hierbei auch um eine Zustandsmaschine. Am Anfang
einer Runde wurde noch keine LED gewählt, und es wären beide gültig. Aus diesen bei-
den wird zufällig eine LED gewählt. Beim nächsten Aufruf dieser Funktion kann dann
nur noch die andere gewählt werden. Achtung: Die Funktion ist ein bisschen länger,
aber nicht kompliziert.
#define NOCH_KEINE_LED_GEWAEHLT 1#define LED_SPIELER_1_GEWAEHLT 2#define LED_SPIELER_2_GEWAEHLT 3
int ledZustand = NOCH_KEINE_LED_GEWAEHLT;int GibMirDenPinDerNaechstenLED(){
if (ledZustand == NOCH_KEINE_LED_GEWAEHLT){
int led = GibMirEineZufallszahl(0, 2); /* zwischen 0 und 2 liegendie Werte 0 und 1 */
if (led == 0){
ledZustand = LED_SPIELER_1_GEWAEHLT;return LED_SPIELER1_PIN;
}else{
ledZustand = LED_SPIELER_2_GEWAEHLT;return LED_SPIELER2_PIN;
10 Die 7-Segment-Anzeige
338
}}else if (ledZustand == LED_SPIELER_1_GEWAEHLT){
ledZustand = LED_SPIELER_2_GEWAEHLT;return LED_SPIELER2_PIN;
}else if (ledZustand == LED_SPIELER_2_GEWAEHLT){
ledZustand = LED_SPIELER_1_GEWAEHLT;return LED_SPIELER1_PIN;
}}
Listing 10.18 Funktion, die den Pin der nächsten LED zurückgibt
Am Anfang definieren wir die drei Zustände, die es geben kann, und eine Variable, die
sich den aktuellen Zustand merkt. Danach folgt die Funktion.
Die Funktion soll nicht die LED, sondern den Pin der LED zurückgeben. Sind wir im
Zustand NOCH_KEINE_LED_GEWAEHLT, haben wir noch die freie Auswahl, welche LED die
nächste sein soll. Also würfeln wir.
Vielleicht können Sie sich noch daran erinnern, dass die obere Grenze nicht in der
Menge der möglichen Rückgabewerte war. Wenn wir also eine 0 oder eine 1 erreichen
wollen, müssen wir den Zufallszahlengenerator mit 0 und 2 als Argumente benutzen.
Damit erhalten wir Zahlen zwischen 0 und 2, also 0 oder 1. Das ist genau das, was wir
wollen.
Je nachdem, welche Zahl es nun geworden ist, setzen wir den Zustand und geben den
entsprechenden Pin zurück. Wurde bereits eine Entscheidung getroffen (was bedeutet,
dass der Wert der Variablen ledZustand entweder LED_SPIELER_1_GEWAEHLT oder LED_
SPIELER_2_GEWAEHLT ist), dann müssen wir jeweils den anderen Pin zurückgeben und uns
in den jeweils anderen Zustand begeben. Das passiert in den beiden else if-Verzwei-
gungen.
Die nächste Funktion ist wieder einfacher. Für uns ist sie schon fast trivial. Eine Funk-
tion soll einen übergebenen Pin kurz aufleuchten lassen:
#define KURZE_BLINK_DAUER 20
void LasseLEDKurzAufleuchten(int ledPin)
10.5 Ihr erstes Spiel für den Arduino
339
{digitalWrite(ledPin, HIGH);delay(KURZE_BLINK_DAUER);digitalWrite(ledPin, LOW);
}
Listing 10.19 Funktion, um eine LED an einem übergebenen Pin aufleuchten zu lassen
»Aufleuchten lassen« ist so ähnlich wie »blinken«, nur dass wir das letzte delay() weg-
lassen können.
Die nächsten beiden Funktionen müssen etwas stärker ineinander greifen. Ob ein Tas-
ter gedrückt wurde, bekommen wir aufgrund eines Interrupts mit. In diesem Interrupt
würden wir einen Wert setzen, der aussagt, dass der Taster gedrückt wurde. Würden wir
nach dem Aufleuchten der LED einfach ein langes delay einfügen, würden wir immer
diese Zeitlang warten, egal ob der Taster gedrückt wurde oder nicht. Deshalb werden wir
dieses lange delay in viele kleine delays aufteilen. Nun müssen wir, wenn ein Taster
gedrückt wurde, nur noch das kurze delay warten.
Das ist die Kernidee hinter der Funktion, aber wie muss sie aussehen?
Auf jeden Fall brauchen wir die maximale Wartezeit. Diese müssen wir irgendwo defi-
nieren. Wie lange müssen wir warten? Solange die Gesamtwartezeit noch nicht erreicht
wurde und auch der Taster nicht gedrückt wurde. »Solange« – das klingt für mich nach
einer while-Schleife. Ich hoffe auch für Sie. Dann haben wir jetzt das Rüstzeug, um die
Funktion zu schreiben:
#define JA 1#define NEIN 0
#define MAXIMALE_WARTEZEIT 3000 // in Millisekunden#define KLEINES_WARTEZEIT_INTERVALL 1 // in Millisekunden
int richtigerTasterWurdeGedrueckt = NEIN;
void WarteBisTasterGedurecktOderZeitAbgelaufenIst(){
int gesamteWartezeit = 0;
while (gesamteWartezeit < MAXIMALE_WARTEZEIT &&richtigerTasterWurdeGedrueckt == NEIN)
{
10 Die 7-Segment-Anzeige
340
delay(KLEINES_WARTEZEIT_INTERVALL);gesamteWartezeit += KLEINES_WARTEZEIT_INTERVALL;
}}
Listing 10.20 Funktion, die so lange wartet, bis eine Zeit abgelaufen ist oder der
entsprechende Taster gedrückt wurde.
Am Anfang kommen wieder einmal ein paar #defines – nichts Wildes. Danach erzeugen
wir eine Variable, bei der die Interrupt-Routinen später melden werden, ob der richtige
Taster gedrückt wurde. In dieser Funktion lesen wir sie nur aus.
Die Funktion macht nur etwas, hat allerdings keinen Rückgabetyp, also verwenden wir
den Rückgabetyp void. In der Funktion selbst brauchen wir eine Variable, die sich merkt,
wie lange schon gewartet wird. Der Name dieser Variablen ist gesamteWartezeit, und ihr
Startwert ist 0. Klar, zum Anfang haben wir noch nicht gewartet.
Die while-Schleife selbst prüft zwei Dinge: zum einen, ob schon die maximale Wartezeit
erreicht ist (gesamteWartezeit < MAXIMALE_ WARTEZEIT), und zum anderen, ob der richtige
Taster noch nicht gedrückt wurde (richtigerTasterWurdeGedrueckt == NEIN).
Da die Schleife nur durchlaufen werden muss, wenn weder die Wartezeit erreicht ist
noch der richtige Taster gedrückt wurde, verbinden wir die beiden Bedingungen mit
einem logischen UND (&&).
Ein logisches UND ist nur dann wahr, wenn beide Teilausdrücke wahr sind. Folglich
bricht die Schleife ab, sobald eine der beiden Bedingungen nicht stimmt. In der Schleife
selbst warten wir nur das kurze Intervall und kumulieren die gewartete Dauer auf die
gesamte Wartezeit, d. h., wir addieren sie auf. Wieder etwas geschafft; wir nähern uns
dem Ende der Funktionsliste.
Nun kümmern wir uns darum, dass in den entsprechenden Interrupt-Routinen geprüft
wird, ob der richtige Taster gedrückt wurde. Wir können schon einmal sicher sein, dass
die folgenden Funktionen aufgerufen werden, wenn ein Interrupt ausgelöst wird. Wir
haben auch bereits eine Variable, die weiß, welche LED gewählt wurde. Wir müssen also
nur noch prüfen, ob der Interrupt und damit der Taster zur richtigen Zeit für die richtige
LED gedrückt wurde.
Ein kleines Problem bleibt dann noch: die Sache mit der Reaktionszeit. Der Arduino bie-
tet die Möglichkeit, die vergangenen Millisekunden seit dem letzten Reset auszugeben.
Wenn wir diese Funktion benutzen, bevor eine LED aufleuchtet, und uns den Wert mer-
ken, müssen wir nur beim Drücken des Tasters das Gleiche machen und die Differenz bil-
den, und schon wissen wir, wer schneller ist – nämlich der mit der geringeren Differenz.
10.5 Ihr erstes Spiel für den Arduino
341
Da es auch vorkommen kann, dass ein Spieler zu langsam gewesen ist, definieren wir
einfach, dass eine negative Differenz bedeutet, dass der Spieler eben zu langsam war.
Schauen wir uns also die Funktion an:
#define TASTER_SPIELER1 3#define TASTER_SPIELER2 2
int startZeit;int ZeitDifferenzSpieler1 = -1;int ZeitDifferenzSpieler2 = -1;
void NimmAuswertungDerTasterVor(int tasterPin){
int aktuelleZeit = millis();
if (tasterPin == TASTER_SPIELER1 && ledZustand == LED_SPIELER_1_GEWAEHLT ){
ZeitDifferenzSpieler1 = aktuelleZeit - startZeit;richtigerTasterWurdeGedrueckt = JA;
}else if (tasterPin == TASTER_SPIELER2 && ledZustand ==
LED_SPIELER_2_GEWAEHLT){
ZeitDifferenzSpieler2 = aktuelleZeit - startZeit;richtigerTasterWurdeGedrueckt = JA;
}}
void Taster1WurdeGedrueckt(){
NimmAuswertungDerTasterVor(TASTER_SPIELER1);}
void Taster2WurdeGedrueckt (){
NimmAuswertungDerTasterVor(TASTER_SPIELER2);}
Listing 10.21 Funktionen zur Auswertung der Taster
10 Die 7-Segment-Anzeige
342
Die Auswertung der Taster selbst gibt nichts zurück, sondern nutzt zum Speichern der
Auswertung die globalen Variablen. Gleichzeitig bekommt die Funktion den Pin des
Tasters übergeben, der gedrückt wurde.
Egal ob es nun der richtige oder der falsche Taster ist, messen wir erst mal die aktuelle
»Uhrzeit«, indem uns die Funktion millis() die Millisekunden nennt, die seit dem letz-
ten Reset vergangen sind.
Anschließend prüfen wir die beiden gültigen Möglichkeiten: Taster und LED von Spieler 1
oder Taster und LED von Spieler 2. Sollte eines der beiden Ereignisse zutreffen (also der
if- oder else if-Zweig wahr sein), so wird die Differenz der Millisekunden berechnet
und entsprechend gespeichert, indem sie entweder zu der Differenz des einen oder des
anderen Spielers hinzugerechnet wird. Wir dürfen auch nicht vergessen, in einem sol-
chen Fall den Wert der Variablen richtigerTasterWurdeGedrueckt auf JA zu setzen, damit
die »Wartefunktion« gegebenenfalls abbrechen kann.
Danach kommen nur noch die beiden direkten Interrupt-Service-Routinen der Taster.
Diese rufen die oben entwickelte Funktion auf, jeweils mit ihrem Taster-Pin als Argu-
ment. Das war die vorletzte Funktion. Jetzt fehlt nur noch eine Funktion, und diese ist
einfach.
Hinweis
Die Funktion millis() gibt keinen int zurück, sondern einen unsigned long. Damit
kann die Funktion einen größeren Wertebereich als int abdecken. Ungefähr nach 10
Tagen fängt millis() wieder an, von vorn zu zählen. Da wir das Spiel aber nur über eine
kurze Dauer spielen wollen, passt der Wert, den millis() zurückgibt, auch in einen nor-
malen int, und wir müssen uns darüber keine Gedanken machen.
Wir müssen nämlich nur noch testen, welcher von beiden Spielern schneller war, und
dies entsprechend auf die Anzeigen setzen:
void WerteDieRundeAus(){
if (ZeitDifferenzSpieler1 < 0 && ZeitDifferenzSpieler2 < 0){
// keiner bekommt einen Punkt; beide waren zu langsam}else if (ZeitDifferenzSpieler1 < 0) // Spieler eins war zu langsam{
punkteSpieler2 += 1;}
10.5 Ihr erstes Spiel für den Arduino
343
else if (ZeitDifferenzSpieler2 < 0) // Spieler zwei war zu langsam{
punkteSpieler1 += 1;}else // keiner war zu langsam{
if (ZeitDifferenzSpieler1 > ZeitDifferenzSpieler2) /* Spieler einswar langsamer */
{punkteSpieler2 += 1;
}else // also war Spieler eins schneller{
punkteSpieler1 += 1;}
}
SchreibeEtwasAnDieRegister(zahlenFuer7SegmentAnzeige[punkteSpieler2],zahlenFuer7SegmentAnzeige[punkteSpieler1]);
}
Listing 10.22 Auswertung, welcher der Spieler für die Runde einen Punkt bekommt
Der Quellcode spricht schon fast von selbst. Für den Fall, dass beide Spieler zu langsam
waren, gibt es keinen Punkt – für keinen der beiden Spieler. Ein Spieler war zu langsam,
wenn der Interrupt nicht während der Wartezeit registriert wurde. Damit verweilt der
Differenzwert also bei -1. Wenn beide nicht zu langsam waren, gibt es immer noch die
Möglichkeit, dass nur ein Spieler zu langsam war. Um das herauszufinden, folgen die
nächsten beiden else if-Verzweigungen. Sollten beide Spieler es geschafft haben, die
LED zu aktivieren, testen wir einfach, ob Spieler 1 langsamer war. Dann erhält entspre-
chend Spieler 2 einen Punkt. Wenn nicht, geht der Punkt der Runde an Spieler 1. Egal wie
es nun ausgegangen ist (deswegen nach den Abfragen), geben wir den Spielstand aus.
Was wir jetzt geschaffen haben, ist ein Haufen aus vielen tollen Funktionen. Das Pro-
blem an ihnen ist nur, dass sie alle für sich zwar etwas können, das große Ganze aber
nicht sehen. Sie sind noch kein Team.
Man kann die Situation mit einem Betrieb vergleichen: Die Funktionen sind Mitarbei-
ter, und nun müssen wir diese nur noch richtig arrangieren, damit sie ein Produkt bzw.
eine Dienstleistung erstellen. Um aus unseren »Mitarbeitern« ein Team zu machen, ver-
wenden wir die loop-Funktion:
10 Die 7-Segment-Anzeige
344
#define AnzahlDerRunden 9#define WARTEZEIT_ZWISCHEN_DEN_RUNDEN 5000 // in Millisekunden
int ersterDurchlauf = JA;
void loop(){
if (ersterDurchlauf == JA){
// Erst einmal die Anzeige auf null setzenSchreibeEtwasAnDieRegister(zahlenFuer7SegmentAnzeige[0],
zahlenFuer7SegmentAnzeige[0]);
// Die LEDs machen sich schon einmal warmdigitalWrite(LED_SPIELER1_PIN, HIGH);digitalWrite(LED_SPIELER2_PIN, HIGH);
// Warte noch eine kurze Zeit, bis das Spiel beginntdelay(WARTEZEIT_ZWISCHEN_DEN_RUNDEN);
// jede Runde ist ein Durchlauf der for-Schleifefor (int i = 0; i < AnzahlDerRunden; i++){
// Setze die Startzeit für die RundestartZeit = millis();
// Beginn der Runde. LEDs wild blinken lassenLEDsWildBlinkenLassen();
/* Der Spieler weiß, dass die Runde begonnen hat.Also warte eine zufällige Zeit */
WarteZufaelligeZeit();// Nun entscheidet der Zufall, welcher Spieler zuerst am Zug istint ersterLEDPin = GibMirDenPinDerNaechstenLED();// Nun muss er die LED sehenLasseLEDKurzAufleuchten(ersterLEDPin);// geben wir ihm Zeit zu reagierenWarteBisTasterGedruecktOderZeitAbgelaufenIst();
/* Nun ist der zweite Spieler am Zug.Wir warten erneut eine zufällige Zeit. */
10.5 Ihr erstes Spiel für den Arduino
345
WarteZufaelligeZeit();// der andere Pin muss nun aufleuchtenint zweiterLEDPin = GibMirDenPinDerNaechstenLED();// resette nun den Wert, ob der richtige Taster gedrückt wurderichtigerTasterWurdeGedrueckt = NEIN;LasseLEDKurzAufleuchten(zweiterLEDPin);/* Nun konnte der andere Spieler seine LED aufblinken sehen.
Nun ist er am Zug. */WarteBisTasterGedruecktOderZeitAbgelaufenIst();
// Die Runde ist entschieden. Nun folgt die Auswertung.WerteDieRundeAus();
// Bereite nun alle Variablen für die nächste Runde vorZeitDifferenzSpieler1 = -1;ZeitDifferenzSpieler2 = -1;ledZustand = NOCH_KEINE_LED_GEWAEHLT;richtigerTasterWurdeGedrueckt = NEIN;
// In der PAUSE sind die LEDs die ganze Zeit andigitalWrite(LED_SPIELER1_PIN, HIGH);digitalWrite(LED_SPIELER2_PIN, HIGH);
// Nun kurze Verschnaufpause bis zur nächsten Rundedelay(WARTEZEIT_ZWISCHEN_DEN_RUNDEN);
digitalWrite(LED_SPIELER1_PIN, HIGH);digitalWrite(LED_SPIELER2_PIN, HIGH);
}
/* Damit das Spiel nicht von vorn beginnt,ist jetzt der erste Durchlauf zu Ende. */
ersterDurchlauf = NEIN;
// ist das Spiel zu Ende, leuchten die LEDs dauerhaftdigitalWrite(LED_SPIELER1_PIN, HIGH);digitalWrite(LED_SPIELER2_PIN, HIGH);
}}
Listing 10.23 Die »loop«-Funktion macht aus dem Haufen der Funktionen ein Team,
das zusammen ein Spiel ergibt.
10 Die 7-Segment-Anzeige
346
Zu dem Listing möchte ich nicht wirklich mehr viel erklären. Das Wichtigste steht in den
Kommentaren.
Zu guter Letzt sehen Sie noch einmal die setup-Funktion, und dann sind wir bereit für
ein erstes Spielchen.
void setup(){
pinMode(DATEN_EINGANG1, OUTPUT);pinMode(DATEN_EINGANG2, OUTPUT);pinMode(SCHIEBE_TAKT, OUTPUT);pinMode(SPEICHER_TAKT, OUTPUT);
pinMode(LED_SPIELER1_PIN, OUTPUT);pinMode(LED_SPIELER2_PIN, OUTPUT);
pinMode(TASTER_SPIELER1, INPUT_PULLUP);pinMode(TASTER_SPIELER2, INPUT_PULLUP);
attachInterrupt(0, ISRTaster1, FALLING); // 0 ist Pin 2attachInterrupt(1, ISRTaster2, FALLING); // 1 ist Pin 3
}
Listing 10.24 Die »setup«-Funktion für das Geschicklichkeitsspiel
Ich verzichte an dieser Stelle darauf, den kompletten Quellcode hier darzustellen. Er
wäre einfach zu lang. Die einzelnen Funktionen haben wir besprochen. Fühlen Sie sich
frei, den Quellcode nach Belieben zu verändern, und kreieren Sie so Ihr eigenes Spiel.
10.6 Zusammenfassung und Ausblick
Na? Das Spiel zu programmieren war doch ganz einfach, nicht wahr? Wenn Sie diese
Frage mit Ja beantworten, gratuliere ich Ihnen, und wahrscheinlich sind Sie überqualifi-
ziert für dieses Buch. Dennoch bedanke ich mich für Ihre Aufmerksamkeit. Wenn Sie die
Frage mit Nein beantworten – und davon gehe ich aus –, ist es total in Ordnung. Ich
wollte mit diesem Kapitel ein klassisches »Midseason-Finale« schaffen, wie es sie
zuhauf in den schönen Fernsehserien aus den USA gibt. Die Spannungskurve (also bei
uns der Anspruch) sollte noch einmal steigen, damit Sie mir als Leser treu bleiben. So
ein Spiel, das war mein Gedanke, hat etwas für sich.
10.6 Zusammenfassung und Ausblick
347
Vor allem wollte ich hier noch einmal zeigen, was Programmieren eigentlich ist. Zum
einen ist es schwer – aber das geht vorüber –, zum anderen erschaffen Sie sich ein Team
(in C sind es Funktionen, in der objektorientierten Programmierung sind es später Klas-
sen und Schnittstellen).
Dieses Team besteht immer aus Spezialisten, die nur eine Sache gut können sollten. Sie
benutzen dieses Team, um damit neue Herausforderungen zu meistern. Sie können
sich sicherlich sehr gut vorstellen, dass man mit der Zeit ein immer größeres Team
bekommt. Dieses Team und Ihre immer besser werdenden Fähigkeiten sorgen dafür,
dass Sie entweder immer größere Dinge entwerfen können oder für ähnliche Dinge
weniger Zeit brauchen. Deswegen kann ich mit »Leichtigkeit« mal eben ein solches Spiel
aufbauen und programmieren.
Unabhängig von der symbolischen Bedeutung dieses Kapitels haben Sie die 7-Segment-
Anzeige kennengelernt und erfahren, wie man ein Schieberegister als einen Seriell-zu-
parallel-Wandler verwenden kann. Gehen Sie einmal durch Ihre Wohnung, und zählen
Sie, wie oft Sie solche Anzeigen finden. Wir werden die Anzeige noch im nächsten Kapi-
tel verwenden, wenn es an das Messen geht. Irgendwo müssen wir unsere Messergeb-
nisse ja darstellen.
Das Fazit dieses Kapitels könnte in etwa so lauten: 7-Segment-Anzeigen sind cool, weil
sie extrem günstig sind und sich leicht ansteuern lassen. Das Problem daran sind nur
die ganzen Widerstände und Kabel. Wie könnten wir es lösen? Man müsste diese Schal-
tung nicht auf einem Steckbrett entwickeln, sondern als richtige Leiterplatte. Damit
würde man sich die gesamte Verdrahtung schenken und müsste nur noch die Steuerlei-
tung zu dem Schieberegister führen.
Zurzeit gibt es noch kein 7-Segment-Shield für den Arduino. Bei einem Shield handelt es
sich um eine Erweiterung des Arduino, die man einfach auf ihn stecken kann. »Hucke-
pack« könnte man dazu auch sagen. So ein Shield könnte fünf solcher Segmente tragen
und würde wohl nur weniger als 5 Euro kosten. Dazu noch eine schöne Bibliothek, und
schon ist das Produkt perfekt. Na, habe ich Sie auf eine Idee gebracht?
Auf einen Blick
Auf einen Blick
1 Ein Streifzug durch die Welt der Prozessoren .................................................... 23
2 Ich stelle vor – der Arduino ....................................................................................... 39
3 Ich packe meinen (Elektronik)-Koffer ................................................................... 57
4 Es werde Licht – die Entwicklungsumgebung und die
Grundlagen von C ........................................................................................................ 101
5 Der Entscheidungshelfer ........................................................................................... 159
6 Nachbau der Frontbeleuchtung von K.I.T.T. aus Knight Rider ..................... 193
7 Wer austeilen kann,
der muss auch einstecken können ........................................................................ 223
8 Timer und Counter ...................................................................................................... 253
9 Wie ein Arduino das Sprechen lernt – serielle Kommunikation ................. 277
10 Die 7-Segment-Anzeige ............................................................................................. 307
11 Der faule (schlaue) Gärtner ...................................................................................... 349
12 Der Gärtner wird jetzt digital .................................................................................. 379
13 Der Gärtner für den Massenmarkt ........................................................................ 409
14 Bin ich schon drin? – Abstandsmessung mit dem Arduino ........................... 431
15 Alles für die Katz’? Beschäftigungstherapie für Stubentiger ....................... 469
16 Der Arduino spricht im Netzwerk .......................................................................... 509
17 Fernsteuerung via Bluetooth ................................................................................... 563
18 Displays – Warum Anzeige nicht gleich Anzeige ist ........................................ 579
19 Aller Anfang war schwer ........................................................................................... 661
5
Inhalt
Inhalt
Programmieren lernen mit dem Arduino ........................................................................................ 15
1
1 Ein Streifzug durch die Welt der Prozessoren 23
1.1 Was ist ein Prozessor und was tut er? ............................................................................ 23
1.2 Verschiedene Arten von Prozessoren ............................................................................. 31
1.2.1 Der General-Purpose-Prozessor – oder: warum mein Rechner
so viel Strom verbraucht ..................................................................................... 31
1.2.2 Der DSP und warum dieser LTE erst möglich macht ................................. 32
1.2.3 Der Microcontroller als »Steuertier« der Familie ........................................ 33
1.2.4 Ein System – ein Chip ........................................................................................... 36
1.3 Zusammenfassung ................................................................................................................. 37
2
2 Ich stelle vor – der Arduino 39
2.1 Aufbau des Arduino ................................................................................................................ 39
2.2 Ein Microcontroller für jeden ............................................................................................. 42
2.3 Wer die Wahl hat, hat die Qual – die Modelle des Arduino ................................. 43
2.3.1 Ardunio Uno ............................................................................................................ 43
2.3.2 Arduino Leonardo .................................................................................................. 44
2.3.3 Arduino Mega 2560 .............................................................................................. 45
2.3.4 Arduino Due ............................................................................................................ 46
2.3.5 Arduino Mega ADK ................................................................................................ 46
2.3.6 Arduino Nano .......................................................................................................... 47
2.3.7 Arduino LilyPad ....................................................................................................... 47
2.3.8 Weitere Varianten ................................................................................................. 48
2.3.9 Andere Hersteller ................................................................................................... 48
2.3.10 Auswahlhilfe ........................................................................................................... 48
2.4 Installation der Software und Anschließen des Arduino ....................................... 50
Inhalt
6
3
3 Ich packe meinen (Elektronik)-Koffer 57
3.1 Ladung, Spannung, Strom – Willkommen in der E-Technik ................................. 57
3.2 Die drei Freunde in der Elektronik: Das ohmsche Gesetz,
der Maschen- und der Knotensatz ................................................................................... 59
3.2.1 Schaltpläne .............................................................................................................. 63
3.2.2 Strom und Spannung berechnen ..................................................................... 64
3.2.3 Ein Beispiel mit dem Arduino ............................................................................ 68
3.2.4 Allgemeine Hinweise zum Berechnen von Schaltungen ......................... 72
3.3 Widerstand ist nicht immer zwecklos ............................................................................ 72
3.3.1 Aufs Material kommt es an ... ............................................................................ 72
3.3.2 ... und auf den Querschnitt ................................................................................. 74
3.3.3 Bauformen von Widerständen ......................................................................... 77
3.3.4 Bauweisen: THT vs. SMD ..................................................................................... 79
3.4 Reihen- und Parallelschaltung ........................................................................................... 80
3.5 Bauteile der Elektronik ......................................................................................................... 84
3.5.1 Der Kondensator .................................................................................................... 84
3.5.2 Die Spule ................................................................................................................... 86
3.5.3 Die Diode .................................................................................................................. 87
3.5.4 Die Leuchtdiode ..................................................................................................... 88
3.6 Rechnen ist gut, simulieren ist aber auch nicht verkehrt –
Einführung in Spice ................................................................................................................. 90
3.7 Was kommt denn nun wirklich in den Koffer? .......................................................... 97
3.8 Zusammenfassung ................................................................................................................. 98
101
4 Es werde Licht – die Entwicklungsumgebung und die Grundlagen von C 101
4.1 Verdrahten für Fortgeschrittene – vom Schaltplan zur Schaltung ................... 102
4.1.1 Vorwiderstände bestimmen .............................................................................. 102
4.1.2 Vom Schaltplan zur Schaltung .......................................................................... 103
4.1.3 Das Steckbrett (Breadboard) .............................................................................. 105
4.1.4 Die Verdrahtung .................................................................................................... 106
4.2 Eine kurze Geschichte der Programmiersprachen .................................................... 109
4.3 Die Arduino-IDE ........................................................................................................................ 110
Inhalt
7
4.4 Aufbau eines Programms für den Arduino .................................................................. 114
4.4.1 Ein erster Sketch .................................................................................................... 116
4.4.2 Blinken im Farbwechsel ...................................................................................... 119
4.5 Den Sketch »hübscher« machen ...................................................................................... 121
4.5.1 #define ...................................................................................................................... 121
4.5.2 Variablen verwenden ........................................................................................... 124
4.6 Ein bisschen Dynamik schadet nie .................................................................................. 127
4.6.1 Lebenszeit, Sichtbarkeit und Blöcke ................................................................ 130
4.6.2 Abfragen und Schleifen ....................................................................................... 131
4.7 Morsen mit dem Arduino .................................................................................................... 135
4.7.1 Arrays ......................................................................................................................... 136
4.7.2 Die »for«-Schleife .................................................................................................. 138
4.7.3 Die Größe von Arrays: »sizeof« ermitteln ..................................................... 145
4.7.4 Anwendung und Ausblick .................................................................................. 147
4.8 Zusammenfassung ................................................................................................................. 147
4.9 C – Ultrakurz-Zusammenfassung der Syntax ............................................................. 149
4.9.1 Variablen .................................................................................................................. 149
4.9.2 Datentypen .............................................................................................................. 149
4.9.3 Gruppieren von Daten ......................................................................................... 151
4.9.4 Funktion ................................................................................................................... 152
4.9.5 Operatoren .............................................................................................................. 153
4.9.6 Kontrollstrukturen ................................................................................................ 155
5
5 Der Entscheidungshelfer 159
5.1 Die Sache mit dem Zufall ..................................................................................................... 159
5.1.1 Pseudo-Zufallszahlengeneratoren .................................................................. 161
5.1.2 Echte Zufallszahlen .............................................................................................. 167
5.2 Aufbau der Schaltung ............................................................................................................ 167
5.3 Ran an die Steuerung ............................................................................................................ 168
5.3.1 Das Blinken dynamischer gestalten ................................................................ 177
5.4 Jetzt neu: Der Entscheidungshelfer auch mit mehr Möglichkeiten ................. 182
5.4.1 Noch ein winziges Problem ............................................................................... 187
5.5 Zusammenfassung und Ausblick ..................................................................................... 192
Inhalt
8
193
6 Nachbau der Frontbeleuchtung von K.I.T.T. aus Knight Rider 193
6.1 Aufbau der Schaltung ............................................................................................................ 193
6.2 Aus »Licht an und aus« wird hell und dunkel –
Grundlagen der Pulsweitenmodulation (PWM) ........................................................ 195
6.3 Dimmen für Anfänger ........................................................................................................... 200
6.4 Das Lauflicht .............................................................................................................................. 208
6.4.1 Einmal vor und einmal zurück ........................................................................... 211
6.4.2 Ein Lauflicht mit unterschiedlicher Leuchtstärke ....................................... 215
6.5 Zusammenfassung und Ausblick ..................................................................................... 220
7
7 Wer austeilen kann, der muss auch einstecken können 223
7.1 Pull-up-Widerstand ................................................................................................................ 223
7.2 Polling vs. Interrupt ................................................................................................................ 226
7.2.1 Polling ........................................................................................................................ 226
7.2.2 Interrupts ................................................................................................................. 227
7.3 Licht an, Licht aus – jetzt neu mit Taster ...................................................................... 232
7.3.1 Licht ein bisschen an – Licht ein bisschen aus ............................................. 234
7.3.2 Das Licht dimmen .................................................................................................. 238
7.4 Das Licht im Hausflur ............................................................................................................. 246
7.5 Zusammenfassung und Ausblick ..................................................................................... 251
8
8 Timer und Counter 253
8.1 Timer bzw. Counter – was dahintersteckt ................................................................... 253
8.1.1 Grundlagen: Das Binärsystem .......................................................................... 254
8.1.2 Zeitspanne berechnen ......................................................................................... 257
8.2 Aufbau der Schaltung ............................................................................................................ 258
8.3 Ein sekundengenaues Pulsieren ....................................................................................... 258
Inhalt
9
8.4 Der »Geekdown« – der etwas andere Countdown .................................................. 267
8.5 Zusammenfassung und Ausblick ..................................................................................... 275
277
9 Wie ein Arduino das Sprechen lernt – serielle Kommunikation 277
9.1 Grundlagen der Kommunikation ..................................................................................... 278
9.1.1 Serielle Ports auf dem Arduino ......................................................................... 284
9.2 Aufbau der Schaltung und weitere Vorbereitungen ............................................... 284
9.2.1 Die Variante mit dem Converter ...................................................................... 286
9.2.2 Tera Term installieren .......................................................................................... 287
9.2.3 Pins am Converter ................................................................................................. 289
9.3 »Nummer 5 lebt und spricht« – der Arduino lernt das Sprechen ...................... 289
9.3.1 Das Programm im Detail .................................................................................... 295
9.4 Der Arduino empfängt Daten ............................................................................................ 298
9.4.1 Programmieren des steuerenden Arduino ................................................... 303
9.5 Zusammenfassung und Ausblick ..................................................................................... 305
10
10 Die 7-Segment-Anzeige 307
10.1 Die 7-Segment-Anzeige näher betrachtet ................................................................... 308
10.2 Schaltung für den Countdown .......................................................................................... 313
10.3 Der Countdown ........................................................................................................................ 320
10.4 Den Countdown spannender machen ........................................................................... 325
10.5 Ihr erstes Spiel für den Arduino ........................................................................................ 333
10.6 Zusammenfassung und Ausblick ..................................................................................... 346
11
11 Der faule (schlaue) Gärtner 349
11.1 Grundbegriffe rund um das Thema »messen« .......................................................... 349
11.2 Was ist Temperatur, und warum hat sie so viele Kelvins? ................................... 351
Inhalt
10
11.3 Die analoge Welt vs. die digitale Welt ........................................................................... 353
11.4 Einfache Messschaltung ....................................................................................................... 356
11.5 Aufbau der Messschaltung ................................................................................................. 360
11.6 Der Arduino misst die Temperatur .................................................................................. 362
11.6.1 Eine Bibliothek erstellen ...................................................................................... 369
11.7 Zusammenfassung und Ausblick ..................................................................................... 377
12
12 Der Gärtner wird jetzt digital 379
12.1 Die verschiedenen Topologien .......................................................................................... 379
12.2 I²C .................................................................................................................................................... 383
12.3 Datenpakte und Register für das Thermometer TC74 ............................................ 386
12.4 Aufbau der Schaltung ............................................................................................................ 388
12.5 Ihr erstes digitales Thermometer ..................................................................................... 391
12.5.1 Der stromsparende digitale Gärtner ............................................................... 400
12.6 Zusammenfassung und Ausblick ..................................................................................... 407
13
13 Der Gärtner für den Massenmarkt 409
13.1 Wie kann Feuchtigkeit gemessen werden? ................................................................. 409
13.2 Der DHT11 im Detail ................................................................................................................ 411
13.3 Aufbau der Schaltung ............................................................................................................ 414
13.4 Der bezahlbare Gärtner entsteht ..................................................................................... 416
13.5 Zusammenfassung und Ausblick ..................................................................................... 429
14
14 Bin ich schon drin? – Abstandsmessung mit dem Arduino 431
14.1 Verfahren für die Abstandsmessung .............................................................................. 431
14.1.1 Wellen ....................................................................................................................... 432
14.1.2 Reflexion ................................................................................................................... 435
14.1.3 Triangulation .......................................................................................................... 436
Inhalt
11
14.2 Die Sensoren im Detail .......................................................................................................... 439
14.2.1 Die Pulslänge für den Ultraschallsensor bestimmen ................................ 439
14.2.2 Bestimmen des Pegels für den Infrarotsensor ............................................ 440
14.3 Aufbau der Schaltung ............................................................................................................ 443
14.4 Die Einparkhilfe entsteht ..................................................................................................... 445
14.4.1 Ultraschall-Sensor ................................................................................................. 445
14.4.2 Messung mit dem Infrarotsensor .................................................................... 450
14.4.3 Sensoren im Vergleich ......................................................................................... 451
14.4.4 Die Einparkhilfe ...................................................................................................... 452
14.5 Deine eigene Horrorfilm-Beleuchtung .......................................................................... 455
14.5.1 Erst wenn es flackert, ist es wirklich ein Horrorfilm .................................. 460
14.6 Zusammenfassung und Ausblick ..................................................................................... 467
15
15 Alles für die Katz’? Beschäftigungstherapie für Stubentiger 469
15.1 Wenn sich etwas bewegt, dann ist es bestimmt ein Motor ................................ 470
15.1.1 Das Funktionsprinzip von Gleichstrommotoren ........................................ 470
15.1.2 Arten von Gleichstrommotoren ....................................................................... 471
15.1.3 Die H-Brücke ........................................................................................................... 472
15.2 Aufbau des Gehäuses für das Katzenspielzeug ......................................................... 473
15.3 Aufbau der Schaltung ............................................................................................................ 483
15.4 Die Motoren leben! ................................................................................................................ 488
15.4.1 Der Servomotor lebt ............................................................................................. 488
15.4.2 Das Katzenspielzeug lebt ................................................................................... 491
15.5 Licht aus, Bewegung an ........................................................................................................ 500
15.6 Zusammenfassung und Ausblick ..................................................................................... 507
16
16 Der Arduino spricht im Netzwerk 509
16.1 Arduino goes Transformer – die Arduino Shields ..................................................... 509
16.1.1 Das Motor Shield ................................................................................................... 510
16.1.2 Das USB Host Shield ............................................................................................. 511
16.1.3 Das WiFi Shield ....................................................................................................... 512
Inhalt
12
16.1.4 Das GSM Shield ...................................................................................................... 512
16.1.5 Weitere Shields ...................................................................................................... 513
16.2 Was ich schon immer über Ethernet erzählen wollte ............................................. 513
16.2.1 Das Schichtenmodell der Kommunikation ................................................... 514
16.2.2 Protokolle ................................................................................................................. 516
16.2.3 TCP/IP ........................................................................................................................ 519
16.2.4 Eine Adresse für Ihren Arduino ......................................................................... 520
16.2.5 Der Physical Layer und der Data Link Layer ................................................... 521
16.2.6 Zusammenfassung ............................................................................................... 521
16.2.7 Ausblick ..................................................................................................................... 522
16.3 Das Client-Server-Modell ..................................................................................................... 522
16.4 Das Prinzip einer Fernbedienung – Entwicklung eines
eigenen Protokolls .................................................................................................................. 523
16.5 Schaltungsaufbau ................................................................................................................... 527
16.6 Die Fernsteuerung entsteht ................................................................................................ 531
16.6.1 Befehle verstehen und reagieren ..................................................................... 536
16.6.2 Abfragen verstehen und antworten ............................................................... 543
16.6.3 Programme zur Fernsteuerung ......................................................................... 547
16.7 Der Pflanz-Versorgungs-O-Mat sendet eine E-Mail ................................................. 547
16.7.1 Der Sketch entsteht .............................................................................................. 551
16.8 Zusammenfassung und Ausblick ..................................................................................... 560
17
17 Fernsteuerung via Bluetooth 563
17.1 Das Für und Wider der Funkkommunikation ............................................................. 563
17.2 Das Ding vom blauen Zahn ................................................................................................. 564
17.3 Aufbau der Schaltung ............................................................................................................ 565
17.4 Verändern der Bluetooth-Eigenschaften ...................................................................... 568
17.5 Die Fernsteuerung entwickeln .......................................................................................... 571
17.6 Fernsteuerung via App .......................................................................................................... 577
17.7 Zusammenfassung und Ausblick ..................................................................................... 578
Inhalt
13
18
18 Displays – Warum Anzeige nicht gleich Anzeige ist 579
18.1 LCD und das LCD Keypad Shield ........................................................................................ 579
18.1.1 Die Physik hinter LCD ........................................................................................... 579
18.1.2 LCD-Displays für Bastler ...................................................................................... 581
18.2 Die Tasten auswerten ............................................................................................................ 585
18.3 Laufschrift ................................................................................................................................... 591
18.3.1 Eine Laufschrift für die Kirmes .......................................................................... 595
18.4 Reaktionszeitmesser .............................................................................................................. 597
18.4.1 Eine Highscore-Tabelle für den Reaktionsmesser ...................................... 610
18.5 Der Arduino wird zum Spielautomaten ........................................................................ 625
18.6 Zusammenfassung ................................................................................................................. 659
19
19 Aller Anfang war schwer 661
19.1 Hilfe, mein Herd verschickt Spam! – Heimautomatisierung
mit dem Arduino ..................................................................................................................... 661
19.2 Und nun zum Schluss ............................................................................................................ 662
Index ............................................................................................................................................................ 663
Index
663
Index
!= (Verschieden-Operator) ................................... 146
.fzz-Datei ..................................................................... 107
.NET Framework ....................................................... 110
& (bitweises UND) ................................................... 188
&& (logisches UND) ................................................ 187
#define ......................................................................... 122
#define � Präprozessor-Direktive
% (Modulo-Operator) ............................................. 174
== (Gleichheitsoperator) ....................................... 146
=-Zeichen ..................................................................... 129
| (bitweises ODER) .................................................... 188
|| (logisches ODER) ................................................... 187
74HC595 � Schieberegister
7-Segment-Anzeige ................................................. 307
Fehlersuche ............................................................ 325
Schaltung ............................................................... 313
Übersicht ................................................................ 308
A
Abfrage ......................................................................... 131
Abisolierungszange ................................................ 476
Absoluter Nullpunkt � Temperatur
Abtasten ...................................................................... 354
ACK � Acknowledgment
Acknowledgment (ACK) ........................................ 385
Adressbus ..................................................................... 27
Adresswerk ................................................................... 28
Aktor ............................................................................. 469
ALU � Arithmetische logische Einheit
Amperesekunde ......................................................... 58
Amplitudenmodulation ....................................... 283
analog ............................................................................. 41
Analog-Digital-Umsetzer
Abtastrate .............................................................. 356
Genauigkeit ........................................................... 356
Kanäle ..................................................................... 356
Quantisierungsstufe .......................................... 356
Analog-Digital-Wandler .......................................... 40
Analoges Signal ........................................................ 353
analogWrite() ............................................................. 199
Android .......................................................................... 46
Anker (Motor) ............................................................ 471
Anode .................................................................... 88, 309
Anschlussleiste ............................................................ 41
Anzeige ........................................................................ 579
Arbeitsspeicher ........................................................... 40
Arbitrierung (zufällige) ......................................... 382
Arbitrierungsverfahren
(nichtdeterministisches) ................................. 382
Arduino
Aufbau .................................................................... 114
Datenempfang ..................................................... 298
Display .................................................................... 307
Erweiterungen ...................................................... 509
I²C .............................................................................. 379
Installation ............................................................... 50
Interrupts nutzen ................................................ 228
Kaufempfehlung .................................................... 97
offzielle Projektseite ............................................. 43
Pins ........................................................................... 229
serielle Kommunikation .................................. 277
serielle Ports .......................................................... 284
Treiber ........................................................................ 54
Uno .............................................................................. 39
Vergleich der Modelle .......................................... 49
Zubehör ..................................................................... 17
Arduino Uno
Kenndaten ................................................................ 40
Arduino-IDE ............................................................... 111
Arduino-Modell wählen ................................... 113
Benutzeroberfläche ............................................ 112
Editor ....................................................................... 112
Port ändern ........................................................... 112
Programm auf Arduino laden ....................... 112
Programm kompilieren .................................... 112
Serial Monitor ...................................................... 112
Speicherverbrauch anzeigen .......................... 112
Argument ................................................................... 117
Arithmetische logische Einheit ............................ 27
ARM Cortex .................................................................. 37
Array ....................................... 136, 152, 182, 208, 329
erzeugen ................................................................. 137
Größe ermitteln ................................................... 145
Länge ....................................................................... 145
Syntax ..................................................................... 136
Array � sizeof
ASCII ............................................................................. 281
Index
664
Assembler ................................................................... 109
ATmega32 ..................................................................... 40
Atmel .............................................................................. 40
B
Baudrate ................................................... 282, 289, 294
Bauelement
aktives ........................................................................ 65
passives ...................................................................... 65
Bauteile
Diode ........................................................................... 87
Halbleiterelement .................................................. 87
Kondensator ............................................................ 84
Leuchtdiode .............................................................. 88
Spule ............................................................................ 86
Befehl .............................................................................. 25
Befehlszähler ............................................................... 28
Betrag (mathematisch) .......................................... 174
Bibliothek � Library
Binärsystem .................................. 165, 254, 269, 398
Bitrate ........................................................................... 283
Blackbox-Modell ........................................................ 23
Block .............................................................................. 130
Bluetooth
Fernsteuerung ...................................................... 563
Funktionsweise .................................................... 565
Modul HC-06 ......................................................... 566
Profil ......................................................................... 565
Bluetooth-Eigenschaften ändern ...................... 568
Bluetooth-Modul (HC-06) ..................................... 566
Board ............................................................................... 40
BoostCap ....................................................................... 85
Breadboard � Steckbrett
Breakout ........................................................................ 49
Bus ....................................................................... 379, 382
Arbitrierung .......................................................... 379
Definition ............................................................... 379
synchroner ............................................................. 383
Bus-Topologie ........................................................... 379
C
C (Programmiersprache) ......... 101, 109, 187, 192
#ifndef ..................................................................... 372
#include .................................................................. 372
Array ..................................................... 136, 152, 296ASCII ......................................................................... 281Blöcke ...................................................................... 130Daten gruppieren ............................................... 151Datentypen ........................................................... 149Funktionen ............................................................ 152Ganzzahl ................................................................ 149Gleitkommazahl ................................................. 150if und else ............................................................... 155Kontrollstrukturen ............................................. 155Lebenszeit .............................................................. 130mehrdimensionales Array .............................. 329Operatoren ............................................................ 153Schleife .................................................................... 138Schleifen ................................................................. 157Sichtbarkeit ........................................................... 130sizeof ........................................................................ 145static ........................................................................ 370String-Terminierer .............................................. 292Struct ....................................................................... 151Switch-case ............................................................ 156Syntax ..................................................................... 149Typen ....................................................................... 124Überladung ........................................................... 296Variablen ...................................................... 124, 149Wahr und Falsch ................................................. 133Zeichen .................................................................... 150Zeichenkette ......................................................... 296Zeichenketten ....................................................... 150Zeiger ....................................................................... 151
C++ ................................................................................. 110CamelCase-Schreibweise ...................................... 126Carriage Return ........................................................ 551cases � switch-caseCentral Processing Unit � CPUClient � Client-Server-ModellClient-Server-Modell .............................................. 522Compiler ..................................................................... 109Coulomb ........................................................................ 58Counter � ZählerCPU ................................................................................... 31
Taktfrequenz ........................................................ 258Cursor ........................................................................... 588
D
Data Link Layer ......................................................... 521Daten ............................................................................... 25
Index
665
an Arduino senden ............................................. 112
von Arduino empfangen .................................. 112
Datenblatt ..................................................................... 21
Datenbus ....................................................................... 27
Datenleitung .............................................................. 383
Datentyp ..................................................................... 124
byte ........................................................................... 532
casten ....................................................................... 425
char .................................................................. 125, 532
float ................................................................. 125, 363
int ..................................................................... 125, 496
long ........................................................................... 496
Datentypen
Ganzzahl ................................................................ 149
Gleitkommazahl ................................................. 150
unsigned ................................................................. 125
Zeichen .................................................................... 150
Zeichenketten ....................................................... 150
Zeiger ....................................................................... 151
Datenübertragung
Ablauf ...................................................................... 383
asynchron .............................................................. 278
seriell ........................................................................ 280
synchron ................................................................. 278
Debugging ........................................................ 277, 325
default � switch-case
Dekrement � Inkrement
delay .................................................................... 118, 258
delay() ........................................................................... 199
delayMicroseconds() .............................................. 199
deterministisch ........................................................ 160
D-Flip-Flop .................................................................. 163
DHT11 (Sensor) ......................................................... 411
Dielektrikum ............................................................. 410
Dielektrizität .............................................................. 410
digital .............................................................................. 41
Digitaler Signalprozessor ....................................... 32
Digitales Signal ......................................................... 355
Digitaltechnik ........................................................... 162
digitalWrite ................................................................ 117
Dimmen ...................................................................... 200
Dimmer .................................................... 235, 238, 455
Diode ..................................................................... 87, 119
Pol ................................................................................ 88
Display ............................................................... 307, 579
double .......................................................................... 125
Drahtbrücke ............................................................... 106
Drosselspulen � Spule
DSP � Digitaler Signalprozessor
DSP-Befehl ..................................................................... 32
duale Zahl ................................................................... 165
Durchsteckmontage .................................................. 79
Dynamik � Sensor
E
Echte Zufallszahl ...................................................... 167
EEPROM ......................................................................... 36
Einheit � Messen
Electrically Erasable Programmable Read-Only
Memory � EEPROM
Elektrische Leistung ............................................... 195
Elektron .......................................................................... 72
Elektrophysik ............................................................... 58
Elektrotechnik
Arduino ...................................................................... 68
Batterie ...................................................................... 64
Bauteile ...................................................................... 84
Einheiten ................................................................... 62
Grundlagen .............................................................. 57
Idiotendreieck ......................................................... 61
Impedanz ............................................................... 410
Induktivität .............................................................. 86
Interrupt ................................................................. 223
kirchhoffschen Regeln ......................................... 99
Knotensatz ................................................. 62, 67, 71
Kommunikation ................................................. 278
Ladung ....................................................................... 57
Ladungsmenge ....................................................... 58
Leistung .................................................................. 195
Leiter ........................................................................ 353
Maschensatz .............................................. 62, 66, 70
Masse ....................................................................... 225
Material ..................................................................... 72
messen .................................................................... 349
Offset ....................................................................... 351
ohmsches Gesetz .................................................... 64
Parallelschaltung ................................................... 80
Periodendauer ..................................................... 197
Polling ..................................................................... 223
Reihen- und Parallelschaltung ......................... 80
Reihenschaltung .................................................... 81
Schaltplan ....................................................... 63, 102
Sensor ...................................................................... 350
Index
666
Spannung .................................................... 58, 60, 64
Spannungspuls .................................................... 197
Spannungsteiler .................................................. 359
Stromfluss ................................................................. 65
Stromstärke ....................................................... 59, 60
Wandler .................................................................. 350
Widerstand ................................................. 61, 72, 90
Zusammenfassung ................................................ 98
Endlosschleife ........................................................... 171
Entprellen ................................................................... 495
Entscheidung ............................................................ 131
Entwicklungsumgebung .............. 43, 51, 101, 110
Benutzeroberfläche ............................................ 112
integrierte .............................................................. 111
Serial Monitor ...................................................... 293
Enumeration ............................................................. 122
Ethernet ....................................................................... 521
Grundlagen ........................................................... 513
Eventing ...................................................................... 227
exklusives ODER ...................................................... 163
Exklusiv-ODER .......................................................... 163
Exponentialfunktion ............................................. 180
F
Fahrraddynamo ....................................................... 470
Fehlercode .................................................................. 121
Feld (Array) ................................................................. 136
Feld (magnetisches) ................................................ 471
Fernbedienung ......................................................... 523
Feuchtigkeitsampel ................................................ 409
Flächeninhalt ............................................................ 196
Flanke ........................................................................... 228
Flash-Speicher ...................................................... 35, 40
Fließkommazahlen ................................................. 363
float ............................................................................... 125
Flüssigkristallanzeige � LCD
Flussspannung ............................................................ 88
for-Schleife ................................................................. 138
Fritzing ............................................................... 107, 194
Funksteckdose .......................................................... 513
Funktion ............................................................ 114, 152
analogRead ........................................................... 362
analogWrite() ....................................................... 199
Argument ............................................................... 117
Aufruf ....................................................................... 117
delay ......................................................................... 118
delay() ...................................................................... 199
delayMicroseconds() ......................................... 199
digitalWrite ........................................................... 117
lineare ..................................................................... 178
pinMode ................................................................. 117
quadratische ......................................................... 180
Funktionen ....................................................... 248, 276
delay ............................................................... 259, 416
loop .......................................................................... 114
map() ....................................................................... 459
pow ........................................................................... 271
setup ........................................................................ 114
void ........................................................................... 248
Funktionseinheit ........................................................ 25
Funktionszeiger ....................................................... 249
G
Galois-Feld .................................................................. 162
Gateway ....................................................................... 520
General-Purpose-Prozessor ................................... 31
Generator ................................................................... 470
Gleichheitsoperator ............................................... 146
Gleichheitszeichen ................................................. 129
Gleichspannung (glätten) ....................................... 85
Gleichstrommotor ......................................... 469, 470
Drehrichtung umkehren .................................. 472
Funktionsweise .................................................... 470
Typen ....................................................................... 471
GND � Masse
GPU .................................................................................. 37
Grafikeinheit ................................................................ 37
Ground ........................................................................ 104
Ground � Masse
GSM ...................................................................... 512, 564
GSM Shield ................................................................. 512
H
Halbleiter .................................................................... 353
Halbleiterelement ...................................................... 87
Temperaturabhängigkeit ................................... 90
Handshake ................................................................. 385
Hardware
Aufbau ....................................................................... 39
Hardware-Schnittstelle ............................................ 35
Hardware-Timer ......................................................... 40
Index
667
H-Brücke ............................................................ 469, 472
HIGH ................................................................... 117, 173
High Impedance ....................................................... 311
HIGH-Pegel ................................................................. 384
Hitachi HD44780 ..................................................... 581
Hochsprachen � Compiler
Höchstwertiges Bit � MSB
H-Schaltung � H-Brücke
HTTP ............................................................................. 516
Hygrometer ............................................................... 409
I
I/O-Pins .......................................................................... 41
I²C ......................................................................... 379, 383
Adressen scannen ............................................... 395
I²C-Bus .......................................................................... 379
I2C .................................................................................... 40
IC ..................................................................................... 383
IDE � Entwicklungsumgebung
IEEE 802.15.4 .............................................................. 521
if … else ......................................................................... 132
Induktive Last ........................................................... 473
Induktivität .................................................................. 86
Infrarotsensor ........................................................... 440
Inkrement ......................................................... 139, 142
INPUT � pinMode
Input/Output-Pin ...................................................... 40
Installation ................................................................... 50
int ................................................................................... 125
Integral ......................................................................... 196
Integrated Circuit � IC
Integrated Development Environment ......... 111
Interface ........................................................................ 35
Inter-Integrated Circuit � I²C
Internet of Things .................................................... 509
Interrupt ........ 34, 35, 223, 226, 227, 247, 249, 265
Interrupt Service Routine .................................... 295
Interrupt Service Routine (ISR) ................ 248, 251
ipconfig ........................................................................ 520
IP-Einstellungen ....................................................... 520
IPv4-Adresse .............................................................. 520
J
Java ................................................................................ 110
K
K.I.T.T. ........................................................................... 193
Kaltleiter ..................................................................... 352
Kapazität ..................................................................... 410
Kaskadieren ............................................................... 313
Kathode ................................................................ 88, 309
Kaufempfehlung ........................................................ 97
Kernel ........................................................................... 110
Kirchhoffsche Regeln ................................................ 62
Klemmverhalten ........................................................ 81
Knight Rider .............................................................. 193
Knotensatz ............................................................. 62, 67
Kommentar ............................................................... 116
Kommunikation
Client-Server-Modell .......................................... 522
OneWire .................................................................. 411
Peer-to-Peer-Modell ........................................... 522
Schichtenmodell .................................................. 514
Kommutator ............................................................. 471
Kondensator
Aufbau .................................................................... 410
Kapazität ........................................................ 84, 410
Plattenkondensator .............................................. 84
Spannungsverlauf .............................................. 179
Stützkondensatoren ............................................. 85
Konstruktor ............................................................... 533
Kontrollstrukturen ................................................. 155
L
L293DNE ..................................................................... 473
Ladung ............................................................................ 57
Last (induktive) ........................................................ 473
Lauflicht ...................................................................... 208
Laufschrift erzeugen .............................................. 591
LCD ................................................................................ 579
LCD Keypad Shield .................................................. 579
LCDKeypad.h ............................................................. 587
Lebenszeit ................................................................... 130
LED � Leuchtdiode
Leistung
elektrische .............................................................. 195
Leiter
elektrischer ............................................................... 72
Leitwert .......................................................................... 76
Index
668
Leuchtdiode ................................................................. 88
7-Segment-Anzeige ............................................ 307
Bauform ..................................................................... 89
dimmen ................................................................... 200
Flussspannungen im Überblick ........................ 89
Library .......................................................................... 369
Header ..................................................................... 369
Library � Funktionen
Licht
polarisiertes .......................................................... 581
Linefeed ....................................................................... 551
Linux ............................................................................. 110
Liquid Crystal Display � LCD
LiquidCrystal.h ......................................................... 587
Litze ............................................................................... 475
Logik
Binärsystem .......................................................... 254
bitweises ODER .................................................... 421
bitweises UND ...................................................... 425
exklusives ODER .................................................. 163
Logisches UND ..................................................... 340
logisches UND ................................... 162, 187, 269
Operatoren ............................................................ 424
Logisches UND .......................................................... 269
loop-Funktion ........................................ 114, 116, 535
Lorentzkraft ............................................................... 471
LOW ..................................................................... 117, 173
LOW-Pegel .................................................................. 384
LSB ................................................................................. 254
LTE-Modem .................................................................. 32
LTspice ........................................................................... 91
Bedienung ................................................................. 92
Luftfeuchte
messen ..................................................................... 409
relative .................................................................... 409
M
Magic Number .......................................................... 121
Magnetfeld ................................................................. 471
Main-Funktion .......................................................... 114
Maker .............................................................................. 17
Maschensatz ......................................................... 62, 66
Maschinensprache .................................................. 109
Masse .................................................. 41, 106, 107, 225
Master-Slave-Verfahren � Bus
Messen ................................................................ 349, 409Skalierung .............................................................. 351Temperatur ........................................................... 351
Microcontroller .................................................... 33, 42Aufbau ....................................................................... 34Aufgabe ..................................................................... 33Ein- und Ausgang .................................................. 35Takt ............................................................................. 35
Microcontroller-Plattform ..................................... 39Modelle
Arduino Due ............................................................ 46Arduino Leonardo ................................................. 44Arduino LilyPad ..................................................... 47Arduino Mega 2560 .............................................. 45Arduino Mega ADK ............................................... 46Arduino Nano ......................................................... 47Ardunio Uno ............................................................ 43Übersicht ............................................................ 43, 48
Modulation ................................................................ 197Amplitude .............................................................. 283
Modulo ........................................................................ 174Morsen .................................................................. 18, 135Motor .................................................................... 86, 469
Definition ............................................................... 470Drehrichtung umkehren .................................. 497
Motor Shield .............................................................. 510Motorsteuerung ...................................................... 472MSB ............................................................................... 254MSB-First .................................................................... 414
N
NetzwerkClient-Server-Modell .......................................... 522Data Link Layer ................................................... 521Ethernet .................................................................. 513IP-Einstellungen ermitteln .............................. 520OSI-Modell ............................................................. 514Physical Layer ...................................................... 521Protokoll ................................................................. 516SMTP ........................................................................ 547Standardgateway ............................................... 520TCP/IP ...................................................................... 519WLAN ....................................................................... 563
Netzwerk � TopologieNiedrigstwertiges Bit � LSBNTC ................................................................................ 353Null aktiv .................................................................... 311
Index
669
O
Objektorientierung ................................................. 110
ohmsches Gesetz ....................................................... 64
OLED ............................................................................. 581
OneWire ...................................................................... 411
Open Accessory Development Kit (ADK) ......... 46
Open Source ................................................................. 43
Open System Interconnect � OSI-Modell
Operation (logische) ................................................. 27
Operatoren ................................................................. 153
OSI-Modell ........................................................ 514, 565
Oszillator ....................................................................... 35
Oszilloskop ....................................................... 278, 383
OUTPUT � pinMode
Overflow ...................................................................... 255
P
PAN � Personal Area Network
Parallelschaltung ....................................................... 80
Parität ........................................................................... 280
Peer-to-Peer-Modell ............................................... 522
Pegel
HIGH ........................................................................ 384
LOW .......................................................................... 384
Periodendauer .......................................................... 197
Personal Area Network .......................................... 565
Physical Layer ........................................................... 521
Pin
+5-V-Pin .................................................................. 229
auslesen .................................................................. 223
Converter ................................................................ 289
INPUT_PULLUP .................................................... 291
pinMode ............................................................ 116, 117
INPUT ....................................................................... 117
OUTPUT .................................................................. 117
Pins .................................................................................. 41
Platine ............................................................................ 40
Plattenkondensator .................................................. 84
Polarisation ................................................................ 580
zirkulare .................................................................. 580
Polarisationsfilter .................................................... 581
Polarisationszustand � Polarisation
Polling ............................................. 223, 226, 227, 251
Polung ............................................................................ 88
Präprozessor .............................................................. 122
Präprozessor-Direktive ................................ 121, 122
Prellen .......................................................................... 238
Prescaler � Zähler:Vorteiler
Programm
auf Arduino laden .............................................. 112
Sketch ...................................................................... 115
Programmiersprache
C ................................................................................. 109
C++ ............................................................................ 110
Funktion ................................................................. 114
Java ........................................................................... 110
objektorientierte ................................................. 110
Proportionalität .......................................................... 60
umgekehrte .............................................................. 74
Protokoll .............................................................. 33, 516
Grundlagen ........................................................... 516
Prozessor
Aufbau ................................................................ 23, 25
digitaler Signalprozessor .................................... 32
Funktionsweise ....................................................... 23
General Purpose ..................................................... 31
interne Steuerung .................................................. 27
schematischer Aufbau ......................................... 26
Sprünge ...................................................................... 32
Prozessorarchitektur
Adressbus .................................................................. 27
Datenbus ................................................................... 27
Puffer .......................................................................... 27
Prüfsumme ................................................................ 413
Pseudo-Zufallszahlengenerator ........................ 161
PTC ................................................................................ 352
Puffer ............................................................................... 27
Pull-down-Widerstand � Pull-up-Widerstand
Pull-up-Widerstand .................... 223, 224, 226, 397
Pulsweitenmodulation ............. 193, 195, 220, 455
Hardware ............................................................... 199
Software ................................................................. 199
PuTTY ........................................................................... 287
PWM � Pulsweitenmodulation
R
Rahmen
Startbit .................................................................... 279
Stoppbit .................................................................. 279
Raspberry Pi .................................................................. 37
Rauschen .................................................................... 173
Index
670
read() ............................................................................. 300
Receiver ....................................................................... 284
Refactoring ................................................................. 121
Reflexion ........................................................... 432, 435
Register .............................................................. 253, 259
Reibungselektrizität ................................................. 58
Reihen- und Parallelschaltung ............................. 80
Reihenschaltung ........................................................ 81
Relais ...................................................................... 86, 473
Röhre .............................................................................. 24
Rotor ............................................................................. 471
Router ........................................................................... 520
Routine � Interrupt
Rückgabewert � Funktionen
S
Sättigungsverlauf .................................................... 179
Schalter ........................................................................ 224
Schaltplan .................................................. 63, 102, 103
Schaltung
integrierte ................................................................. 24
Simulation einer ..................................................... 90
Scheitelpunkt ............................................................ 180
Schichtenmodell ...................................................... 514
Schiebe-Operator ..................................................... 420
Schieberegister ............................................... 163, 310
Setup-Zeit ............................................................... 323
Schiebetakt ................................................................. 312
Schleife ............................................................... 116, 131
Arten von ................................................................ 138
for .............................................................................. 139
Index ........................................................................ 140
Schleifen ...................................................................... 157
do while ................................................................... 466
do-while-Schleife ................................................. 158
for-Schleife .................................................... 157, 184
fußgesteuerte ........................................................ 466
kopfgesteuerte ..................................................... 466
while-Schleife ............................................... 157, 171
Schleifenzähler ......................................................... 185
Schrittmotor .............................................................. 471
Schwingung ............................................................... 434
SCL � Serial Clock
SDA � Serial Data
Sensor ..................................... 350, 364, 379, 409, 439
Infrarotsensor ...................................................... 440
Triangulation ....................................................... 436
Ultraschallsensor ....................................... 439, 445
Vergleich ................................................................ 451
Sensorik � Sensor
Sensornetzwerk ....................................................... 407
Serial Clock ................................................................. 383
Serial Data .................................................................. 383
Serial Monitor .................................................. 112, 293
Serial Port Profil ....................................................... 565
Serielle Kommunikation ...................................... 277
Server � Client-Server-Modell
Servo.h ......................................................................... 489
Servomotor ................................................................ 469
setup-Funktion ................................................ 114, 116
Shield
Display .................................................................... 579
GSM .......................................................................... 512
LCD Keypad ........................................................... 579
Motor ....................................................................... 510
Übersicht ................................................................ 510
USB Host ................................................................ 511
WiFi .......................................................................... 512
Sichtbarkeit ................................................................ 130
SI-Einheit ....................................................................... 58
Silizium-Diode ............................................................. 88
Simple Mail Transport Protocol � SMTP
Simulation Program with Integrated Circuit
Emphasis ................................................................... 90
sizeof ............................................................................ 145
Sketch ........................................................... 21, 115, 121
Smart Home .............................................................. 661
SMD .................................................................................. 79
SMD-Bauteil .................................................................. 79
SMTP ............................................................................. 547
Snake ..................................................................... 18, 625
Snapdragon 810 .......................................................... 37
SoC � System-on-a-Chip
Software-PWM .......................................................... 199
SoftwareSerial ........................................................... 568
SoftwareSerial � UART
Spannung ...................................................................... 58
Spannungsabfall ......................................................... 65
Spannungspuls ......................................................... 197
Spannungsquelle ........................................................ 64
HIGH ........................................................................ 195
LOW .......................................................................... 195
Spannungsteiler ....................................................... 359
Speicher .......................................................................... 26
Adresse ....................................................................... 26
Index
671
SPI ............................................................................. 35, 40
Spice ................................................................................ 90
SPICE � Simulation Program with Integrated
Circuit Emphasis
SPP � Serial Port Profil
Spule ...................................................................... 86, 473
Induktivität .............................................................. 86
SRAM ....................................................................... 35, 40
Startbit ............................................................... 279, 383
Stator ............................................................................ 471
Steckbrett .................................................................... 105
Teilreihe .................................................................. 105
Verbindungspunkt ............................................. 105
Steckbrücke ................................................................ 108
Sterntopologie .......................................................... 379
Steuerleitung ............................................................... 27
Stoppbit ....................................................................... 279
String-Terminierer ........................................ 292, 296
Stromstärke ................................................................. 59
Struct .................................................................. 151, 610
Surface Mount Devices � SMD
switch-case .............................................. 243, 244, 498
System-on-a-Chip ...................................................... 36
T
Taktfrequenz ............................................................. 258
maximale .................................................................. 40
Taktleitung ................................................................. 383
Tastdauer .................................................................... 197
Tastdimmer � Dimmer
Taster ............................................................................ 223
entprellen ............................................................... 495
richtiger Einbau ................................................... 231
Tastweite � Tastdauer
TCP/IP ........................................................................... 519
Telnet ............................................................................ 516
Client ........................................................................ 517
Temperatur ................................................................ 351
Beiwert .................................................................... 352
Koeffizient .............................................................. 352
Tera Term
benutzen ................................................................. 304
Download ............................................................... 287
Installation ............................................................ 287
Thermometer
Schaltplan für TC74 ........................................... 390
Stromsparmodus aktivieren ........................... 400
TC74 ......................................................................... 386
Temperaturdaten auslesen ............................. 397
Through Hole Technology � THT
THT ................................................................................... 79
THT-Bauteil ................................................................... 79
Time Slot ..................................................................... 381
Timer ............................................................................... 35
Timer/Counter Control Register A ................... 259
Token ............................................................................ 381
Topologie
Bus ............................................................................ 379
Transformator ............................................................. 86
Transistor ...................................................................... 24
Transistoren .............................................................. 353
Transmisson Control Protocol � TCP/IP
Transmitter ................................................................ 284
Treiber (Motor)
L293DNE ................................................................ 473
Triangulation ............................................................ 436
Tristate � High Impedance
Tx � Transmitter
U
UART .................................. 35, 40, 278, 295, 300, 568
Überladung ................................................................ 296
Überlauf ...................................................................... 255
Übertragungsprotokoll ............................................ 35
UltraCap ......................................................................... 85
Ultraschallsensor ............................................ 439, 445
Umlaute (in Namen) .............................................. 201
Umwandlung ............................................................ 365
UND (logisches) ........................................................ 162
Universal Asynchronous Receiver
Transmitter � UART
unsigned int .............................................................. 125
Unterprogramm � Funktion
USB ................................................................................... 35
USB Host Shield ....................................................... 511
V
Valenzband ................................................................ 353
Variable ............................................. 25, 124, 130, 149
globale .................................................................... 130
Lebenszeit .............................................................. 130
Typ ............................................................................ 124
Index
672
Vektoren � Interrupt
Verdrahtung .............................................................. 106
Verlustleistung ........................................................... 79
Verpolung ..................................................................... 88
Verschieden-Operator ........................................... 147
Versorgungsspannung ..................................... 40, 85
Verzweigung (if und else) .................. 131, 132, 155
Visio ................................................................................ 63
Visual Micro ............................................................... 111
Visual Studio ............................................................. 111
Vorsilben
Infra .......................................................................... 432
Ultra ......................................................................... 432
Vorwiderstand ................................................... 69, 102
W
Wahrheitstafel .......................................................... 162
Wahrscheinlichkeit ................................................. 160
Wandler ................................................................ 35, 350
Watchdog ...................................................................... 35
Wearables ...................................................................... 47
Wechselspannung gleichrichten ......................... 88
Wechselstrom ........................................................... 410
Wechselstrommotor .............................................. 470
Wechselstromwiderstand .................................... 410
Welle
transversale ........................................................... 580
Wellen .......................................................................... 432
Addition .................................................................. 435
longitudinal .......................................................... 435
Reflexion ................................................................. 435
Wellenlänge ................................................................. 89
Wellen-Teilchen-Dualismus ................................ 580
while-Schleife ............................................................ 171
Widerstand ............................................................ 61, 90
Bauform ..................................................................... 77
Bauweisen ................................................................. 79
Impedanz ............................................................... 410
Material ..................................................................... 72
messen ..................................................................... 356
Pull-down-Widerstand ..................................... 226
Pull-up ..................................................................... 223
Querschnitt .............................................................. 74
Toleranz ..................................................................... 78
Vorwiderstand ..................................................... 102
Widerstandswert ........................................................ 90
Wiederholung � Schleifen
WiFi Shield ................................................................. 512
Wire-Bibliothek ........................................................ 392
Wolfram Alpha ......................................................... 182
X
XOR � exklusives ODER
Z
Zahl
duale ........................................................................ 165
Zahlensystem
binäres .................................................................... 532
hexadezimales ..................................................... 532
Zähler .................................................................... 35, 253
Vorteiler .................................................................. 256
ZigBee .................................................................. 513, 521
Zufall ............................................................................. 159
random() ................................................................ 172
randomSeed() ....................................................... 173
Seed .......................................................................... 326
Zufallszahl .................................................................. 325
Betrag bilden ........................................................ 174
Zufallszahlengenerator ......................................... 161
echte Zufallszahlen ............................................ 167
Pseudo-Zufallszahlengenerator .................... 161
Zusatzmaterial ............................................................. 21
Zustand � Zustandsmaschine
Zustandsdiagramm .................... 203, 220, 235, 238
Zustandsmaschine ...................... 203, 220, 235, 238
Zuweisung .................................................................. 129
Zuweisungsoperator .............................................. 125
Benjamin Kappel
Arduino – Elektronik, Programmierung, Basteln672 Seiten, broschiert, in Farbe, März 2016 29,90 Euro, ISBN 978-3-8362-3648-5
www.rheinwerk-verlag.de/3797
Wir hoffen sehr, dass Ihnen diese Leseprobe gefallen hat. Sie dürfen sie gerne emp-fehlen und weitergeben, allerdings nur vollständig mit allen Seiten. Bitte beachten Sie, dass der Funktionsumfang dieser Leseprobe sowie ihre Darstellung von der E-Book-Fassung des vorgestellten Buches abweichen können. Diese Leseprobe ist in all ihren Teilen urheberrechtlich geschützt. Alle Nutzungs- und Verwertungsrechte liegen beim Autor und beim Verlag.
Teilen Sie Ihre Leseerfahrung mit uns!
Benjamin Kappel, studierter Elektrotechniker und Arduino- Enthusiast, absolviert zurzeit den Masterstudiengang Informa-tionstechnik/Technische Informatik an der Universität Rostock. Darüber hinaus ist er als IT-Dozent tätig. Dabei bildet er im Schwerpunkt Jugendliche weiter. Privat lebt er mit seiner Frau und der gemeinsamen kleinen Tochter in unmittelbarer Nähe zur Ostsee.
Know-how für Kreative.Wissen, wie’s geht.
Recommended