Tinkercad Übung 6 - LED mit Taster ansteuern

Zustand eines Tasters auslesen

In dieser Übung liest du den Zustand eines Tasters aus und sendest diesen an den Serial Monitor. Dann steuerst du die LED damit.

Empfohlenes Vorwissen: Bedienung Tinkercad Circuits, LED, LED-Vorwiderstand, Taster, Schaltpläne.
Neue Inhalte: Daten an den Serial Monitor senden, Pin als Eingang konfigurieren und einlesen, Pullup, Pulldown, Taster auslesen, Rückgabewert eines Befehls als Parameter für einen anderen Befehl verwenden.

Schritt 1 - Werte im Serial Monitor ausgeben

In Übung 1 und Übung 4 hast du den Serial Monitor schon einmal benutzt. Jetzt werden wir ein Programm schreiben, dass wir in den Arduino herunterladen und dass von dort aus Text an unseren Rechner sendet. Dieser Text wird im Serial Monitor zu sehen sein.

Erstelle einen neuen Entwurf und füge einen "Arduino Uno R3" hinzu. Du musst erstmal nichts verdrahten; du programmierst nur.

Öffne den "Code"-Editor im Text-Modus und lösche alle Befehle, sodass nur noch die leeren setup()- und loop()-Bereiche übrig bleiben. In setup() füge folgenden Code hinzu:

Serial.begin(9600);
Serial.println('a');

Das einfache Anführungszeichen ' befindet sich mit auf der Hastag-Taste.

Öffne das "Serial Monitor" Fenster und starte die Simulation.

Der Befehl Serial.begin(9600) initialisiert den Serial Monitor mit einer Übertragungsgeschwindigkeit von 9600 Baud, also 9600 Bits werden pro Sekunde zwischen Arduino und Rechner übertragen. Man kann auch andere Geschwindigkeiten wählen, zum Beispiel funktioniert auch 115200 Bits/Sekunde. Ist der Serial Monitor nicht vorher initialisiert worden, können keine Daten übertragen werden.
Der Befehl Serial.println('a') sendet das Zeichen "a" an den Rechner und beginnt dann eine neue Zeile.

Lies dir die Beschreibung dieser beiden Befehle in der Arduino-Referenz durch:

https://www.arduino.cc/reference/de/language/functions/communication/serial/

Versuche mal, was passiert, wenn du den Befehl Serial.println('a') mehrere Male hintereinander einsetzt. Schreibe auf diese Weise "Hallo".

Jetzt stehen die einzelnen Zeichen untereinander. Das kannst du ändern. Es gibt noch einen Befehl, der fast genauso heißt: Serial.print(). Dieser fängt nach dem Buchstaben keine neue Zeile an.

Serial.println(): sprich "Serial Print Line": gibt eine ganze Zeile aus (inklusive ENTER)
Serial.print(): sprich "Serial Print": gibt einfach nur was aus (ohne ENTER).

Benutze Serial.print(), um das Wort "Hallo" in eine Zeile zu schreiben anstatt untereinander.

Man kann auch Sonderzeichen verwenden, zum Beispiel:

'\n': Zeilenumbruch / ENTER / das, was Serial.println() automatisch am Ende jeder Zeile macht.
'\t': TAB
'\'': einfaches Anführungszeichen (' kann nicht direkt verwendet werden, da es ja schon eine besondere Bedeutung hat, nämlich ein Einzel-Zeichen zu umschließen)
'\"': doppeltes Anführungszeichen (" kann nicht direkt verwendet werden, da es ja schon eine besondere Bedeutung hat, nämlich einen Text zu umschließen)

Backslash \ befindet sich mit auf der "?"-Taste.

Schreibe das Wort "Hallo" in Anführungszeichen und davor einen TAB und füge einen Zeilenumbruch hinzu, sodass folgendes ausgegeben wird:

"Hal

lo"

Jetzt ist es reichlich umständlich, jedes Zeichen einzeln zu übermitteln. Dafür gibt es Abhilfe, denn Serial.print() und Serial.println() verstehen auch Text. Dafür muss man dann doppelte Anführungszeichen verwenden: Serial.println("Hallo"). Auch Zahlen zu übertragen ist möglich. In dem Fall benötigt man gar keine Anführungszeichen. Einzel-Zeichen, Text und Zahlen können nicht gemischt werden, sondern es muss für jeden Datentyp immer einzeln Serial.print() oder Serial.println() verwendet werden.

Serial.print('a'); Einzel-Zeichen, in einfache Anführungszeichen einschließen
Serial.print("Hallo"); mehrere Zeichen, in doppelte Anführungszeichen einschließen
Serial.print(2); Ganzzahl: keine Anführungszeichen
Serial.print(10.3); Kommazahl: keine Anführungszeichen und als Komma muss ein Punkt verwendet werden (Weil das bei den Ammis so gemacht wird).

Das "Serial." bedeutet, dass die Befehle "print()" und "println()" zur "Serial"-Bibliothek gehören. Dazu aber später mehr.

Probiere mal alle Datentypen aus (siehe Abbildung 1).

Lösungsvorschlag: https://www.tinkercad.com/things/hZfUGRigQDB-kkg-robotik-ubung-6-serialprintln

Probiere mal aus was passiert, wenn du einen Umlaut oder ß verwendest. Diese kommen im amerikanischen Alphabet nicht vor und dürfen generell beim Programmieren nicht verwendet werden (außer in Kommentaren, aber dazu später mehr).

Abbildung 1 - Zahlen und Buchstaben auf dem Serial Monitor ausgeben

Schreibe ein Programm, dass in den Serial Monitor schreibt:

Sagt die 0 zur 8: "Schicker Gürtel!"

Lösungsvorschlag: https://www.tinkercad.com/things/1F2LY61365i-kkg-robotik-ubung-6-flachwitz

Abbildung 2 - Flachwitz

Schritt 2 - Einen Pin als Eingang konfigurieren und auslesen

Erstelle einen neuen Entwurf. Man muss nicht immer alle Schaltungen von vorn aufbauen. Glücklicherweise bietet Tinkercad sogenannte "Starter" an, also fertige Beispielschaltungen.

Wähle im Auswahlfeld "Komponenten" "Starter Arduino" aus und füge "Steckplatine" hinzu. Es erscheint ein Arduino, dessen 5V und GND Pin bereits an eine Steckplatine angeschlossen sind. Diese ist also bereits mit 5V Spannungs versorgt.

Öffne den "Code"-Editor und lösche alle Befehle, sodas nur noch setup() und loop() übrig bleiben.

Abbildung 3 - Starter verwenden

Baue folgende Schaltung auf:

Abbildung 4 - Schaltung - Pin 2 an 5V

Der Schaltplan dazu ist in Abbildung 5 dargestellt. Der Arduino wird durch das USB-Kabel mit 5V versorgt und versorgt damit Pin 13, sobald dieser eingeschaltet wird. Dann kann ein Strom fließen und LED1 leuchtet. An Pin 2 wirst du später einen Taster anschließen, um auszulesen, ob dieser gedrückt ist oder nicht. Momentan ist Pin 2 aber direkt an 5V vom Arduino angeschlossen, dem Plus-Pol des USB-Kabels. Wenn du den Pin also ausliest, wird dort 5V gemessen. Das entspricht AN.

Abbildung 5 - Schaltplan Arduino als USB-Spannungsversorgung, Pin 2 an 5V

Füge folgenden Programmcode in den setup()-Bereich hinzu:

Serial.begin(115200);
pinMode(2, INPUT);

Serial.begin() kennst du bereits. Es initialisiert den Serial Monitor. Diesmal mit einer schnelleren Übertragungsgeschwindigkeit von 115200 Bis/Sekunde.
pinMode(2, INPUT) hast du schon mal in Übung 5 mit dem Parameter OUTPUT verwendet. Dieser Befehl konfiguriert Pin 2 als Eingang, d.h. es geht eine Information in den Arduino hinein und sie kann im Programm verwendet werden.

Füge folgenden Programmcode in den setup()-Bereich hinzu:

Serial.println( digitalRead(2) );

digitalRead(2) liest den momentanen Zustand von Pin 2. Das kann entweder AN (1) oder AUS (0) sein.

Öffne den Serial Monitor und starte die Simulation. In welchen Zustand befindet sich Pin 2 gerade?

Lösungsvorschlag: https://www.tinkercad.com/things/63Nqh5Jp6oI-kkg-robotik-ubung-6-starter

Die Befehlszeile ist ein wenig komplizierter. Wie bei Mathe auch werden erst die inneren Klammern ausgewertet und dann arbeitet sich das Programm zu den äußeren Klammern vor. Wie in Abbildung 5 gezeigt, ist Pin 2 gerade mit 5V verbunden. 5V entspricht AN. Ist der Arduino also mit dem Befehl digitalRead(2) fertig, wird er durch seinen Rückgabewert (0 oder 1) ersetzt und es steht dort:

Serial.println( 1 );

Dann erst wird Serial.println() ausgeführt mit dem Rückgabewert von digitalRead(). Das siehst du ja auch im Serial Monitor.

Schaue dir die Beschreibung von digitalRead() in der Arduino-Referenz an, besonders das Kapitel "Rückgabewert":

https://www.arduino.cc/reference/de/language/functions/digital-io/digitalread/

Schließe Pin 2 nun an GND an.

Abbildung 6 - Schaltung - Pin 2 an GND

Der Schaltplan dazu ist in Abbildung 7 dargestellt. D2 ist nun mit GND verbunden, also mit dem Minus-Pol des USB-Kabels.

Abbildung 7 - Arduino als USB-Spannungsversorgung, Pin 2 an GND

Öffne den Serial Monitor und starte die Simulation. In welchen Zustand befindet sich Pin 2 gerade?

Schritt 3 - Pullup

Soweit so gut! Jetzt soll Pin 2 ja eigentlich den Zustand eines Tasters messen. Ein Taster hat den Zustand OFFEN oder GESCHLOSSEN, also nix mit 5V oder GND. Wir müssen es irgendwie schaffen, dass der Taster den Pin zwischen 5V und GND umschaltet.

Abbildung 8 zeigt da mal einen Versuch.

Wird Taster S1 gedrückt und damit geschlossen, verbindet er Pin 2 mit GND. Das entspräche 0.
Ist der Taster allerdings offen, ist Pin 2 mit nichts mehr verbunden. Wir haben aus Versehen eine kleine Antenne gebaut. Bei einem echten Arduino könnte man an diesen Draht an Pin 2 einfach ein Stück Alufolie anbringen und hätte sich damit einen Touch-Sensor gebaut. Das ist aber nicht was wir momentan wollen. Wir wollen keine Signale einfangen und auch nicht auf Berührungen reagieren. Das ist kein stabiler Zustand. Ein stabiler Zustand wäre AN (1). Es muss also irgendwie dafür gesorgt werden, dass Pin 2 immer mit irgendwas verbunden ist.

Abbildung 8 - Taster nach GND

Ok, dann packen wir den Taster S1 halt noch an 5V mit ran.

Wenn S1 offen ist, ist Pin 2 nicht mehr offen, sondern mit 5V verbunden. Das entspricht (1). Top!
Wenn wir den Schalter S1 schließen, verbinden wir allerdings Arduino 5V durch S1 hindurch mit Arduino GND. Das ist ein geschlossener Stromkreis ohne Widerstand, also ein Kurzschluss. Der Arduino könnte dabei sogar kaputt gehen. Abbildung 9 zeigt diesen Versuch.

Abbildung 9 - Kurzschluss

Nächster Versuch: Wir wollen ja keinen Kurzschluss, aber irgendwie Pin 2 mit 5V verbinden, wenn Taster S1 offen ist. Zur Strombegrenzung eignet sich ein Widerstand (siehe Abbildung 9).

Ist der Schalter offen, wird Pin 2 über R2 mit 5V verbunden und es wird 5V gemessen (1). Sehr gut!
Wenn S1 geschlossen wird, ist Pin 2 sowohl mit 5V als auch mit GND verbunden. Da zwischen Pin 2 und GND aber kein Widerstand ist, "gewinnt" GND gegen 5V und der Zustand ist (0).

Durch den Widerstand R2 haben wir nun keinen Kurzschluss mehr. Es eignen sich sehr große Widerstände wie z.B. 1 kΩ oder 10 kΩ, da ja wenig Strom fließen soll.

Der Zweig mit dem mit Abstand geringeren Widerstand "gewinnt" und erzwingt den Zustand von Pin 2:

Wären in beiden Zweigen jeweils ein Widerstand von 1 kΩ, würde kein Zweig gewinnen. Das wäre kein eindeutiger Zustand.
Wäre im oberen Zweig 10 kΩ und im unteren nur 1 kΩ, würde der untere gewinnen, da dort 10x so viel Strom fließen kann.

Solch ein Widerstand nennt sich "Pullup" (sprich Pull Up) Widerstand, da er den Zustand von Pin 2 "weich" nach oben zu 5V zieht. Wird der Schalter geschlossen, wird Pin 2 zusätzlich noch "hart" nach GND gezogen. Hart gewinnt gegen weich.

Abbildung 9 - Taster nach GND mit Pullup

Bau dies in Tinkercad auf, öffne den Serial Monitor und starte die Simulation. Was wird gemessen? Was passiert, wenn du den Taster drückst?

Abbildung 10 - Taster mit Pullup-Widerstand

Zu deinem Erschrecken hast du bestimmt gerade bemerkt, dass der Serial Monitor ja nur einmal am Anfang einen Wert ausgibt und der ist immer "1", weil der Taster zu Simulationsbeginn offen ist und wir ihn nicht schnell genug drücken können.

Verschiebe den Serial.println()-Befehl in den loop()-Bereich, damit er wiederholt ausgeführt wird. Starte die Simulation, öffne den Serial Monitor und betätige den Taster.

Lösungsvorschlag: https://www.tinkercad.com/things/0Ypmk6o0r0d-kkg-robotik-ubung-6-pullup

Schritt 4 - Pulldown

Ich meinte zwar jetzt macht die Schaltung genau, was wir wollen, aber das stimmt ja gar nicht:

Taster geschlossen → Zustand=0
Taster offen → Zustand=1

Das ist anders herum als man es eigentlich erwarten würde. Wird ein Taster gedrückt, sollte ja irgendwas AN gehen.

Wir wollen das Verhalten also invertieren (umkehren). Dazu müssen wir die Schaltung quasi spiegeln, d.h. der Pullup Widerstand (nach 5V) wird zum Pulldown Widerstand (nach GND) und der Taster wird anstatt an GND and 5V angeschlossen wie in Abbildung 11 gezeigt:

Abbildung 11 - Pulldown

Bau die Schaltung in Tinkercad so um, öffne den Serial Monitor und starte die Simulation.

Lösungsvorschlag: https://www.tinkercad.com/things/2vXIk5quiAx-kkg-robotik-ubung-6-pulldown

Schritt 5 - LED mit Taster steuern

Nun zum Finale: Konfiguriere den LED-Pin (im Lösungsvorschlag Pin 13) als Ausgang. Ersetze die Zeile

Serial.println(digitalRead(2));

durch

digitalWrite(13, digitalRead(2));

digitalRead(2) wird zuerst ausgeführt, liegst den Zustand von Pin 2 und gibt diesen zurück (entweder 0 oder 1).
digitalRead() wird durch seinen Rückgabewert ersetzt (0 oder 1).
digitalWrite() wird dann ausgeführt und benutzt den Rückgabewert von digitalRead(), um Pin 13 entweder ein- oder auszuschalten.

Starte die Simulation und betätige den Taster.

Lösungsvorschlag: https://www.tinkercad.com/things/elCROX38wpE-kkg-robotik-ubung-6-led-und-taster

Abbildung 12 - Fertig

Zusammenfassung

Du weißt nun wie du Werte vom Arduino an den Serial Monitor sendest, wie du einen Eingangs-Pin ausliest, dass es 2 Varianten gibt einen Taster an einen Eingangs-Pin anzuschließen und wie du den Rückgabewert eines Befehls and einen anderen Befehl weitergibts.

Weiter zu Übung 7

Beiträge durchsuchen

KKG Robotik