Was du gerade im Kapitel 4 gelernt hast, sind die elementarsten Operationen, die wir in Arduino vornehmen können: Steuerung der digitalen Ausgabe und Lesen der digitalen Eingabe. Wenn Arduino eine Art menschliche Sprache wäre, dann wären das zwei Buchstaben ihres Alphabets. Wenn man bedenkt, dass dieses Alphabet aus nur fünf Buchstaben besteht, dann verstehst du, wie viel Arbeit wir vor uns haben, bevor wir Arduino-Poesie schreiben können.
Nun, da du gelernt hast, einen Drucktastschalter zu verwenden, solltest du wissen, dass es viele weitere, sehr einfache Sensoren gibt, die nach demselben Prinzip funktionieren:
Wechselschalter
Der Drucktastschalter, den du verwendet hast, ist ein Schaltertyp, der sich Taster nennt, weil er nach dem Loslassen wieder in seine Ausgangsstellung zurückgeht. Ein einfaches Beispiel für einen Drucktaster ist die Türklingel.
Ein Wechselschalter (auch Kippschalter) hingegen bleibt in der Stellung, in die du ihn bewegst. Ein einfaches Beispiel für einen Wechselschalter ist ein Lichtschalter.
In diesem Buch verwenden wir die gebräuchlichen Namen für diese Schalter: Ein Drucktastschalter bezieht sich auf einen Taster, während ein Schalter für einen Wechselschalter steht.
Obwohl du einen Schalter nicht für einen Sensor halten magst – er ist es doch: Ein Drucktastschalter (nicht einrastender Schalter) erkennt, wenn er gedrückt wird, und ein (Wechsel-)Schalter erkennt (elektrisch) und erinnert sich (mechanisch) an den letzten Zustand, in den er versetzt wurde.
Thermostat
Ein Schalter, der seinen Zustand ändert, wenn die Temperatur einen bestimmten Wert erreicht.
Magnetschalter (auch als Reedschalter bekannt)
Dieser hat zwei Kontakte, die in Berührung kommen, wenn sie sich in der Nähe eines Magneten befinden; der Schalter kommt oft bei Alarmanlagen zum Einsatz, um festzustellen, ob eine Tür oder ein Fenster geöffnet wird.
Sensormatte
Dies sind dünne Matten, die sich unter einem Teppich oder einer Türmatte platzieren lässt, um zu erkennen, ob ein Mensch (oder eine schwere Katze) drauftritt.
Neigungsschalter oder Neigungssensor
Ein einfacher, aber cleverer Sensor, der zwei (oder mehr) Kontakte und eine kleine Metallkugel (oder einen Tropfen Quecksilber, dessen Einsatz ich aber nicht empfehle) enthält. Abb. 5–1 zeigt das Innere eines typischen Modells.
Abb. 5–1Das Innenleben eines Neigungssensors
Wenn sich der Sensor in seiner aufrechten Position befindet, überbrückt die Kugel die beiden Kontakte, und das funktioniert genau wie beim Drücken eines Drucktasters. Wenn du diesen Sensor neigst, bewegt sich die Kugel und der Kontakt wird geöffnet, was dem Loslassen eines Drucktasters entspricht. Mithilfe dieser simplen Komponente kannst du beispielsweise gestengesteuerte Schnittstellen implementieren, die auf Bewegen oder Schütteln eines Objekts reagieren.
Ein weiterer nützlicher Sensor, der sich häufig in Alarmanlagen findet, ist der Passiv-Infrarot-Sensor, oder PIR, dargestellt in Abb. 5–2. Dieses Bauteil ändert seinen Zustand, wenn sich eine genügend große Infrarotquelle, wie ein Mensch, in seinem Erfassungsbereich bewegt. Diese Sensoren werden häufig so ausgelegt, dass sie Menschen erfassen, nicht jedoch kleine Tiere, damit Alarmanlagen nicht durch Haustiere ausgelöst werden.
Abb. 5–2Typischer PIR-Sensor
Das Erkennen von Menschen ist übrigens recht kompliziert, und der PIR-Sensor (oder Bewegungsmelder) ist innen ziemlich komplex. Zum Glück interessiert uns das Innere nicht wirklich. Alles, was wir wissen müssen, ist, dass es ein digitales Signal auslöst, das anzeigt, ob ein Mensch anwesend ist oder nicht. Deshalb ist der PIR-Sensor ein digitaler Sensor.
Du kannst mit einer Metallkugel, ein paar Nägeln und etwas Draht, um die Nägel damit zu umwickeln, deinen eigenen Neigungsschalter bauen. Wenn die Kugel auf eine Seite rollt und auf zwei Nägeln zur Ruhe kommt, verbindet sie diese beiden Drähte miteinander.
Einen Drucktastschalter kannst du mit einer Wäscheklammer herstellen, indem du um jeden Griff einen Draht wickelst. Wenn die Griffe zusammengedrückt werden, wird der Schalter geschlossen.
Alternativ dazu kannst du die Drähte um die Klemmbacken der Wäscheklammer wickeln und ein Stück Pappe dazwischenstecken, um die Drähte voneinander fernzuhalten. Binde eine Schnur an die Pappe und binde das andere Ende der Schnur an eine Tür. Wird die Tür geöffnet, zieht die Schnur die Pappe heraus, die Drähte berühren sich und der Schalter wird geschlossen.
Da all diese Sensoren digital sind, kann jeder von ihnen statt des Drucktasters verwendet werden, mit dem du in Kapitel 4 gearbeitet hast, ohne eine Änderung an deinem Sketch vornehmen zu müssen.
Verwendest du die Schaltung und den Sketch »Einsatz eines Drucktasters zur Steuerung der LED« auf Seite 46, ersetzt aber den Taster durch einen PIR-Sensor, könntest du zum Beispiel deine Lampe auf die Anwesenheit von Menschen reagieren lassen, oder du könntest einen Neigungsschalter verwenden und die Lampe so bauen, dass sich die Lampe ausschaltet, wenn sie zu einer Seite geneigt wird.
Du weißt bereits genug, um eine interaktive Lampe zu bauen, aber bisher ist das Ergebnis etwas langweilig, da die Lampe lediglich entweder an oder aus ist. Eine moderne interaktive Lampe muss dimmbar sein. Um dieses Problem zu lösen, können wir einen kleinen Trick anwenden, der einige Dinge wie Fernsehen oder Kino erst möglich macht. Dieser Trick nennt sich Persistence of Vision, oder POV – zu Deutsch Augenträgheit. POV nutzt die Tatsache, dass unsere Augen das, was sie sehen, nicht mehr als etwa zehnmal pro Sekunde »auffrischen« können. Wenn sich das, was wir ansehen, schneller als das bewegt, dann »verwischt« das Auge ein Bild mit dem nächsten und erzeugt so die Illusion – manche nennen es »Interpretation« – einer Bewegung.
Wie wir nach dem ersten Beispiel in Kapitel 4 andeuteten, wirst du beim Reduzieren der Zahl in der delay-Funktion, bis du die LED nicht mehr blinken siehst, feststellen, dass die LED dunkler erscheint als normalerweise. Beim Herumexperimentieren wirst du feststellen, dass du, wenn die Einschaltverzögerung anders eingestellt ist als die Ausschaltverzögerung, die LED heller erscheinen lassen kannst, indem du sie länger brennen lässt, und du kannst die LED dunkler wirken lassen, indem du sie länger ausgeschaltet lässt. Diese Technik nennt sich Pulsweitenmodulation, oder PWM, da du die Helligkeit der LED durch Modulieren (oder Ändern) des Pulses änderst. Abb. 5–3 zeigt diesen Vorgang. Das funktioniert, da unsere Augen aufgrund der Augenträgheit keine auffallenden Änderungen an der LED sehen können, weil sie zu schnell vonstattengehen.
Die Pulsweitenmodulation funktioniert mit einigen anderen Geräten außer LEDs. Zum Beispiel kannst du die Drehzahl eines Motors auf dieselbe Weise ändern. In diesem Fall sind es nicht unsere Augen, die dies zulassen, sondern der Motor selbst, da er nicht auf der Stelle starten oder stoppen kann. Es dauert einen Moment, bis der Rotor des Motors beschleunigt oder abbremst. Wenn wir die Ausgabe (unter Verwendung von digitalWrite()) schneller ändern, als der Motor reagieren kann, dreht er sich mit einer dazwischenliegenden Drehzahl weiter, abhängig davon, für welche Zeit er ein- bzw. ausgeschaltet ist.
Obwohl dieser Trick nützlich ist, hattest du wahrscheinlich das Gefühl, dass die Steuerung der Helligkeit der LED durch Herumspielen mit Verzögerungen in deinem Code etwas unpraktisch ist. Schlimmer noch: Sobald du einen Sensor ablesen, Daten über den seriellen Port schicken oder was auch immer machen möchtest, wird sich die Helligkeit der LED ändern, weil jede zusätzliche Codezeile Zeit zum Ausführen hinzuaddiert, was sich auf die Zeit, die die LED ein- oder ausgeschaltet ist, auswirkt.
Zum Glück umfasst der von deinem Arduino verwendete Mikrocontroller ein besonderes Hardwareteil namens Timer/Counter, zu Deutsch Zeitschaltuhr/Zähler. Timer/Counter laufen unabhängig von dem Programm, das der Mikrocontroller ausführt, und können deine LED sehr effizient blinken lassen, während dein Sketch etwas anderes tut. Auf dem Uno ist diese Hardware in den Pins 3, 5, 6, 9, 10 und 11 implementiert. Sobald sie korrekt eingerichtet sind, können die Timer/Counter insbesondere einen Pin automatisch für eine bestimmte Zeit ein- und dann für eine bestimmte Zeit wieder ausschalten, und all das, ohne dein Programm zu beeinflussen. Wenn du ein Diagramm der Spannung am Pin zeichnest, wirst du sehen, dass die Pulse in ihrer Weite variieren können; daher nennt sich diese Technik Pulsweitenmodulation oder PWM.
Die Funktion, die für die PWM auf dem Arduino zuständig ist, nennt sich analogWrite(). analogWrite() nimmt einen Wert zwischen 0 und 255, wobei 255 volle Helligkeit bedeutet, 0 dagegen vollkommen aus.
Schreibt man zum Beispiel analogWrite(9,50), wird die Helligkeit der LED am Pin 9 auf recht dunkel gesetzt, während analogWrite(9,200) die LED ziemlich hell scheinen lässt. Wenn du einen Motor am Pin 9 anschließt, dann wird analogWrite(9,50) den Motor recht langsam bewegen, während analogWrite(9,200) den Motor deutlich schneller bewegt.
Mehrere PWM-Pins zu haben, ist sehr hilfreich. Wenn du zum Beispiel eine RGB-LED kaufst (eine LED, die rotes, grünes und blaues Licht mit unterschiedlicher Intensität emittieren kann), dann kannst du jeden Wert anpassen, um Licht jeder beliebigen Farbe zu produzieren.
Abb. 5–3PWM im Einsatz
Lass es uns probieren. Bau die Schaltung, die du in Abb. 5–4 siehst. Du benötigst eine LED jeder Farbe und ein paar 220-Ohm-Widerstände.3
Beachte, dass LEDs polarisiert sind, was bedeutet, es spielt eine Rolle, in welcher Richtung der elektrische Strom durch sie hindurchfließt. Der lange Leiter kennzeichnet die Anode bzw. positive Leitung, und in unserem Fall muss diese auf die rechte Seite gehen, womit sie am Pin 9 des Arduino angeschlossen wird. Der kurze Leiter kennzeichnet die Kathode bzw. die negative Leitung, und in diesem Fall muss sie links angeschlossen werden, am Widerstand.
Die meisten LEDs haben auch auf der Seite der Kathode ein abgeflachtes Ende, wie in der Abbildung dargestellt. Eine einfache Methode, sich dies zu merken, ist, dass das flache Teil aussieht wie ein Minuszeichen und dass der kurze Leiter etwas von ihm abgezogen bekommen hat.
Wie zuvor bei »Blinkende LED« auf Seite 30 erwähnt, solltest du mit einer LED immer einen Widerstand verwenden, um ein Durchbrennen der LED zu verhindern. Jeglicher Wert eines Widerstands zwischen 220 Ohm (rot-rot-braun) und 1000 Ohm (braun-schwarz-rot) sollte in Ordnung sein.
Erstelle dann einen neuen Sketch im Arduino mit dem in Beispiel 5–1 gezeigten Code. Du kannst ihn auch über den Link für die Beispielcodes von der Katalogseite der englischen Originalausgabe des Buches herunterladen (https://makezine.com/go/arduino-4e-github/).
Abb. 5–4LED angeschlossen an PWM-Pin
Beispiel 5–1LED ein- und ausblenden, wie bei einem »schlafenden« Apple-Computer
const int LED = 9; // the pin for the LED
int i = 0; // We'll use this to count up and down
void setup() {
pinMode(LED, OUTPUT); // tell Arduino LED is an output
}
void loop(){
for (i = 0; i < 255; i++) { // loop from 0 to 254 (fade in)
analogWrite(LED, i); // set the LED brightness
delay(10); // Wait 10ms because analogWrite
// is instantaneous and we would
// not see any change with no delay
}
for (i = 255; i > 0; i--) { // loop from 255 to 1 (fade out)
analogWrite(LED, i); // set the LED brightness
delay(10); // Wait 10ms
}
}
Lade den Sketch hoch, und die LED wird fortlaufend erst heller, dann wieder dunkler werden. Glückwunsch! Du hast ein schickes Feature eines Laptop-Computers nachgebildet.
Vielleicht ist es ein wenig Verschwendung, Arduino für so etwas Simples zu verwenden, aber von diesem Beispiel kannst du eine Menge lernen.
Wie du zuvor gelernt hast, ändert analogWrite() die Helligkeit der LED. Der andere wichtige Teil ist die for-Schleife: Sie wiederholt analogWrite() und delay() immer wieder, dabei verwendet sie jedes Mal wie folgt einen anderen Wert für die Variable i.
Bei der ersten for-Schleife wird für die Variable i der Wert 0 benutzt. Dieser Wert wird dann bis auf 255 gesteigert, was die LED ihre volle Helligkeit erreichen lässt.
Bei der zweiten for-Schleife wird für die Variable i der Wert 255 benutzt und dann bis auf 0 verringert, womit die LED bis zum kompletten Ausschalten gedimmt wird.
Nach der zweiten for-Schleife startet Arduino unsere loop()-Funktion von vorn.
Die Verzögerung delay() dient nur dazu, alles ein wenig zu verlangsamen, damit du erkennen kannst, wie die Helligkeit sich verändert – andernfalls würde das zu schnell ablaufen.
Lass uns dieses Wissen zum Verbessern unserer Lampe nutzen.
Füge dieser Steckplatine die Schaltung hinzu, die wir (vorher in Kapitel 4) zum Ablesen einer Taste verwendet haben. Schau mal, ob du es schaffst, ohne über diesen Absatz hinaus weiterzulesen, denn ich möchte, dass du erst über die Tatsache nachdenkst, dass jede elementare Schaltung, die ich hier zeige, ein Baustein für den Bau immer größerer Projekte ist. Wenn du doch einen kurzen Blick nach vorn werfen musst, kein Problem – Hauptsache, du denkst in Ruhe ein wenig darüber nach, wie das aussehen könnte.
Um diese Schaltung zu erstellen, musst du die gerade von dir gebaute Schaltung (in Abb. 5–4 dargestellt) mit der in Abb. 4–5 dargestellten Drucktasterschaltung kombinieren. Wenn du möchtest, kannst du einfach beide Schaltungen auf verschiedenen Teilen der Steckplatine bauen – du hast viel Platz.
Schau dir Anhang A an, um mehr zur lötfreien Steckplatine zu erfahren.
Wenn du dazu noch nicht bereit bist, keine Sorge: Verbinde einfach die beiden Schaltungen mit deinem Arduino, wie in den Abbildungen 4–5 und 5–4 dargestellt.
Nun zum nächsten Beispiel: Wenn man nur einen Taster hat, wie steuert man dann die Helligkeit einer Lampe? Du erlernst noch eine weitere Methode des Interaktionsdesigns: erkennen, wie lange ein Taster gedrückt worden ist. Dazu müssen wir das Beispiel 4–5 aus Kapitel 4 modifizieren, um eine Dimmfunktion hinzuzufügen. Der Gedanke ist, eine Schnittstelle zu bauen, an der eine Drücken-und-Loslassen-Aktion das Licht ein- und ausschaltet und eine Drücken-und-Halten-Aktion die Helligkeit ändert.
Schau dir den Sketch in Beispiel 5–2 an. Er schaltet die LED ein, wenn der Taster gedrückt ist, und lässt sie nach dem Loslassen weiter an. Wenn der Taster gehalten wird, ändert sich die Helligkeit.
Beispiel 5–2Sketch zum Ändern der Helligkeit einer LED, während du den Taster drückst
const int LED = 9; // the pin for the LED
const int BUTTON = 7; // input pin of the pushbutton
int val = 0; // stores the state of the input pin
int old_val = 0; // stores the previous value of "val"
int state = 0; // 0 = LED off while 1 = LED on
int brightness = 128; // Stores the brightness value
unsigned long startTime = 0; // when did we begin pressing?
void setup() {
pinMode(LED, OUTPUT); // tell Arduino LED is an output
pinMode(BUTTON, INPUT); // and BUTTON is an input
}
void loop() {
val = digitalRead(BUTTON); // read input value and store it
// yum, fresh
// check if there was a transition
if ((val == HIGH) && (old_val == LOW)) {
state = 1 - state; // change the state from off to on
// or vice-versa
// remember when the button was last pressed)
startTime = millis(); // millis() is the Arduino clock
// it returns how many milliseconds
// have passed since the board has
// been reset.
delay(10); // wait a bit so we can see the effect
}
// check whether the button is being held down
if ((val == HIGH) && (old_val == HIGH)) {
// If the button is held for more than 500 ms.
if (state == 1 && (millis() - startTime) > 500) {
brightness++; // increment brightness by 1
delay(10); // delay to avoid brightness going
// up too fast
if (brightness > 255) { // 255 is the max brightness
brightness = 0; // if we go over 255
// let's go back to 0
}
}
}
old_val = val; // val is now old, let's store it
if (state == 1) {
analogWrite(LED, brightness); // turn LED ON at the
// current brightness level
} else {
analogWrite(LED, 0); // turn LED OFF
}
}
Jetzt probiere es aus. Wie du siehst, nimmt dieses Interaktionsmodell Gestalt an. Wenn du den Taster drückst und sofort wieder loslässt, schaltest du die Lampe ein oder aus. Wenn du den Taster gedrückt hältst, ändert sich die Helligkeit; lass ihn einfach los, wenn du die gewünschte Helligkeit erreicht hast.
Wie ich bereits zum Thema »Nachdenken über die Schaltung« sagte: Versuche ein wenig Zeit dafür zu investieren, das Programm zu verstehen.
Die verwirrendste Zeile ist wahrscheinlich diese hier:
if (state == 1 && (millis() - startTime) > 500) {
Diese Codezeile prüft, um zu sehen, ob der Taster mehr als 500 ms gedrückt gehalten wird, indem sie eine Funktion namens millis() verwendet, die lediglich eine Zählung der Millisekunden seit Beginn des Betriebs deines Sketches ist. Durch das Festhalten des Zeitpunkts, an dem der Taster gedrückt wurde (in der Variablen startTime), können wir die aktuelle Zeit mit der Startzeit vergleichen, um zu sehen, wie viel Zeit vergangen ist.
Das funktioniert natürlich nur, wenn der Taster gedrückt wird, weshalb wir am Beginn der Zeile prüfen, ob state auf den Wert 1 gesetzt ist.
Wie du siehst, sind Schalter echt leistungsstarke Sensoren, auch wenn sie so simpel sind. Jetzt lass uns lernen, einige andere Sensoren zu verwenden.
Jetzt werden wir versuchen, ein interessantes Experiment mit einem Fotowiderstand4 durchzuführen, wie jenem in Abb. 5–5 gezeigten.
Abb. 5–5Fotowiderstand (LDR, engl. für Light Dependent Resistor)
Wie sein englischer Name »Light dependend resistor« nahelegt, ist der Fotowiderstand eine Art Widerstand, der von Licht abhängig ist. Bei Dunkelheit ist der Widerstand eines LDR recht hoch, aber wenn du etwas Licht auf ihn scheinen lässt, sinkt der Widerstand schnell und er wird zu einem ziemlich guten Leiter für elektrischen Strom. Damit ist er eine Art lichtaktivierter Schalter.
Bau die in Abb. 4–5 dargestellte Schaltung (siehe »Einsatz eines Drucktasters zur Steuerung der LED« auf Seite 46 in Kapitel 4) und lade dann den Code aus Beispiel 4–2 in deinen Arduino hoch. Drück den Taster, um sicherzustellen, dass er funktioniert.
Jetzt entferne vorsichtig nur den Drucktaster und füge den LDR genau dort in die Schaltung ein, wo zuvor der Taster war. Die LED sollte aufleuchten. Bedecke den LDR mit deinen Händen, und die LED schaltet sich aus.
Du hast soeben deine erste echte sensorbetriebene LED gebaut. Das ist ein bedeutender Schritt, weil du erstmals in diesem Buch eine elektronische Komponente verwendest, die nicht nur ein einfaches mechanisches Gerät ist: Sie ist ein echter, leistungsstarker Sensor. Tatsächlich ist das nur ein kleines Beispiel dessen, wofür sich ein LDR einsetzen lässt.
Wie du im vorhergehenden Abschnitt gelernt hast, kann Arduino erkennen, ob auf einen der Pins eine Spannung angewandt wird, und meldet dies durch die Funktion digitalRead(). Diese Art der Entweder-oder-Reaktion ist in vielen Applikationen ausreichend, aber der Fotowiderstand, den wir gerade verwendet haben, kann uns nicht nur sagen, ob überhaupt Licht vorhanden ist, sondern auch, wie viel. Das ist der Unterschied zwischen einem Ein/Aus- oder digitalen Sensor (der uns sagt, ob etwas da ist oder nicht) und einem analogen Sensor, der uns sagen kann, wie viel von etwas da ist.
Um diese Art von Sensor ablesen zu können, müssen wir einen speziellen Arduino-Pin verwenden.
Dreh deinen Arduino herum, damit er der Abb. 5–6 entspricht.
Im oberen linken Teil des Boards siehst du sechs Pins mit der Kennzeichnung Analog In; das sind spezielle Pins, die dir nicht nur sagen können, ob eine Spannung auf sie angewandt wird, sondern die auch die Höhe dieser Spannung messen können, indem sie die analogRead()-Funktion verwenden. Die analogRead()-Funktion gibt eine Zahl zwischen 0 und 1023 wieder, die Spannungen zwischen 0 und 5 Volt repräsentiert. Wenn zum Beispiel eine Spannung von 2,5 V auf Pin Nummer 0 angewandt wird, dann gibt analogRead(0) 512 wieder.
Wenn du jetzt diese Schaltung aufbaust, die du in Abb. 5–6 siehst, einen 10-kΩ-Widerstand verwendest und den im Beispiel 5–3 aufgeführten Code ausführst, dann siehst du die LED auf dem Board mit einer Rate blinken, die von der auf den Sensor scheinenden Lichtmenge abhängig ist.
Abb. 5–6Eine Schaltung mit einem analogen Sensor
Beispiel 5–3LED mit einer durch den Wert der analogen Eingabe bestimmten Rate blinken lassen
const int LED = 13; // the pin for the LED
int val = 0; // variable used to store the value
// coming from the sensor
void setup() {
pinMode(LED, OUTPUT); // LED is as an OUTPUT
// Note: Analogue pins are
// automatically set as inputs
}
void loop() {
val = analogRead(0); // read the value from
// the sensor
digitalWrite(LED, HIGH); // turn the LED on
delay(val); // stop the program for
// some time
digitalWrite(LED, LOW); // turn the LED off
delay(val); // stop the program for
// some time
}
Nun füge wie zuvor eine LED an Pin 9 hinzu und verwende dazu die in Abb. 5–4 gezeigte Schaltung. Da du bereits einiges auf der Platine stecken hast, musst du eine Stelle darauf finden, wo die LED, die Drähte und der Widerstand nicht die LDR-Schaltung überlappen. Vielleicht musst du ein paar Dinge verlagern, aber keine Sorge, das ist eine gute Übung, weil es dir hilft, Schaltungen und die Steckplatine zu verstehen.
Wenn du mit dem Hinzufügen der LED zu deiner LDR-Schaltung fertig bist, gib das Beispiel 5–4 ein und lade es dann auf deinen Arduino hoch.
Beispiel 5–4LED auf eine vom Wert des analogen Eingangs bestimmte Helligkeit einstellen
const int LED = 9; // the pin for the LED
int val = 0; // variable used to store the value
// coming from the sensor
void setup() {
pinMode(LED, OUTPUT); // LED is as an OUTPUT
// Note: Analogue pins are
// automatically set as inputs
}
void loop() {
val = analogRead(0); // read the value from
// the sensor
analogWrite(LED, val/4); // turn the LED on at
// the brightness set
// by the sensor
delay(10); // stop the program for
// some time
}
Sobald es läuft, decke die LDR abwechselnd ab und wieder auf und schau, was mit der Helligkeit der LED passiert.
Versuche wiederum zu verstehen, was passiert. Das Programm ist wirklich sehr einfach, sogar viel einfacher als die vorhergehenden zwei Beispiele.
Wir spezifizieren die Helligkeit der LED durch Teilen von val durch 4, da analogRead() eine Zahl bis 1023 wiedergibt und analogWrite() maximal 255 akzeptiert. Der Grund dafür ist, dass es immer wünschenswert ist, analoge Sensoren mit einer möglichst hohen Präzision abzulesen, während unsere Augen feinere Unterschiede in der Helligkeit einer LED nicht erkennen können. Falls du dich fragst, warum analogRead() keinen noch größeren Zahlenbereich wiedergibt – das liegt daran, dass es mehr Raum auf dem Stück Silikon im Kern des Mikrocontrollers einnehmen würde, und dies ginge auf Kosten irgendeiner anderen Funktionalität. Das Design von Mikrocontrollern ist immer ein sorgfältiges Zusammenspiel von Merkmalen, Raum, Hitze, Kosten und der Anzahl von Pins.
Der Fotowiderstand ist ein sehr nützlicher Sensor, aber Arduino kann Widerstand nicht direkt ablesen. Die Schaltung in Abb- 5–6 nimmt den Widerstand des LDR und wandelt ihn in eine Spannung um, die Arduino lesen kann.
Dieselbe Schaltung funktioniert für jeden Widerstandssensor. Hiervon gibt es viele verschiedene Arten wie Sensoren zum Messen von Kraft, Dehnung, Biegung oder Temperatur. Du könntest zum Beispiel einen Thermistor (temperaturabhängiger Widerstand) statt des LDR anschließen und damit eine LED erhalten, die ihre Helligkeit je nach Temperatur verändert.
Wenn du mit einem Thermistor arbeitest, sei dir bewusst, dass keine direkte Verbindung zwischen dem von dir abgelesenen Wert und der tatsächlich gemessenen Temperatur besteht. Wenn du eine exakte Ablesung benötigst, dann solltest du die Zahlen nehmen, die beim Messen mit einem echten Thermometer vom analogen Pin kommen. Du könntest diese Zahlen in einer Tabelle nebeneinanderstellen und einen Weg erarbeiten, die analogen Ergebnisse mit tatsächlichen Temperaturen zu kalibrieren. Alternativ dazu könntest du einen digitalen Temperatursensor wie den TMP36 von Analog Devices verwenden.
Bis jetzt haben wir eine LED als Ausgabegerät verwendet. Es wäre schwierig, zum Beispiel die Temperatur zu messen, indem man versucht, die Helligkeit einer LED zu beurteilen. Wäre es nicht schön, wenn wir tatsächlich die Werte erhielten, die Arduino vom Sensor abliest? Wir könnten die LED die Werte in Morsecode blinken lassen, aber es gibt einen viel einfacheren Weg für Arduino, Informationen an uns Menschen zu senden, indem dasselbe USB-Kabel verwendet wird, das du zum Hochladen deiner Sketche auf den Arduino benutzt hast.
Du hast am Anfang dieses Buches gelernt, dass der Arduino einen USB-Anschluss hat, der von der IDE zum Hochladen von Code auf den Mikrocontroller genutzt wird. Die gute Nachricht ist, dass, nachdem der Sketch hochgefahren ist und läuft, der Sketch dieselbe Verbindung nutzen kann, um Mitteilungen an deinen Computer zu senden bzw. von ihm zu empfangen. Dafür verwenden wir das serielle Objekt.
In der Arduino-Programmiersprache ist ein Objekt eine Sammlung verwandter Fähigkeiten, die aus praktischen Gründen gebündelt sind, und das serielle Objekt erlaubt uns, über die USB-Verbindung zu kommunizieren. Du kannst dir das serielle Objekt als einen Weg vorstellen, eine Mitteilung zum oder vom Arduino zu schicken, Buchstabe für Buchstabe. Natürlich enthält das serielle Objekt eine Menge kompliziertes Zeug, um das wir uns nicht kümmern brauchen. Wir müssen nur lernen, wie man das serielle Objekt verwendet.
In diesem Beispiel nimmst du die letzte Schaltung, die wir mit dem Fotowiderstand gebaut haben, aber statt der Steuerung der Helligkeit einer LED sendest du die von analogRead() gelesenen Werte zurück an den Computer. Gib den Code aus Beispiel 5–5 in einen neuen Sketch ein. Du kannst ihn auch über den Link für die Beispielcodes von der Katalogseite der englischen Originalausgabe des Buches herunterladen (https://makezine.com/go/arduino-4e-github/).
Beispiel 5–5Sende dem Computer die vom analogen Eingang 0 gelesenen Werte
const int SENSOR = 0; // select the input pin for the
// sensor resistor
int val = 0; // variable to store the value coming
// from the sensor
void setup() {
Serial.begin(9600); // open the serial port to send
// data back to the computer at
// 9600 bits per second
}
void loop() {
val = analogRead(SENSOR); // read the value from
// the sensor
Serial.println(val); // print the value to
// the serial port
delay(100); // wait 100ms between
// each send
}
Nachdem du den Code auf deinen Arduino hochgeladen hast, denkst du vielleicht, es passiert nichts Interessantes. Tatsächlich arbeitet dein Arduino einwandfrei: Er ist damit beschäftigt, den Lichtsensor abzulesen und Informationen an deinen Computer zu senden. Das Problem ist, dass nichts an deinem Computer anzeigt, dass die Informationen von deinem Arduino kommen.
Was du brauchst, ist eine Softwarefunktion namens Serial Monitor, und diese ist in die Arduino-IDE eingebaut.
Die Serial-Monitor-Schaltfläche befindet sich nahe der oberen rechten Ecke der Arduino-IDE. Sie sieht ein bisschen wie eine Lupe aus, als würdest du die Kommunikation vom Arduino zu deinem Computer ausspionieren.
Klicke die Serial-Monitor-Schaltfläche an, um den Monitor zu öffnen – im unteren Teil des Fensters siehst du dann die Zahlen vorbeirollen. Deck den Fotowiderstand zu, um es abzudunkeln, und schau, wie sich die Zahlen verändern. Beachte, dass die Zahlen nie unter Null gehen und nie über 1023, da dies der Zahlenbereich ist, den analogRead() produzieren kann.
Der serielle Kommunikationskanal zwischen Arduino und deinem Computer eröffnet eine völlig neue Welt voller Möglichkeiten. Es gibt viele Programmiersprachen, mit denen du Programme für deinen Computer schreiben kannst, der mit dem seriellen Port sprechen kann, und über den seriellen Port können jene Programme mit deinem Arduino sprechen.
Eine besonders gute Ergänzung zum Arduino ist die Programmiersprache »Processing«, da die Sprache und die IDE sich so ähnlich sind. Im Kapitel 6 unter »Programmieren« auf Seite 86 erfährst du mehr zu Processing, und deine Arduino-IDE schließt einige Beispiele ein, wie bspw. File 
Examples 04.Communication Dimmer und File Examples 04.Communication Graph. Du kannst auch viele Beispiele im Internet finden.
Jeder der Pins auf einem Arduino-Board kann nur für den Antrieb von Geräten verwendet werden, die sehr wenig Strom verbrauchen, wie zum Beispiel eine LED. Wenn du versuchst, etwas Größeres wie einen Motor oder eine Glühbirne zu betreiben, könnte der Pin seine Arbeit einstellen und den Mikrocontroller, das Herz deines Arduino, dauerhaft beschädigen.
Um sicherzugehen, sollte der Strom, der durch einen I/O-Pin des Arduino fließt, auf 20 mA beschränkt sein.
Aber keine Sorge: Es gibt eine Reihe einfacher Techniken, die es dir erlauben, Geräte zu steuern, die viel mehr Strom benötigen. Der Trick ähnelt ein bisschen dem Einsatz eines Hebels und Drehpunkts zum Heben einer sehr schweren Last. Indem ein langer Stock unter einen schweren Stein geschoben wird und ein Hebelpunkt an der richtigen Stelle ist, kannst du am langen Ende des Stocks ziehen, und das kurze Ende unter dem Stein hat erheblich mehr Kraft. Du ziehst mit einer geringen Kraft, und die Mechanik des Hebels wendet eine größere Kraft auf den Stein an.
In der Elektronik ist ein MOSFET hierfür eine Methode. Ein MOSFET ist ein elektronischer Schalter, der mit wenig Strom gesteuert werden, im Gegenzug aber sehr viel mehr Strom steuern kann. Ein MOSFET hat drei Pins. Du kannst dir einen MOSFET als Schalter zwischen zwei seiner Pins (Drain und Source) vorstellen, der von einem dritten Pin (Gate) gesteuert wird. Er ist so etwas wie ein Lichtschalter, bei dem das Gate durch das Teil, das du zum Ein- und Ausschalten des Lichts bewegst, repräsentiert wird. Ein Lichtschalter ist mechanisch, wird durch einen Finger gesteuert, aber ein MOSFET ist elektronisch, wird durch einen Pin von deinem Arduino gesteuert.
MOSFET steht für »Metalloxid-Halbleiter-Feldeffekttransistor«. Er ist ein spezieller Typ Transistor, der nach dem Feldeffektprinzip funktioniert. Das bedeutet, dass Strom durch ein Stück Halbleitermaterial (zwischen den Drain- und Source-Pins) fließt, wenn Spannung auf den Gate-Pin angewandt wird. Da das Gate durch eine Schicht Metalloxid vom Rest isoliert ist, fließt kein Strom vom Arduino in den MOSFET, wodurch er sehr leicht zu koppeln ist. MOSFETs sind ideal zum Ein- und Ausschalten großer Lasten bei hoher Frequenz.
In Abb. 5–7 siehst du, wie du einen MOSFET wie den IRF520 zum Ein- und Ausschalten eines an einem Ventilator angeschlossenen Motors einsetzen könntest. In dieser Schaltung nimmt der Motor seinen Strom tatsächlich vom VIN-Anschluss auf dem Arduino-Board, der für eine Spannung zwischen 7 und 12 Volt vorgesehen ist. Das ist ein weiterer Vorteil des MOSFET: Er erlaubt uns die Steuerung von Geräten, die eine andere Spannung als die vom Arduino verwendeten 5 V benötigen.
Die schwarze Komponente mit dem weißen Band drumherum ist eine Diode, und in dieser Schaltung wird sie zum Schutz des MOSFET verwendet.
Praktischerweise können MOSFETs sehr schnell ein- und ausgeschaltet werden, sodass du dennoch PWM zum Steuern einer Lampe oder eines Motors über einen MOSFET verwenden kannst. In Abb. 5–7 ist der MOSFET am Stift 9 angeschlossen, sodass du analogWrite() zum Steuern der Drehzahl des Motors über PWM verwenden kannst. (Denk dran, dass nur die Pins 3, 5, 6, 9, 10 und 11 mit analogWrite() genutzt werden können.)
Zum Bau der Schaltung benötigst du einen IRF520-MOSFET und eine 1N4007-Diode. Wenn sich der Motor zufällig während des Hochladens dreht, ordne einen 10-kΩ-Widerstand zwischen Pin 9 und GND an5.
In Kapitel 8 lernst du das Relais kennen, eine weitere Methode zum Steuern von Geräten, die mehr Strom benötigen.
Wir definieren komplexe Sensoren als solche, die ihre Informationen auf eine Art und Weise liefern, dass sie nicht mit digitalRead() oder analogRead() allein gelesen werden können. Diese Sensoren haben in der Regel eine vollständige interne Schaltung, möglicherweise mit ihrem eigenen Mikrocontroller. Einige Beispiele für komplexe Sensoren sind digitale Temperatursensoren, Ultraschall- und Infrarot-Abstandssensoren sowie Beschleunigungsmesser. Ein Grund für diese Komplexität könnte sein, mehr Information oder Genauigkeit zu erreichen; beispielsweise haben manche Sensoren eindeutige Adressen, damit man viele Sensoren an denselben Drähten anschließen und trotzdem jeden einzeln um Meldung seiner Daten bitten kann.
Zum Glück bietet Arduino eine Vielfalt an Mechanismen zum Lesen dieser komplexen Sensoren. Du wirst einige von ihnen in Kapitel 8 sehen unter »Testen der Echtzeituhr (RTC)« auf Seite 111 zum Ablesen einer Echtzeituhr und unter »Testen des Temperatur- und Feuchtigkeitssensors« auf Seite 131 zum Ablesen eines Temperatur- und Feuchtigkeitssensors.
Weitere Beispiele findest du auf der Arduino-Website, indem du nach »Tutorials« sowie unter Community Project Hub suchst.
Tom Igoes Making Things Talk, 3. Auflage (Make Community LLC 2017, in englischer Sprache), deckt einen weiten Bereich komplexer Sensoren ab.
Abb. 5–7Eine Motorschaltung für Arduino
In den vorangegangenen Kapiteln hast du die Grundlagen von Arduino und die dir zur Verfügung stehenden Basisbausteine kennengelernt. Lass uns nun sehen, was das »Arduino-Alphabet« ausmacht.
Digitaler Ausgang
Wir haben ihn zum Steuern einer LED verwendet, aber mit der richtigen Schaltung kann er zum Steuern von Motoren, zum Erzeugen von Sounds und für vieles mehr genutzt werden.
Analoger Ausgang
Dieser bietet uns die Möglichkeit, die Helligkeit der LED zu steuern, sie also nicht nur ein- oder auszuschalten. Wir können sogar die Drehzahl eines Motors mit ihm steuern.
Digitaler Eingang
Dieser erlaubt uns das Ablesen des Zustands von Sensoren, die einfach nur ja oder nein sagen, wie Drucktastschalter oder Neigungsschalter.
Analoger Eingang
Wir können Signale von Sensoren lesen, die mehr Informationen als lediglich ein oder aus haben, wie ein Potenziometer, das uns mitteilen kann, wie weit es gedreht wurde, oder ein Lichtsensor, der uns sagen kann, wie viel Licht auf ihn scheint.
Serielle Kommunikation
Diese erlaubt uns die Kommunikation mit einem Computer und den Austausch von Daten oder einfach das Beobachten des Sketches, der auf dem Arduino läuft.
Jetzt, da du das Alphabet erlernt hast, können wir mit dem Schreiben der Poesie beginnen!
