arduino – elektronik, programmierung, basteln - aws · pdf fileprogrammieren lernen mit...

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.

mailto:?body=Leseproben-Empfehlung:%20%C2%BBArduino%20%E2%80%93%20Elektronik,%20Programmierung,%20Basteln%C2%AB%20von%20Rheinwerk,%20http://gxmedia.galileo-press.de/leseproben/3797/leseprobe_rheinwerk_arduino_elektronik_programmierung_basteln.pdf&subject=Leseprobe:%20%C2%BBArduino%20%E2%80%93%20Elektronik,%20Programmierung,%20Basteln%C2%AB

https://www.rheinwerk-verlag.de/arduino_3797/?GPP=lpn

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.


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


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-


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


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


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


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)


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.


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)


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


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


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


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.


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.


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.


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:


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


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.


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.


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:


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.


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);

}


329

/* Erzeugen einer steigenden Flanke für das Speicherregister,indem man den Pin für den "Speicher-Takt" auf LOW setztund danach auf HIGH */


}

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 },


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


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(){


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


}

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.


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.


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.


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


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);


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{



338

}}else if (ledZustand == LED_SPIELER_1_GEWAEHLT){


}else if (ledZustand == LED_SPIELER_2_GEWAEHLT){


}}

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)


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)

{


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.


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


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;}


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:


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


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.


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


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


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


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.3 Ein sekundengenaues Pulsieren ....................................................................................... 258

Inhalt

9

8.4 Der »Geekdown« – der etwas andere Countdown .................................................. 267


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


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


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


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.5 Ihr erstes digitales Thermometer ..................................................................................... 391

12.5.1 Der stromsparende digitale Gärtner ............................................................... 400


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.4 Der bezahlbare Gärtner entsteht ..................................................................................... 416


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


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


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


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.4 Verändern der Bluetooth-Eigenschaften ...................................................................... 568

17.5 Die Fernsteuerung entwickeln .......................................................................................... 571

17.6 Fernsteuerung via App .......................................................................................................... 577


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


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.

https://www.rheinwerk-verlag.de/arduino_3797/?GPP=lpn

https://www.facebook.com/rheinwerkverlag

https://plus.google.com/118435207805510651040

http://twitter.com/rheinwerkverlag

arduino – elektronik, programmierung, basteln - aws · pdf fileprogrammieren lernen mit...

Documents