Nachdem wir in der ersten Lektion bereits gelernt haben, wie man eine oder mehrere LEDs zum Blinken bringt, schauen wir uns nun ein weiteres wichtiges Bauteil in der Mikroelektronik an: den Taster.
Ähnlich wie Leuchtdioden findest du Taster an ganz vielen Stellen in deinem alltäglichen Leben wieder. Zum Beispiel auf deinem Weg zur Schule, wo du einen Taster dafür verwendest, die Fußgängerampel zu betätigen.
Wenn wir den Taster auf unserem Funduino Cube drücken, soll die rote Leuchtdiode aufleuchten.
Sobald wir den Taster wieder loslassen, soll die rote LED aufhören zu leuchten.
Für den ersten Schritt unserer Aufgabe müssen wir in die ROBOTERKONFIGURATION von OpenRoberta navigieren.
Den entsprechenden Menüpunkt siehst du auf der nachfolgenden Abbildung.
Wenn du auf das Feld ROBOTERKONFIGURATION geklickt hast, erscheint jetzt auf der linken Bildschirmseite ein neues Menü.
In diesem Menü klicken wir jetzt den Menüpunkt „Sensoren„ an.
Durch den Klick auf den Menüpunkt Sensoren öffnet sich ein zusätzliches Menü mit grünem Hintergrund.
In diesem Menüpunkt findest du den Block für den Taster wieder.
Du fügst diesen Block zu deiner ROBOTERKONFIGURATION hinzu, indem du auf den Block klickst, dabei die linke Maustaste gedrückt hältst, du den Block in das weiße Feld ziehst.
Wunderbar! Wenn deine ROBOTERKONFIGURATION jetzt so aussieht, wie du es auf der folgenden Abbildung erkennen kannst, hast du alles richtig gemacht.
Wir schauen uns jetzt den Block ein wenig genauer an.
In der ersten Zeile des Blocks findest du die Worte „Taste“ und daneben den Buchstaben „T“. Das „T“ steht für den Namen deines Tasters. Du kannst diesen Namen beliebig anpassen – für den Anfang belassen wir es jedoch bei dem Buchstaben „T“.
„T“ für „Taster“, das passt doch gut, oder?
Spannender wird es in der zweiten Zeile des Blocks. Dort findest du neben dem Wort „pin“ die Bezeichnung „D2“. Diese Bezeichnung legt fest, an welchem digitalen Pin („D“ steht also für Digital) wir den Taster mit dem Mikrocontroller verbunden haben.
Jetzt ist es also eine gute Gelegenheit, einen Blick auf den Funduino Cube zu werfen.
Kannst du erkennen, an welchem digitalen Pin der Taster auf dem Cube mit dem Mikrocontroller verbunden ist?
Na klar, richtig! Das ist natürlich der Pin „D9“.
Wir müssen in dem Block also eine Änderung vornehmen. Das machen wir, indem wir mit der linken Maustaste in das Feld „D2“ klicken und den richtigen Pin „D9“ auswählen. Du bestätigst deine Auswahl mit einem Klick der linken Maustaste.
Wenn du alles richtig gemacht hast, sieht der Block jetzt so aus wie in der nachfolgenden Abbildung.
In der ersten Zeile steht der Name des Tasters „T“, welchen wir nicht verändert haben.
In der zweiten Zeile ist nun der richtige digitale Pin „D9“ ausgewählt.
In der dritten Zeile, über die wir bis hierhin noch gar nicht gesprochen haben, steht 5V. Diese dritte Zeile gibt an, mit welcher Spannung der Taster betrieben wird. Wenn du in das Feld 5V klickst, wirst du feststellen, dass du dieses Feld nicht verändern kannst.
Wir sind deshalb mit der Konfiguration des Tasters fertig. Herzlichen Glückwunsch!
Aber mal ehrlich: Was können wir mit einem Taster anfangen, der bei einem Tastendruck gar nichts bewirkt?
Deshalb möchten wir jetzt noch eine LED hinzufügen, die beim Tastendruck aufleuchten soll.
Dies gelingt uns, indem wir auf den Menüpunkt „Aktion„ auf der linken Bildschirmseite klicken.
Wie man eine LED zur ROBOTERKONFIGURATION hinzufügt, hast du bereits in der ersten Lektion gelernt. Trotzdem schauen wir uns den Vorgang jetzt noch einmal genauer an.
Nach dem Klick auf den Menüpunkt Aktion öffnet sich ein neues Fenster mit orangefarbenem Hintergrund.
In diesem Menüpunkt findest du, wenn du ein wenig mit dem Mausrad herunterscrollst, den Block für die LED.
Diesen Block ziehst du durch einen Klick mit der linken Maustaste, bei dem du die Maustaste gedrückt hältst, in das weiße Feld rechts daneben.
Deine ROBOTERKONFIGURATION sollte jetzt so wie in der nachfolgenden Abbildung aussehen.
Jetzt folgt ein Schritt, den du bereits in der Lektion 1 kennengelernt hast.
Dort haben wir gelernt, dass wir dem Mikrocontroller beibringen müssen, an welchem Pin die LED mit dem Controller verbunden ist.
Na, erinnerst du dich daran, wie das geht?
Richtig! Wir klicken zunächst mit der linken Maustaste auf das Feld „Port intern“ im Block der LED.
Aber Moment: welche LED möchten wir überhaupt mit dem Mikrocontroller ansteuern? In diesem Aufbau verwenden wir die rote LED.
Wir müssen also zuerst auf unseren Funduino Cube schauen und herausfinden, welcher digitale Pin für die rote LED festgelegt ist.
Kannst du erkennen, an welchem Pin die rote LED mit dem Mikrocontroller verbunden ist?
Das war einfach: natürlich ist die rote LED mit dem Pin „D12“ verbunden.
Wir wählen in dem Menü also „D12“ aus und bestätigen unsere Auswahl mit einem Klick auf die linke Maustaste.
Toll gemacht! Deine ROBOTERKONFIGURATION sieht jetzt so aus wie auf dem nächsten Bild.
Fast hätten wir jedoch etwas vergessen. Kannst du erkennen, welchen Schritt wir vergessen haben?
Genau! Wir haben unserer LED noch gar keinen Namen gegeben.
Ohne den richtigen Namen fällt es uns später bestimmt schwer, uns in unserem Programm zu orientieren.
Den Namen für diesen Block können wir vergeben, indem wir auf das „L“ neben dem Wort „LED“ klicken.
Hier tragen wir jetzt das Wort „rot“ ein.
So wissen wir später, dass die rote LED mit diesem Block angesteuert wird.
Super! Wir haben unsere ROBOTERKONFIGURATION jetzt abgeschlossen.
Gleiche jetzt deine ROBOTERKONFIGURATION mit dem nachfolgenden Bild ab. Wenn alles übereinstimmt, können wir mit dem Programm beginnen.
Frage: Welche Änderungen müsstest du vornehmen, wenn du anstelle der roten LED eine grüne LED zum Leuchten bringen möchtest?
Tipp: Es müssen genau zwei Änderungen vorgenommen werden.
Für unseren ersten Schritt wechseln wir wieder in unser Programm. Den Menüpunkt findest du oberhalb der weißen Fläche.
Sobald du dich in der Programmansicht befindest, siehst du den Baustein auf der nachfolgenden Abbildung.
Dieser Baustein wird auch „loop“, also auf Deutsch „Schleife“ genannt.
Die Schleife heißt deswegen so, weil Programminhalte, die sich innerhalb der Klammer befinden, wiederholt werden.
Diese Schleife möchten wir zunächst erweitern.
Wir starten dabei nicht direkt mit dem Block für den Taster oder unserer roten LED, sondern mit einer weiteren Anweisung.
Warum wir das machen, erklären wir dir ein wenig später.
Den Baustein für die Anweisung findest du im Menü auf der linken Seite. Klicke hierfür mit der linken Maustaste auf den Block „Kontrolle“. In der Informatik ist eine Anweisung eine sogenannte „Kontrollstruktur“. Kontrollstrukturen ermöglichen es einem Programm, in Abhängigkeit von einer Eingabe, etwas zu erfüllen.
Zum Beispiel: „Wenn der Taster gedrückt ist, dann schalte die LED an“
Jetzt öffnet sich ein neues Menü mit orangefarbenem Hintergrund.
Deine Oberfläche in OpenRoberta müsste jetzt so aussehen, wie auf der nachfolgenden Abbildung dargestellt.
In dieser Oberfläche findest du eine ganze Reihe verschiedener Schleifen.
Neben dem „loop“, den du etwas weiter vorn schon kennengelernt hast, gibt es eine ganze Reihe verschiedener Kontrollstrukturen.
Diese Schleifen helfen Programmierern wie dir und uns dabei, sogenannte Bedingungen festzulegen.
Noch einmal zur Erinnerung. Wir möchten folgende Aufgabenstellung umsetzen:
„Wenn der Taster gedrückt wird, soll die rote LED leuchten.
Sonst soll die rote LED nicht leuchten.“
Diese Bedingung finden wir in unserer Oberfläche wieder.
Wir klicken den Block also mit der linken Maustaste an, halten diese gedrückt und ziehen ihn in die weiße Fläche.
Gut gemacht! Wir haben soeben unsere erste richtige Schleife kennengelernt.
Die Schleife, die du jetzt verwendest, wird auf „if-else-Bedingung“ genannt. Zu Deutsch: „Wenn-sonst-Bedingung“.
Jetzt müssen wir nur noch den Taster und unsere rote LED zu unserem Programm hinzufügen.
Wir starten zuerst mit dem Taster.
Den Taster findest du in dem Menü auf der linken Bildschirmseite unter dem Menüpunkt „Sensoren“. Wir klicken also mit unserer linken Maustaste auf „Sensoren“.
Es öffnet sich eine neue Oberfläche, diesmal allerdings mit einem grünen Hintergrund.
In diesem Menü suchen wir jetzt unseren Taster.
Na, kannst du den Block für den Taster in der nachfolgenden Abbildung finden?
Hervorragend!
Wir klicken also wieder mit der linken Maustaste auf den Block für den Taster, halten die Maustaste gedrückt und ziehen den Block in das weiße Feld.
Jetzt müssen wir uns eine wichtige Frage stellen: an welcher Stelle im Programm wird eigentlich abgefragt, ob der Taster gedrückt wird?
„Wenn der Taster gedrückt wird, soll die rote LED leuchten.
Sonst soll die rote LED nicht leuchten.“
Der Block muss also neben das „wenn“ in unserer Schleife gehängt werden.
Dein Programm sollte jetzt so aussehen, wie auf der nachfolgenden Abbildung.
Würden wir unser Programm jetzt direkt übersetzen, würde dies aussagen:
„Wenn der Taster gedrückt wird, …“.
Den ersten Teil unserer Aufgabe haben wir damit geschafft. Toll gemacht!
Jetzt fehlt eigentlich nur noch unsere rote LED. Wie wir die rote LED in unserem Programm ergänzen, könntest du mittlerweile schon wissen.
Falls nicht, schaue dir die Lektion 1 noch einmal an.
Kleiner Tipp: den Block findest du im Menü auf der linken Seite unter dem Punkt „Aktion“ wieder.
„Wenn der Taster gedrückt wird, soll die rote LED leuchten.
Sonst soll die rote LED nicht leuchten.“
Den ersten Teil der Aufgabenstellung haben wir somit bereits umgesetzt:
„Wenn der Taster gedrückt wird, soll die rote LED leuchten. …“
Wir müssen in dem Programm also noch ergänzen, dass die rote LED sonst nicht mehr leuchten soll.
Toll gemacht! Wir machen großartige Fortschritte.
Jetzt ist ein guter Zeitpunkt, um unser Programm einmal auf den Funduino Cube zu überspielen.
Haben wir unser Ziel erreicht?
Mist! Leider haben wir unser Ziel noch nicht erreicht.
Um den Fehler ausfindig zu machen, versuchen wir, unser Programm erneut in unsere Sprache zu übersetzen.
„Wenn der Taster gedrückt wird, soll die rote LED leuchten.
Sonst soll die rote LED nicht leuchten.“
„Sonst auch.„? Das ist nicht ganz richtig!
Wir klicken mit der linken Maustaste also in das Feld „an“ des unteren Blocks für die rote LED und wählen hier „aus“ aus.
„Wenn der Taster gedrückt wird, soll die rote LED leuchten.
Sonst soll die rote LED nicht leuchten.“
Tolle Arbeit! Unser Programm liest sich jetzt genauso, wie es die Aufgabenstellung wünscht.
Es wird also höchste Zeit, dass wir das Programm erneut auf den Funduino Cube überspielen.
Frage: Was würde passieren, wenn du das Programm um den Block „Warte ms“ ergänzt. Du findest den Block im linken Menü unter dem Menüpunkt „Kontrolle“.
Du erinnerst dich bestimmt noch an den Begriff „Variable“, den wir in der ersten Lektion kennengelernt haben.
Eine Variable ist vergleichbar mit einem Informationsspeicher, in welchem wir Informationen zwischenspeichern und bei Bedarf abrufen können.
Im ersten Schritt definieren wir zuerst unsere Variablen als Ganzzahl, auch als „Integer“ bezeichnet.
Diese Variablen dienen dazu, die Pin-Nummern unserer Module zu speichern.
Die rote LED ist mit dem Pin D10 des Mikrocontrollers auf unserem Funduino Cube verbunden. Der Taster an Pin D9.
/* Variablen - Bauteile */
int modul_taster = 9;
int modul_led_rot = 12;
Um den Status unseres Tasters zu überwachen, erstellen wir eine Variable namens „taster_status“. Dieser Variable weisen wir den Startwert 0 zu.
Die Variable ermöglicht es uns, den aktuellen Taster-Status während der Programmausführung abzufragen.
/* Variablen - Bauteile */
int modul_taster = 9;
int modul_led_rot = 12;
/* Variablen - Hilfe */
int taster_status = 0;
Jetzt, da alle Variablen einsatzbereit sind, ist es an der Zeit, sich um die Ein- und Ausgänge zu kümmern. LEDs sind immer Ausgänge, da wir Spannung vom Arduino zur LED schicken.
/* Variablen - Bauteile */
int modul_taster = 9;
int modul_led_rot = 12;
/* Variablen - Hilfe */
int taster_status = 0;
/* setup */
void setup()
{
pinMode(modul_led_rot, OUTPUT);
}
Um einen Taster zu verwenden, muss der entsprechende Pin als Eingang (Input) deklariert werden. Durch das Auswerten des eingehenden Spannungssignals kann der Mikrocontroller auf dem Funduino Cube erkennen, wann der Taster gedrückt wird.
Wir schreiben dafür den Ausdruck „INPUT“ statt „OUTPUT“ im „pinMode„ Befehl.
/* Variablen - Bauteile */
int modul_taster = 9;
int modul_led_rot = 12;
/* Variablen - Hilfe */
int taster_status = 0;
/* setup */
void setup()
{
pinMode(modul_taster, INPUT);
pinMode(modul_led_rot, OUTPUT);
}
Um auszuwerten, ob der Taster gedrückt worden ist, verwenden wir jetzt den Befehl „digitalRead„.
Die Nutzung des „digitalRead„-Befehls unterscheidet sich etwas von der Verwendung des „digitalWrite„-Befehls.
Mit dem „digitalWrite„-Befehl gibt der Mikrocontroller an dem entsprechenden digitalen Pin eine Spannung aus. Dadurch können wir z.B. eine Leuchtdiode ein- oder ausschalten.
Beim „digitalRead„ läuft es genau umgekehrt. Der Mikrocontroller fragt den im „digitalRead„-Befehl hinterlegten digitalen Pin ab. Wenn zum Beispiel eine Spannung anliegt (oder auch keine Spannung anliegt), können wir diese Information in einer Variable, unserem Informationsspeicher, zwischenspeichern. Dabei steht 1 für HIGH und 0 für LOW.
digitalRead(Modul);
Lasst uns jetzt den digitalRead-Befehl in unserem Programmcode einbetten.
Dafür müssen zwei Dinge geschehen.
Erstens: Der Pin mit dem Taster muss ausgelesen werden Liegt eine Spannung an dem Pin an, dann ist der Taster gedrückt und der Mikrocontroller erkennt den Wert „HIGH“. Ist der Taster nicht gedrückt, dann kommt keine Spannung an dem Pin an und der ausgelesene Wert ist „LOW“.
Zweitens: Der ausgelesene Wert muss in der Variablen „taster_status“ abgespeichert werden.
Diese beiden Aktionen werden im Programmcode in nur einzigen Befehl zusammengefasst:
tast_status = digitalRead(modul_taster);
Diese Zeile kann man interpretieren als:
Die Variable „Taster_Status“ ist ab jetzt das Ergebnis aus dem Ausgelesenen Pin mit dem Taster.
/* Variablen - Bauteile */
int modul_taster = 9;
int modul_led_rot = 12;
/* Variablen - Hilfe */
int taster_status = 0;
/* setup */
void setup()
{ // start setup
pinMode(modul_taster, INPUT);
pinMode(modul_led_rot, OUTPUT);
} // ende setup
/* loop */
void loop()
{ // start loop
taster_status = digitalRead(modul_taster);
} // ende loop
Um die rote Leuchtdiode immer dann einzuschalten, wenn der Taster gedrückt ist, verwenden wir jetzt erstmalig eine besondere Methode namens „If-Abfrage“.
Aber was genau ist eine If-Abfrage? In der Abbildung auf der rechten Seite könnt ihr bereits einen groben Aufbau sehen.
wenn (Bedingung) {
was soll passieren wenn unsere Bedingung erfüllt wird?
}
Eine If-Abfrage ermöglicht es uns, einen Codeabschnitt nur dann auszuführen, wenn eine bestimmte Bedingung erfüllt ist.
Wir verwenden hierfür das Schlüsselwort „if„, gefolgt von einer Klammer. Innerhalb dieser Klammer geben wir die Bedingung an, die erfüllt sein muss, damit der Codeabschnitt ausgeführt wird.
Danach öffnen wir eine geschweifte Klammer, in der wir unsere Anweisungen platzieren. Der Abschnitt wird mit einer schließenden geschweiften Klammer beendet.
if (Bedingung) {
was soll passieren?
}
Mit einer If-Abfrage können wir komplexe Problemstellungen lösen. Es handelt sich hierbei um eine einfache, logische Verknüpfung.
Auch in deinem täglichen Leben verwendest du If-Abfragen – und zwar ganz automatisch, häufig ohne es zu merken!
Vor dem Gang zur Schule stellst du bei einem Blick aus dem Fenster fest, dass graue Wolken aufziehen. Du bist unsicher, ob du einen Regenschirm mitnehmen sollst oder nicht. Deshalb blickst du in den Wetterbericht.
Falls Regen vorausgesagt wird, nimmst du einen Regenschirm mit.
Falls nicht, lässt du den Regenschirm zu Hause.
Hast du eine Idee, wie wir unsere Aufgabenstellung mit einer If-Abfrage lösen können?
if (Hohe Regenwahrscheinlichkeit) {
Bitte Regenschirm mitnehmen!
}
Wir müssen zuerst eine geeignete Bedingung formulieren.
Da die LED nur leuchten soll, wenn der Taster gedrückt wird, setzen wir dies als Bedingung fest.
Anschließend geben wir innerhalb der geschweiften Klammern die Anweisungen, dass unsere LED eingeschaltet werden soll.
if (ist der Taster gedrückt?) {
schalte die LED ein
}
Zuerst passen wir die Bedingung an. Da die LED nur leuchten soll, wenn der Taster gedrückt wurde, müssen wir eine entsprechende Überprüfung vornehmen.
Wenn der Taster gedrückt wird, speichert der Mikrocontroller den Wert 1 (HIGH) in der Variable „taster_status“ ab. Andernfalls speichert er den Wert 0.
Wir prüfen in der Bedingung, ob der Wert der Variable gleich 1 ist. Wir verwenden dazu den Variablennamen, gefolgt von zwei Gleichheitszeichen und dem Wert, den wir überprüfen möchten – in unserem Fall den Wert 1.
Würde man diese Programmzeile in unsere menschliche Sprache übersetzen, würde sie lauten: „Wenn der Tasterstatus genau gleich 1 ist.“
Innerhalb der geschweiften Klammern geben wir dann die Anweisungen an. Die LED soll für 5 Sekunden leuchten. Dazu schalten wir sie mit dem „digitalWrite„-Befehl ein, warten fünf Sekunden mithilfe des „delay„-Befehls und schalten die LED dann wieder mit dem „digitalWrite„-Befehl aus.
Vielleicht habt ihr euch gefragt, warum wir bei der If-Abfrage zwei Gleichheitszeichen verwenden. In der Programmierung dient ein einzelnes Gleichheitszeichen dazu, Werte zuzuweisen. Dies kennst du zum Beispiel von der Definition der Variablen gleich zu Beginn des Programms.
Zwei Gleichheitszeichen werden immer dann verwendet, wenn Werte miteinander verglichen werden sollen.
/* Variablen - Bauteile */
int modul_taster = 9;
int modul_led_rot = 12;
/* Variablen - Hilfe */
int taster_status = 0;
/* setup */
void setup()
{ // start setup
pinMode(modul_taster, INPUT);
pinMode(modul_led_rot, OUTPUT);
} // ende setup
/* loop */
void loop()
{ // start loop
taster_status = digitalRead(modul_taster);
if (taster_status == 1)
{ // start If
digitalWrite(modul_led_rot, HIGH);
delay(5000);
digitalWrite(modul_led_rot, LOW);
} // Ende If
} // ende loop
Als Nächstes programmieren wir eine Fußgängerampel. Den grundlegenden Programmablauf kannst du aus deinem Programm mit der Ampelschaltung übernehmen.
Dazu soll der Mikrocontroller deines Funduino Cubes während der Grünphase konstant einen Taster abfragen. Bei Betätigung des Tasters (als dem Drücken der Fußgängerampel) soll die Ampel für Autofahrer nach einer bestimmten Zeit auf Gelb und dann auf Rot schalten. Nach diesem Vorgang und einer weiteren kurzen Wartezeit schaltet die Ampel für Autofahrer erneut auf Grün.
Schalte die grüne Leuchtdiode ein. Wenn der Taster auf deinem Funduino Cube gedrückt wird, soll nach zwei Sekunden die grüne LED aus- und die gelbe LED eingeschaltet werden. Nach einer Sekunde Wartezeit soll die gelbe LED aus- und die rote LED eingeschaltet werden.
Nach weiteren fünf Sekunden Wartezeit soll die gelbe LED wieder eingeschaltet werden. Nach einer weiteren Pause von einer Sekunde soll die gelbe und die rote LED ausgeschaltet werden.
Die Roboterkonfiguration wird um einen Taster (T) erweitert. Dieser Taster wird in OpenRoberta an den digitalen Pin D9 gelegt. Die Versorgungsspannung wird mit 5V festgelegt.
Die Einstellung aus dem Aufbau 1.1.1. wird beibehalten.
Rote LED = Pin D12
Gelbe LED = Pin D11
Grüne LED = Pin D10
Auch hier möchten wir uns den Programmablauf genauer ansehen.
Die grüne LED ist im Grundzustand eingeschaltet. Daher erschient der Programblock ganz oben in der Schleife.
Es folgt eine Abfrage, ob der Taster T gedrückt wird. Wenn der Taster gedrückt wird, startet der Programmablauf in der orangefarbenen Klammer.
Dabei wird infolge des Tastendrucks eine Pause für 2000ms (2 Sekunden) eingelegt. In dieser Pause leuchtet die grüne LED weiter.
Anschließend wird die grüne LED ausgeschaltet und die gelbe LED eingeschaltet.
Es folgt eine weitere Pause von 1000ms (1 Sekunde), in welcher nur die gelbe LED leuchtet.
Danach wird die gelbe LED ausgeschaltet und die rote LED eingeschaltet.
Es folgt eine längere Pause von 5000ms (5 Sekunden), in welcher nur die rote LED leuchtet.
Im Anschluss wird die gelbe LED eingeschaltet und eine weitere Pause von 1000ms (1 Sekunde) eingelegt. Zu diesem Zeitpunkt leuchten sowohl die rote LED als auch die gelbe LED.
Unmittelbar nach dieser Pause wird die gelbe LED und die rote LED ausgeschaltet.
Frage: Warum endet das Programm mit dem Ausschalten der gelben LED und der roten LED?
Nun werden wir unser Programm aus Lektion 1 erweitern, um eine Ampelschaltung zu erstellen.
Dafür benötigen wir noch die Lichtsignale der gelben und grünen LED.
Der Variable für die gelbe LED wird der Wert 11 zugewiesen, welcher dem Pin D11 auf dem Cube entspricht.
Der Variable für die grüne LED wird der Wert 10 zugewiesen, welcher dem Pin D12 auf dem Cube entspricht.
Die Variablen für die rote LED und den Taster bleiben unverändert, genauso wie unsere Hilfsvariable 1.
/* Variablen - Bauteile */
int modul_taster = 9;
int modul_led_rot = 12;
int modul_led_gelb = 11;
int modul_led_gruen = 10;
/* Variablen - Hilfe */
int taster_status = 0;
Im Setup-Teil unseres Programms legen wir anschließend fest, dass es sich bei den Leuchtdioden um Module handelt, die über einen Signalausgang gesteuert werden („OUTPUT“).
Da bei einem Tastendruck unseres Tasters ein Signaleingang vorliegt, definieren wir diesen als („INPUT“).
Mit diesem zweiten Schritt ist die grundlegen Konfiguration erfolgreich abgeschlossen.
/* Variablen - Bauteile */
int modul_taster = 9;
int modul_led_rot = 12;
int modul_led_gelb = 11;
int modul_led_gruen = 10;
/* Variablen - Hilfe */
int taster_status = 0;
/* setup */
void setup()
{ // start setup
pinMode(modul_taster, INPUT);
pinMode(modul_led_rot, OUTPUT); // Die LED Rot ist ein Ausgang
pinMode(modul_led_gelb, OUTPUT); // Die LED Gelb ist ein Ausgang
pinMode(modul_led_gruen, OUTPUT); // Die LED Grün ist ein Ausgang
} // ende setup
Im Loop-Teil unseres Programms widmen wir uns der eigentlichen Aufgabenstellung.
Hierfür fragen wir mit dem Befehl „digitalRead„ zunächst den Tasterstatus ab und weisen diesen unserer Variable „taster_status“ zu.
Da unsere Ampelschaltung in der Grundstellung auf Grün stehen soll, schalten wir die grüne Leuchtdiode mit dem Befehl „digitalWrite“ ein.
/* Variablen - Bauteile */
int modul_taster = 9;
int modul_led_rot = 12;
int modul_led_gelb = 11;
int modul_led_gruen = 10;
/* Variablen - Hilfe */
int taster_status = 0;
/* setup */
void setup()
{ // start setup
pinMode(modul_taster, INPUT);
pinMode(modul_led_rot, OUTPUT); // Die LED Rot ist ein Ausgang
pinMode(modul_led_gelb, OUTPUT); // Die LED Gelb ist ein Ausgang
pinMode(modul_led_gruen, OUTPUT); // Die LED Grün ist ein Ausgang
} // ende setup
/* loop */
void loop()
{ // start loop
taster_status = digitalRead(modul_taster);
digitalWrite(modul_led_gruen, HIGH);
} // ende loop
Da die Ampelphasen immer dann wechseln sollen, wenn der Taster gedrückt wird, fügen wir eine „If-Abfrage“ zu unserem Programm hinzu.
Die Bedingung für unsere If-Abfrage lautet „taster_status == 1“. Wenn der Tasterstatus also 1 beträgt (also ein HIGH-Signal am Pin D9 anliegt), soll der Programmcode in der geschweiften Klammer ausgeführt werden.
/* Variablen - Bauteile */
int modul_taster = 9;
int modul_led_rot = 12;
int modul_led_gelb = 11;
int modul_led_gruen = 10;
/* Variablen - Hilfe */
int taster_status = 0;
/* setup */
void setup()
{ // start setup
pinMode(modul_taster, INPUT);
pinMode(modul_led_rot, OUTPUT); // Die LED Rot ist ein Ausgang
pinMode(modul_led_gelb, OUTPUT); // Die LED Gelb ist ein Ausgang
pinMode(modul_led_gruen, OUTPUT); // Die LED Grün ist ein Ausgang
} // ende setup
/* loop */
void loop()
{ // start loop
taster_status = digitalRead(modul_taster);
digitalWrite(modul_led_gruen, HIGH);
if (taster_status == 1)
{ // start If
} // ende If
} // ende loop
Die Aufgabenstellung sieht vor, dass zwei Sekunden nach dem Tastendruck die grüne Leuchtdiode aus- und die gelbe Leuchtdiode eingeschaltet wird.
Bei einer herkömmlichen Fußgängerampel ist dieses vorgehen üblich, damit sich alle Verkehrsteilnehmer auf die neue Situation einstellen können.
Daher beginnen wir mit dem „delay„-Befehl und verzögern dadurch den weiteren Programmablauf um 2000ms (2 Sekunden).
Anschließend schalten wir die grüne LED mit dem „digitalWrite„-Befehl aus und die gelbe LED ein. Auf diese Weise werden die Autofahrer darauf hingewiesen, dass sie in Kürze anhalten müssen.
/* Variablen - Bauteile */
int modul_taster = 9;
int modul_led_rot = 12;
int modul_led_gelb = 11;
int modul_led_gruen = 10;
/* Variablen - Hilfe */
int taster_status = 0;
/* setup */
void setup()
{ // start setup
pinMode(modul_taster, INPUT);
pinMode(modul_led_rot, OUTPUT); // Die LED Rot ist ein Ausgang
pinMode(modul_led_gelb, OUTPUT); // Die LED Gelb ist ein Ausgang
pinMode(modul_led_gruen, OUTPUT); // Die LED Grün ist ein Ausgang
} // ende setup
/* loop */
void loop()
{ // start loop
taster_status = digitalRead(modul_taster);
digitalWrite(modul_led_gruen, HIGH);
if (taster_status == 1)
{ // start If
delay(2000);
digitalWrite(modul_led_gruen, LOW);
digitalWrite(modul_led_gelb, HIGH);
} // ende If
} // ende loop
Nachdem wir die gelbe LED eingeschaltet haben, fügen wir eine weitere Pause von 1000ms (1 Sekunde) zu unserem Programm hinzu.
Anschließend schalten wir die gelbe LED aus und die rote LED ein, indem wir den „digitalWrite„-Befehl verwenden.
Es folgt eine weitere Pause von 5000ms (5 Sekunden), in welcher die Fußgänger die Straße überqueren können.
Nach Ablauf dieser Zeit geht die gelbe LED erneut an – das Zeichen für die Fußgänger, die Fahrbahn schnellstmöglich zu verlassen.
/* Variablen - Bauteile */
int modul_taster = 9;
int modul_led_rot = 12;
int modul_led_gelb = 11;
int modul_led_gruen = 10;
/* Variablen - Hilfe */
int taster_status = 0;
/* setup */
void setup()
{ // start setup
pinMode(modul_taster, INPUT);
pinMode(modul_led_rot, OUTPUT); // Die LED Rot ist ein Ausgang
pinMode(modul_led_gelb, OUTPUT); // Die LED Gelb ist ein Ausgang
pinMode(modul_led_gruen, OUTPUT); // Die LED Grün ist ein Ausgang
} // ende setup
/* loop */
void loop()
{ // start loop
taster_status = digitalRead(modul_taster);
digitalWrite(modul_led_gruen, HIGH);
if (taster_status == 1)
{ // start If
delay(2000);
digitalWrite(modul_led_gruen, LOW);
digitalWrite(modul_led_gelb, HIGH);
delay(1000);
digitalWrite(modul_led_gelb, LOW);
digitalWrite(modul_led_rot, HIGH);
delay(5000);
digitalWrite(modul_led_gelb, HIGH);
} // ende If
} // ende loop
Nachdem wir die gelbe LED eingeschaltet haben, fügen wir eine weitere Pause von 1000ms (1 Sekunde) ein.
Nach der Wartezeit werden die gelbe und rote LED ausgeschaltet.
Nun hat die gesamte Ampelschaltung einen vollständigen Zyklus durchlaufen und idealerweise hatte der Fußgänger ausreichend Zeit, die Straße sicher zu überqueren.
/* Variablen - Bauteile */
int modul_taster = 9;
int modul_led_rot = 12;
int modul_led_gelb = 11;
int modul_led_gruen = 10;
/* Variablen - Hilfe */
int taster_status = 0;
/* setup */
void setup()
{ // start setup
pinMode(modul_taster, INPUT);
pinMode(modul_led_rot, OUTPUT); // Die LED Rot ist ein Ausgang
pinMode(modul_led_gelb, OUTPUT); // Die LED Gelb ist ein Ausgang
pinMode(modul_led_gruen, OUTPUT); // Die LED Grün ist ein Ausgang
} // ende setup
/* loop */
void loop()
{ // start loop
taster_status = digitalRead(modul_taster);
digitalWrite(modul_led_gruen, HIGH);
if (taster_status == 1)
{ // start If
delay(2000);
digitalWrite(modul_led_gruen, LOW);
digitalWrite(modul_led_gelb, HIGH);
delay(1000);
digitalWrite(modul_led_gelb, LOW);
digitalWrite(modul_led_rot, HIGH);
delay(5000);
digitalWrite(modul_led_gelb, HIGH);
delay(1000);
digitalWrite(modul_led_gelb, LOW);
digitalWrite(modul_led_rot, LOW);
} // ende If
} // ende loop
Vielleicht fragst du dich, wieso die grüne Leuchtdiode nach dem Durchlaufen der der letzten aufleuchtet, obwohl wir diese gar nicht in der if-Schleife eingeschaltet haben.
Das liegt an der Art und Weise, wie der Mikrocontroller den Programmcode ausliest: von Oben nach unten und von links nach rechts.
Nachdem wir die gelbe und rote LED am Ende der If-Schleife ausgeschaltet haben, springt der Mikrocontroller direkt wieder in die erste Zeile des Programms.
Und da wir die grüne Leuchtdiode gleich zu Beginn des Loop-Teils unseres Programms eingeschaltet haben, leuchtet diese im Grundzustand hell auf. Und zwar so lange, bis wir den Taster erneut drücken.
/* Variablen - Bauteile */
int modul_taster = 9; // Taster an Pin D9
int modul_led_rot = 12; // LED Rot an Pin D10
int modul_led_gelb = 11; // LED Rot an Pin D10
int modul_led_gruen = 10; // LED Rot an Pin D10
/* Variablen - Hilfe */
int taster_status = 0; // Hilfsvariable um den Taster Status zu speichern
/* setup */
void setup()
{ // start setup
pinMode(modul_taster, INPUT); // Der Taster ist ein Eingang
pinMode(modul_led_rot, OUTPUT); // Die LED Rot ist ein Ausgang
pinMode(modul_led_gelb, OUTPUT); // Die LED Gelb ist ein Ausgang
pinMode(modul_led_gruen, OUTPUT); // Die LED Grün ist ein Ausgang
} // ende setup
/* loop */
void loop()
{ // start loop
taster_status = digitalRead(modul_taster); // Der Taster-Status wird gelesen und gespeichert
digitalWrite(modul_led_gruen, HIGH); // Schalte LED Grün an (Signal HIGH = 1)
if (taster_status == 1) // Wenn der Taster gedrückt wurde...
{ // start If
delay(2000); // Warte zwei Sekunde
digitalWrite(modul_led_gruen, LOW); // Schalte LED Grün aus (Signal LOW = 0)
digitalWrite(modul_led_gelb, HIGH); // Schalte LED Gelb an (Signal HIGH = 1)
delay(1000); // Warte eine Sekunde
digitalWrite(modul_led_gelb, LOW); // Schalte LED Gelb aus (Signal LOW = 0)
digitalWrite(modul_led_rot, HIGH); // Schalte LED Rot an (Signal HIGH = 1)
delay(5000); // Warte fünf Sekunden
digitalWrite(modul_led_gelb, HIGH); // Schalte LED Gelb an (Signal HIGH = 1)
delay(1000); // Warte eine Sekunde
digitalWrite(modul_led_gelb, LOW); // Schalte LED Gelb aus (Signal LOW = 0)
digitalWrite(modul_led_rot, LOW); // Schalte LED Rot aus (Signal LOW = 0)
} // ende If
} // ende loop
Nehmen wir uns einen kurzen Moment Zeit, um den Programmcode noch einmal nachzuvollziehen.
Zu Beginn haben wir die Variablen festgelegt und diesen Variablen einen Startwert zugewiesen.
Im Setup haben wir festgelegt, ob es sich bei den verwendeten Modulen um Ein- oder Ausgänge handelt.
Im Loop haben wir zunächst den Status unseres Tasters ausgelesen und diesen Status in einer Variable gespeichert.
Anschließend haben wir die grüne Leuchtdiode eingeschaltet.
Danach haben wir mit Hilfe einer If-Abfrage den Status unseres Tasters mit dem Zielwert 1 (für HIGH) abgeglichen.
Bei einer Übereinstimmung wird der Programmcode unserer Ampelschaltung abgerufen.
Im Programmcode unserer Ampelschaltung haben wir zunächst für 2000ms (2 Sekunden) pausiert. In dieser Zeit können die Autos auf unserer Fahrbahn zum Stillstand kommen.
Darauffolgend haben wir die gelbe LED zunächst eingeschaltet, dann eine Pause von 1000ms (1 Sekunde) eingelegt und anschließend wieder ausgeschaltet. Zeitgleich haben wir die rote LED eingeschaltet und eine weitere Pause von 5000ms (5 Sekunden) eingelegt. In dieser Zeit können die Fußgänger die Fahrbahn überqueren.
Nach dieser Pause schalten wir die gelbe Leuchtdiode ein und warten erneut eine Sekunde.
Mit dem Ablauf dieser Pause schalten wir die gelbe und die rote Leuchtdiode wieder aus.
Da der Mikrocontroller auf unserem Funduino Cube nach dem Durchlaufen der Ampelphasen den Programmcode wieder von Beginn an ausliest, leuchtet die grüne Leuchtdiode erneut auf. Und das so lange, bis der Taster wieder gedrückt wird und ein HIGH-Signal an Pin D9 anliegt.
/* Variablen - Bauteile */
int modul_taster = 9; // Taster an Pin D9
int modul_led_rot = 12; // LED Rot an Pin D10
int modul_led_gelb = 11; // LED Rot an Pin D10
int modul_led_gruen = 10; // LED Rot an Pin D10
/* Variablen - Hilfe */
int taster_status = 0; // Hilfsvariable um den Taster Status zu speichern
/* setup */
void setup()
{ // start setup
pinMode(modul_taster, INPUT); // Der Taster ist ein Eingang
pinMode(modul_led_rot, OUTPUT); // Die LED Rot ist ein Ausgang
pinMode(modul_led_gelb, OUTPUT); // Die LED Gelb ist ein Ausgang
pinMode(modul_led_gruen, OUTPUT); // Die LED Grün ist ein Ausgang
} // ende setup
/* loop */
void loop()
{ // start loop
taster_status = digitalRead(modul_taster); // Der Taster-Status wird gelesen und gespeichert
digitalWrite(modul_led_gruen, HIGH); // Schalte LED Grün an (Signal HIGH = 1)
if (taster_status == 1) // Wenn der Taster gedrückt wurde...
{ // start If
delay(2000); // Warte zwei Sekunde
digitalWrite(modul_led_gruen, LOW); // Schalte LED Grün aus (Signal LOW = 0)
digitalWrite(modul_led_gelb, HIGH); // Schalte LED Gelb an (Signal HIGH = 1)
delay(1000); // Warte eine Sekunde
digitalWrite(modul_led_gelb, LOW); // Schalte LED Gelb aus (Signal LOW = 0)
digitalWrite(modul_led_rot, HIGH); // Schalte LED Rot an (Signal HIGH = 1)
delay(5000); // Warte fünf Sekunden
digitalWrite(modul_led_gelb, HIGH); // Schalte LED Gelb an (Signal HIGH = 1)
delay(1000); // Warte eine Sekunde
digitalWrite(modul_led_gelb, LOW); // Schalte LED Gelb aus (Signal LOW = 0)
digitalWrite(modul_led_rot, LOW); // Schalte LED Rot aus (Signal LOW = 0)
} // ende If
} // ende loop
Falls du Unterstützung bei der Verwendung deines Funduino Cubes benötigen solltest, steht dir unser kompetentes Support Team jederzeit gerne zur Verfügung!
Du erreichst uns am Besten per Mail unter info@funduino.de oder von Montags bis Freitags, zwischen 09:00 und 17:00 Uhr unter der Rufnummer (+49) 5921 9704030.