Leuchtdioden kennst du aus deinem Alltag. Sie geben dabei Informationen über den Status von elektronischen Geräten an. Ein typisches Beispiel für eine Leuchtdiode in einem elektronischen Gerät ist die Stand-by-Leuchte von einem Bildschirm. Wenn wir die Stand-by-Leuchte sehen können, die sich häufig als roter Punkt darstellt, wissen wir, dass das Gerät z.B. über eine Fernbedienung wieder eingeschaltet werden kann.
Gemeinsam möchten wir uns gleich zu Beginn unserer Reise eines der wichtigsten Programme der Mikroelektronik ansehen: die blinkende Leuchtdiode.
Schalte die grüne Leuchtdiode auf deinem Funduino Cube ein. Pausiere eine Sekunde und schalte die grüne Leuchtdiode wieder aus. Nach einer weiteren Sekunde soll die grüne Leuchtdiode wieder aufleuchten.
Wenn du die OpenRoberta Oberfläche geöffnet hast, findest du in der oberen Navigationsleiste zwei Felder wieder: PROGRAMM und ROBOTERKONFIGURATION.
Wir starten mit einem Klick auf die ROBOTERKONFIGURATION. Es öffnet sich an der linken Bildschirmseite ein neues Menü. In diesem Menü findest du die beiden Felder Aktion und Sensoren.
Wir benötigen in unserem ersten Versuchsaufbau einen Baustein aus dem Feld Aktion. Diesen Baustein finden wir, indem wir jetzt das Feld Aktion anklicken.
Durch den Klick auf das Feld Aktion klappt jetzt ein weiteres Menü auf. Wenn wir in diesem Menü jetzt ein wenig mit dem Mausrad nach unten scrollen, entdecken wir den gewünschten Block.
Wir haben dir diesen Block in der Abbildung rot markiert.
Was genau sagt dieser Block eigentlich aus?
Du wirst erkennen, dass die Worte auf der linken Seite des Block farblich anders hinterlegt sind, als die auf der rechten Seite des Blockes . Das liegt daran, dass wir die Informationen auf der rechten Seite des Bausteins anpassen können.
Und wie fügen wir diesen Block jetzt in unsere ROBOTERKONFIGURATION ein?
Ganz einfach! Wir klicken auf den Baustein und ziehen diesen in das weiße Feld.
Der Block wird direkt nach dem Loslassen des Blockes automatisch durch eine Leitung mit unserem Controller verbunden.
Jetzt haben wir die Möglichkeit, die hell hinterlegten Informationen in dem Baustein anzupassen.
Wir beginnen damit, unserer LED einen Namen zu geben. Da wir zunächst die grüne LED auf unserer Platine blinken lassen möchten, vergeben wir den Namen „gruen“. Diese Bezeichnung wird uns im späteren Ablauf dabei helfen, die LED zielgerichtet anzusteuern.
Weiterhin wählen wir mit einem Klick auf das hell hinterlegte Feld rechts von „input“ den Pin aus, an dem unsere LED mit dem Mikrocontroller verbunden ist.
Schaue doch einmal auf deinen Funduino Cube und überprüfe, welcher Pin wir auswählen müssen, damit wir die LED ansteuern können. An der schwarzen Linie, die auf dem Cube von der LED zum Mikrocontroller führt, wirst du die Nummer des passenden Kontakts erkennen.
Richtig! Wir wählen natürlich den Pin D10 aus. Deine Roboterkonfiguration müsste jetzt so wie auf dem nachfolgenden Bild aussehen.
Die ROBOTERKONFIGURATION ist mit dieser letzten Einstellung erfolgreich abgeschlossen. Gratulation!
Jetzt schauen wir uns gemeinsam das zweite Feld in der oberen Navigation an, dass den Namen „PROGRAMM“ trägt. Mit einem Klick auf dieses Menü gelangst du zu den sogenannten Blöcken.
Unsere grüne LED finden wir mit einem Klick auf den Baustein „Aktion“ am linken Bildschirmrand wieder. Nach dem Klick öffnet sich, so wie du es schon aus unserer ROBOTERKONFIGURATION kennst, ein Feld mit unterschiedlichen Blöcken.
Weil wir eine LED ansteuern müssen, wählen wir den Block „Schalte LED gruen an“ aus und ziehen diesen in das weiße Feld.
Sicherlich wirst du jetzt feststellen, dass der Aktionsbaustein „Schalte LED an gruen an“ in dem weißen Feld schwebt. Mit einem weiteren Klick auf den Aktionsbaustein können wir diesen nun an die gewünschte Stelle in unserer Schleife ziehen.
Herzlichen Glückwunsch! Du hast soeben deinen ersten Programmablauf erstellt!
Doch bevor wir uns jetzt auf unserem Erfolg ausruhen, erinnern wir uns an unser eigentliches Ziel: Wir möchten eine LED blinken lassen.
Wenn du das Programm jetzt auf deine Platine lädst, wirst du feststellen, dass diese dauerhaft leuchtet. Wir müssen also noch einen weiteren Aktionsbaustein ergänzen, der die grüne LED wieder ausschaltet.
Na, findest du den Baustein wieder? Falls nicht, schaue dir die vorherigen Schritte noch einmal genauer an.
Dein Programmlauf sollte jetzt wie auf der nachfolgenden Abbildung aussehen.
Schauen wir uns den vorherigen Programmablauf an, so stellen wir fest, dass wir dem Mikrocontroller jetzt Folgendes beigebracht haben:
Schalte die grüne LED an…
…und danach…
…schalte die grüne LED erneut an…
Unser Programmcode stimmt so also bis jetzt nicht ganz mit unserem Ziel überein. Das ist aber gar kein Problem, denn wir wählen jetzt den zweiten Block aus und klicken auf „an“. Es öffnet sich ein Menü, in welchem wir jetzt richtigerweise „aus“ auswählen können.
Dein Programmablauf sieht jetzt aus, wie auf der nachfolgenden Abbildung.
Toll gemacht! Wir haben eine blinkende LED programmiert und unser Ziel erreicht.
Probiere doch einmal aus und beobachte, was passiert, wenn du das Programm jetzt auf dein Funduino Cube überspielst.
Ohje, die LED leuchtet dauerhaft? Woran liegt das?
Wie du in der Einstiegslektion bereits gelernt hast, lesen Mikrocontroller einen Programmcode genauso aus, wie du ein Buch liest:
Von oben nach unten und von links nach rechts.
Im Gegensatz zu dir lesen Mikrocontroller die Programmabläufe in einer wahnsinnig schnellen Geschwindigkeit aus. Diese Lesegeschwindigkeit wird auch Frequenz genannt.
Auch wenn wir den Programmablauf richtig programmiert haben, erfolgt das auslesen so schnell, dass wir mit dem menschlichen Auge nicht erkennen können, ob die LED auch wirklich blinkt. Für unser Auge scheint es so, als würde die LED durchgehend leuchten – auch wenn sie das in Wirklichkeit gar nicht tut.
Für diesen Fall gibt es einen weiteren Block, den wir dir jetzt vorstellen werden. Dieser Baustein nennt sich in OpenRoberta „Warte ms“.
Mithilfe dieses Bausteins können wir dem Mikrocontroller also befehlen, für eine bestimmte Zeitdauer zu warten (zu pausieren).
In dem Programmbaustein „Warte ms“ können wir jetzt festlegen, für welche Zeitdauer (auch Intervall genannt) der Mikrocontroller warten soll, bis der nächste Befehl ausgewählt wird. Der Zusatz „ms“ steht hierbei für die Zeitangabe in der Einheit Millisekunden.
1 Sekunde entspricht 1000 Millisekunden…
2 Sekunden entspricht 2000 Millisekunden…
10 Sekunden entspricht 10000 Millisekunden…
Da wir nach jedem Ein- oder Ausschalten der LED eine solche Pause benötigen, fügen wir den Programmbaustein „Warte ms“ gleich an zwei Stellen in unser Programm ein.
Was passiert, wenn du das Programm jetzt auf den Funduino Cube überspielst? Was passiert, wenn du statt der 1000 einen Wert von 5000 in das Programm überträgst und dieses erneut auf den Funduino Cube überspielst?
Im ersten Schritt erstellen wir zunächst eine Variable für die grüne Leuchtdiode. Hierzu schreiben wir zuerst das Wort „int“ in den Programmcode.
„Int„ ist dabei die Kurzform für „integer“. Bei einem Integer handelt um einen Datentyp. In diesem Fall um eine Ganzzahl (z.B. 1, 2, 5 oder auch 1337). Es erscheint dir vielleicht ungewöhnlich, aber beim Programmieren ist die Angabe des Datentyps für das Programm sehr wichtig.
Nach der Festlegung des Datentyps folgt der Name für die Variable. Da unsere LED grün ist, nennen wir sie „modul_led_gruen“. Da unsere grüne LED auf dem Funduino Cube an dem Pin D10 (oder auch an Pin 10) mit dem Mikrocontroller verbunden ist, hinterlegen wir in der Variable den Wert „10„.
/* Variablen - Bauteile */
int modul_led_gruen = 10;
Im zweiten Schritt ergänzen wir unseren Code um das Setup.
Im Setup legen wir fest, an welchem Pin die grüne LED mit unserem Mikrocontroller verbunden ist. Dies erfolgt durch den Befehl in der nachfolgenden Abbildung.
Der erste Teil der Programmzeile „PINBELEGUNG“ wird mit dem Namen unserer Variable „modul_led_gruen“ aus Schritt 1 ersetzen. In dieser Variable ist der Wert „10“ gespeichert.
pinMode(PINBELEGUNG, INPUT oder OUTPUT);
Anschließend müssen wir festlegen, ob es sich bei der LED um einen Eingang (Input) oder einen Ausgang (Output) handelt.
Da die LED über eine ausgehende Spannung von dem Mikrocontroller auf deinem Funduino Cube angesteuert wird, hinterlegen wir im „pinMode“ Befehl den Wert „OUTPUT“.
pinMode(modul_led_gruen, OUTPUT);
Das Codebeispiel aus Schritt 3 ergänzen wir jetzt in unserem Setup.
Wenn du alles richtig gemacht hast, sieht dein Code jetzt so aus wie in der nachfolgenden Abbildung.
/* Variablen - Bauteile */
int modul_led_gruen = 10;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_gruen, OUTPUT);
} // ende setup
An dieser Stelle erinnern wir uns an unsere Aufgabenstellung zurück: Wir möchten eine LED blinken lassen, also nacheinander ein- und wieder ausschalten. Bisher haben wir jedoch nur Vorbereitungen getroffen. Jetzt schreiben wir das eigentliche Programm. Der Bereich in dem das geschieht, wird als „Loop„ bezeichnet.
/* Variablen */
int modul_led_gruen = 10;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_gruen, OUTPUT);
} // ende setup
void loop()
{ // start setup
} // ende setup
Der Befehl, den wir für das Ein- und Ausschalten benötigen, nennt sich „digitalWrite„. Mit diesem Befehl können wir Module an einem digitalen Pin ansteuern.
Die LED auf unserem Funduino Cube befindet sich an Pin D10. Das „D“ steht dabei für „digital„, also „digital 10“.
Auch dieser Befehl setzt sich aus zwei Informationen zusammen, die durch ein Komma voneinander getrennt sind.
Die erste Information legt fest, an welchem Pin das gewünschte Modul angeschlossen ist. Wir tragen hier also wieder unsere Variable „modul_led_gruen“ ein.
digitalWrite(modul_led_gruen, An/Aus)
Die zweite Information legt fest, welches Signal wir an den digitalen Pin senden möchten.
Wenn wir ein HIGH Signal senden, schalten wir die LED ein.
Wenn wir ein LOW Signal senden, schalten wir die LED aus.
Da wir die LED zunächst einschalten möchten, hinterlegen wir hier den Wert „HIGH“. Anschließend fügen wir die Codezeile in den Loop-Teil unseres Codes ein.
/* Variablen */
int modul_led_gruen = 10;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_gruen, OUTPUT);
} // ende setup
void loop()
{ // start setup
digitalWrite(modul_led_gruen, HIGH);
} // ende setup
Nachdem wir die Leuchtdiode eingeschaltet haben, möchten wir die Leuchtdiode auch wieder ausschalten. Dies erzielen wir, indem wir die zweite Information aus dem „digitalWrite„ Befehl von HIGH auf LOW umschreiben.
Auch diese Codezeile fügen wir jetzt in unseren Loop-Teil ein.
digitalWrite(modul_led_gruen, LOW);
Wenn du die beiden Codezeilen richtig in deinen Programmcode eingefügt hast, sollte dieser jetzt so wie in der Abbildung aussehen.
Was passiert, wenn du den Code jetzt auf deinen Funduino Cube überspielst?
/* Variablen */
int modul_led_gruen = 10;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_gruen, OUTPUT);
} // ende setup
void loop()
{ // start setup
digitalWrite(modul_led_gruen, HIGH);
digitalWrite(modul_led_gruen, LOW);
} // ende setup
Hmm… die LED leuchtet dauerhaft. Aber warum?
Der Mikrocontroller auf deinem Funduino Cube liest den Code in einer sehr schnellen Geschwindigkeit aus. Die Geschwindigkeit, in welcher der Code ausgelesen wird nennt man auch Frequenz.
Die Frequenz ist dabei so hoch, dass wir Menschen das Ein- und Ausschalten der Leuchtdiode mit dem Auge nicht wahrnehmen können. Für uns macht es den Anschein, als würde die Leuchtdiode durchgehend leuchten.
Was müssen wir in unserem Code ergänzen, damit das Ein- und Ausschalten für uns Menschen sichtbar wird?
/* Variablen */
int modul_led_gruen = 10;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_gruen, OUTPUT);
} // ende setup
void loop()
{ // start setup
digitalWrite(modul_led_gruen, HIGH);
digitalWrite(modul_led_gruen, LOW);
} // ende setup
Genau, wir müssen eine Pause zwischem dem Einschalten und dem Ausschalten ergänzen.
Die Pause gibt eine Zeit vor, in der das Programm stoppt. Diese Angabe erfolgt in Millisekunden (ms). Eine Sekunde entspricht dabei 1000 Millisekunden.
In einem Programmcode wird diese Pause auch „delay„ (engl. für Verzögerung) genannt. Die Codezeile sieht so aus, wie in der nachfolgenden Abbildung dargestellt.
delay(1000);
Zwischen dem Einschalten und dem Ausschalten der Leuchtdiode fügen wir jetzt diese Pause ein.
Anschließend laden wir das Programm auf wieder auf den Mikrocontroller unseres Funduino Cubes hoch.
Und, was kannst du beobachten?
/* Variablen */
int modul_led_gruen = 10;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_gruen, OUTPUT);
} // ende setup
void loop()
{ // start setup
digitalWrite(modul_led_gruen, HIGH);
delay(1000);
digitalWrite(modul_led_gruen, LOW);
} // ende setup
Mist, die Leuchtdiode leuchtet immer noch dauerhaft?
Aber woran liegt das?
In Schritt 9 haben wir gelernt, dass der Mikrocontroller den Programmcode in einer sehr hohen Frequenz ausliest. Und genau liegt hier wieder einmal das Problem.
Wenn wir uns die Zeilen 10 bis 12 einmal genauer ansehen, verstehen wir auch warum das so ist.
Wir schalten die Leuchtdiode ein, pausieren für eine Sekunde und schalten die Leuchtdiode wieder aus. Der Mikrocontroller startet sofort nach dem Verarbeiten des Loop-Teils wieder von vorne. Demnach wird direkt nach dem Ausschalten der Leuchtdiode, die Leuchtdiode wieder eingeschaltet. Und das in einer Frequenz, die für das menschliche Auge wieder nicht sichtbar ist.
/* Variablen */
int modul_led_gruen = 10;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_gruen, OUTPUT);
} // ende setup
void loop()
{ // start setup
digitalWrite(modul_led_gruen, HIGH);
delay(1000);
digitalWrite(modul_led_gruen, LOW);
} // ende setup
Wir ergänzen unsere Programmcode also um eine weitere Pause, direkt nach dem Ausschalten der Leuchtdiode.
Anschließend laden wir das Programm wieder auf den Mikrocontroller unseres Funduino Cubes hoch. Mit diesem letzten Schritt ist unser Code endlich fertig!
Gratulation, du hast dein erstes eigenes Programm geschrieben!
Nur eine Frage hätten wir da noch…
… was passiert eigentlich, wenn du die zweite Pause direkt an den Start des Loop-Teils setzt?
/* Variablen */
int modul_led_gruen = 10;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_gruen, OUTPUT);
} // ende setup
void loop()
{ // start setup
digitalWrite(modul_led_gruen, HIGH);
delay(1000);
digitalWrite(modul_led_gruen, LOW);
delay(1000);
} // ende setup
Wir haben bei unserer ersten Aufgabe gelernt, wie wir eine einzelne LED auf dem Funduino Cube mithilfe der Entwicklungsumgebung OpenRoberta zum Blinken bringen können. Jetzt möchten wir den Schwierigkeitsgrad ein wenig erhöhen und zwei Leuchtdioden abwechselnd blinken lassen.
Schalte die grüne Leuchtdiode ein. Warte anschließend eine Sekunde und schalte die grüne Leuchtdiode wieder aus.
Schalte anschließend die rote Leuchtdiode ein. Warte erneut eine Sekunde und schalte die rote Leuchtdiode wieder aus.
In 1.1.1. haben wir bereits gelernt, wie wir Blöcke auswählen und diese in unsere ROBOTERKONFIGURATION einbinden können.
Wir erweitern unsere bestehende ROBOTERKONFIGURATION jetzt mit einer zweiten LED. Dazu fügen wir die entsprechenden Blöcke in unsere ROBOTERKONFIGURATION ein und vergeben für die zweite LED den Namen „rot“.
Schaue dir deinen Funduino Cube doch einmal genauer an und versuche herauszufinden, welchen Kontakt wir für die rote LED eintragen müssen.
Richtig! Die LED ist mit dem Mikrocontroller an dem digitalen Pin D10 verbunden. Wir wählen in dem hell hinterlegten Feld, gleich neben „Input“ den Wert D12 ein.
Damit ist unsere ROBOTERKONFIGURATION bereits vollständig abgeschlossen. Das ging einfach, oder?
Auch hier können wir auf den vorherigen Programmablauf zurückgreifen.
Wir erweitern unser Programm um einen zusätzlichen Baustein „Schalte LED an“ und wählen mit einem Klick auf „gruen“ jetzt die rote LED aus.
Dein neuer Programmablauf sollte jetzt so aussehen, wie in der nachfolgenden Abbildung dargestellt.
Nehmen wir uns an dieser Stelle doch einmal kurz die Zeit und überlegen, was genau beim Hochladen des Programms auf unseren Funduino Cube jetzt passieren würde.
Zunächst schalten wir die grüne LED ein.
Danach warten wir für 1000ms (also für eine Sekunde).
Anschließend schalten wir die grüne LED wieder aus und die rote LED ein.
Danach folgt eine weitere Pause von 1000ms (1 Sekunde).
So weit, so gut. Lade das Programm doch einmal auf den Funduino Cube und schaue, was passiert.
Und? Scheinbar läuft unser Wechselblinker noch nicht ganz reibungslos. Aber warum? Was haben wir vergessen?
Gehen wir den Code noch einmal ganz langsam durch:
Wir schalten die grüne LED ein, pausieren für eine Sekunde und schalten die grüne LED anschließend wieder aus. Alles richtig!
Danach schalten wir die rote LED ein, pausieren…
… aber schalten die LED nicht wieder aus.
Da das gesamte Programm in einer Schleife läuft („Wiederhole unendlich oft“), bleibt die LED nach dem ersten Einschalten dauerhaft eingeschaltet. Wir müssen unser Programm also noch um einen Aktionsbaustein ergänzen, in welchem wir die rote LED wieder ausschalten.
An welcher Stelle wir das im Programmablauf machen, siehst du in der nachfolgenden Abbildung.
Toll gemacht!
Dein Programmablauf sollte jetzt so aussehen, wie auf der nachfolgenden Abbildung dargestellt.
Probiere jetzt einmal, den Wechselblinker in unterschiedlichen Frequenzen blinken zu lassen.
Warum folgt direkt nach dem Ausschalten der roten LED eigentlich kein weiterer Aktionsbaustein, mit dem wir die grüne LED wieder einschalten? Kennst du die Antwort?
Zuerst erweitern wir unseren Code aus Aufgabe 1 um die rote LED. Für diesen Schritt verwenden wir wieder eine Variable.
Dieser Variable weisen wir den Wert „12“ zu. Die Variable nennen wir „modul_led_rot“.
/* Variablen */
int modul_led_gruen = 10;
int modul_led_rot = 12;
Unsere Variable ergänzen wir nun in unserem Programmcode aus Aufgabe 1.
Wir fügen die Variable in unserem Beispiel in Zeile 2 unseres Programmcodes ein.
/* Variablen */
int modul_led_gruen = 10;
int modul_led_rot = 12;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_gruen, OUTPUT);
} // ende setup
void loop()
{ // start setup
digitalWrite(modul_led_gruen, HIGH);
delay(1000);
digitalWrite(modul_led_gruen, LOW);
delay(1000);
} // ende setup
Nachdem wir unser Programm um die Variable für die rote LED ergänzt haben, widmen wir uns jetzt dem Setup-Teil.
Wie du bereits aus Aufgabe 1 weißt, legen wir mit dem Befehl „pinMode„ fest, an welchem Pin unseres Mikrocontrollers ein elektronisches Modul angeschlossen wurde und ob es sich bei dieses Modul um einen Eingang (Signaleingang) oder Ausgang (Signalausgang) handelt.
pinMode(modul_led_rot, OUTPUT); // Die LED Rot ist ein Ausgang
Diese Programmzeile fügen wir jetzt in unser Setup ein.
In unserem Beispiel ergänzen wir die Programmzeile in Zeile Nummer 6.
/* Variablen */
int modul_led_gruen = 10;
int modul_led_rot = 12;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_gruen, OUTPUT);
pinMode(modul_led_rot, OUTPUT);
} // ende setup
void loop()
{ // start setup
digitalWrite(modul_led_gruen, HIGH);
delay(1000);
digitalWrite(modul_led_gruen, LOW);
delay(1000);
} // ende setup
Gut gemacht! Mit diesem vierten Schritt haben wir die „Installation“ unserer LED erfolgreich abgeschlossen.
Jetzt folgt der spannende Teil: Die Aufgabenstellung sieht vor, dass wir die rote und die grüne Leuchtdiode abwechselnd blinken lassen.
Hierzu schalten wir zunächst die grüne LED ein und anschließend wieder aus. Danach schalten wir die rote LED ein und wieder aus.
Das Ein- und Ausschalten der grünen LED haben wir in der ersten Aufgabe bereits erfolgreich abgeschlossen.
Höchste Zeit also, dass wir den Loop-Teil des Programms um die Codezeilen zum Ein- und Ausschalten der roten LED ergänzen.
Da unsere LED ebenfalls an einem digitalen Pin des Mikrocontrollers auf deinem Funduino Cube verbunden ist, verwenden wir erneut den Befehl „digitalWrite„.
digitalWrite(modul_led_rot, HIGH); // Schalte LED Rot an (Signal HIGH = 1)
Mit dem Zusatz „HIGH“ oder „LOW“ in dem Befehl „digitalWrite„ können wir bestimmen, ob ein Signal an den von uns als Variable hinterlegten Pin gesendet werden soll oder auch nicht. Wenn wir ein Signal an den Pin senden, schalten wir damit die Leuchtdiode ein. Senden wir kein Signal, bleibt die Leuchtdiode ausgeschaltet.
Den Befehl „digitalWrite(led_rot, HIGH);“ ergänzen wir in unserem Programm direkt nachdem wir die grüne LED ausgeschaltet haben. In unserem Beispiel ergänzen wir diese Codezeile in Zeile Nummer 15.
/* Variablen */
int modul_led_gruen = 10;
int modul_led_rot = 12;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_gruen, OUTPUT);
} // ende setup
void loop()
{ // start setup
digitalWrite(modul_led_gruen, HIGH);
delay(1000);
digitalWrite(modul_led_gruen, LOW);
digitalWrite(modul_led_rot, HIGH);
delay(1000);
} // ende setup
Anschließend möchten wir die Leuchtdiode wieder ausschalten. Diesmal müssen wir also kein „HIGH“-Signal senden, sondern ein „LOW“-Signal.
Kannst du erkennen, an welcher Stelle im Programmcode wir diese Codezeile im Programm ergänzt haben?
/* Variablen */
int modul_led_gruen = 10;
int modul_led_rot = 12;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_gruen, OUTPUT);
} // ende setup
void loop()
{ // start setup
digitalWrite(modul_led_gruen, HIGH);
delay(1000);
digitalWrite(modul_led_gruen, LOW);
digitalWrite(modul_led_rot, HIGH);
delay(1000);
digitalWrite(modul_led_rot, LOW);
} // ende setup
Mit diesem letzten Schritt haben wir unser Programm fertiggestellt.
Gratulation, wir machen große Fortschritte!
Wir haben gelernt, dass wir mit dem Befehl „digitalWrite„ entweder ein „HIGH“ oder ein „LOW“ Signal an den Mikrocontroller versenden können.
Es handelt sich bei diesem Signal um ein sogenanntes digitales Signal.
In der Maschinensprache wird das „HIGH“ Signal mit einer 1 übersetzt. Das „LOW“ Signal mit einer 0.
Wenn wir den Befehl „digitalWrite(led_rot, HIGH)“ in unsere menschliche Sprache übersetzen würden, wäre die Übersetzung wie folgt:
„Sende das digitale Signal „HIGH“ (also 1) an den Pin 12 (unsere Variable led_rot) des Mikrocontrollers.“
Eigentlich ganz einfach, oder?
/* Variablen */
int modul_led_gruen = 10;
int modul_led_rot = 12;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_gruen, OUTPUT);
} // ende setup
void loop()
{ // start setup
digitalWrite(modul_led_gruen, HIGH);
delay(1000);
digitalWrite(modul_led_gruen, LOW);
digitalWrite(modul_led_rot, HIGH);
delay(1000);
digitalWrite(modul_led_rot, LOW);
} // ende setup
Nachdem wir auch unseren Wechselblinker erfolgreich programmiert haben, beschäftigen wir uns jetzt gemeinsam mit der Umsetzung einer echten Ampelschaltung.
Schalte die rote Leuchtdiode ein. Warte zwei Sekunden und schalte die gelbe Leuchtdiode ein. Warte eine weitere Sekunde und schalte die rote und gelbe Leuchtdiode aus und die grüne LED ein. Warte zwei weitere Sekunden.
Schalte anschließend die gelbe Leuchtdiode ein und die grüne Leuchtdiode aus. Warte eine Sekunde und schalte die gelbe Leuchtdiode aus.
Zunächst schalten wir die rote LED ein.
Anschließend warten wir 2000ms (2 Sekunden).
Danach schalten wir die gelbe LED ein.
Anschließend warten wir 1000ms (1 Sekunde).
Jetzt wird es spannend:
Wir schalten die rote LED und die gelbe LED aus. Danach wird die grüne LED eingeschaltet. Diese drei Schritte erfolgen nacheinander, jedoch in so kurzen Abständen, dass das Aus- bzw. Einschalten in der menschlichen Wahrnehmung zeitgleich erfolgt.
Ab diesem Zeitpunkt leuchtet nur noch die grüne LED.
Anschließend warten wir erneut 2000ms (2 Sekunden)
Wir schalten die gelbe LED ein und die grüne LED aus. Auch dieser Ablauf folgt „zeitgleich“. Es leuchtet also nur noch die grüne LED.
Anschließend warten wir erneut 1000ms (1 Sekunde) und schalten anschließend die gelbe LED aus.
Der gesamte Programmablauf befindet sich in einer sogenannten Schleife (Loop). Diesen Loop erkennst du an der roten Klammer, die den gesamten Programmablauf umschließt.
Frage: Warum endet das Programm mit dem Ausschalten der gelben LED?
In dieser Lektion möchten wir den Programmcode für eine Ampelschaltung schreiben.
Hierfür können wir auf den Programmcode aus Aufgabe 2 zurückgreifen. In diesem Programmcode haben wir bereits eine grüne und eine rote Leuchtdiode abwechselnd blinken lassen.
Da eine echte Ampel nicht nur aus den Signalfarben Rot und Grün besteht, müssen wir also eine gelbe LED ergänzen. Zudem müssen wir sicherstellen, dass die Leuchtdioden in der richtigen Reihenfolge aufleuchten.
/* Variablen */
int modul_led_gruen = 10;
int modul_led_rot = 12;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_gruen, OUTPUT);
} // ende setup
void loop()
{ // start setup
digitalWrite(modul_led_gruen, HIGH);
delay(1000);
digitalWrite(modul_led_gruen, LOW);
digitalWrite(modul_led_rot, HIGH);
delay(1000);
digitalWrite(modul_led_rot, LOW);
} // ende setup
Wir ergänzen zunächst die Variable, also den Informationsspeicher, für die gelbe Leuchtdiode.
Die gelbe LED ist auf unserem Funduino Cube an dem digitalen Pin 11 mit dem Mikrocontroller verbunden.
Wir benennen unsere Variable „modul_led_gelb“ und weisen Ihr den Wert „11„ zu.
int modul_led_gelb = 11; // LED Gelb an Pin D11
Anschließend fügen wir die Programmzeile in unser bestehendes Programm ein.
/* Variablen */
int modul_led_gruen = 10;
int modul_led_gelb = 11;
int modul_led_rot = 12;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_gruen, OUTPUT);
} // ende setup
void loop()
{ // start setup
digitalWrite(modul_led_gruen, HIGH);
delay(1000);
digitalWrite(modul_led_gruen, LOW);
digitalWrite(modul_led_rot, HIGH);
delay(1000);
digitalWrite(modul_led_rot, LOW);
} // ende setup
Nachdem wir diesen Schritt erfolgreich abgeschlossen haben, müssen wir dem Mikrocontroller jetzt noch vermitteln, an welchem digitalen Pin die gelbe Leuchtdiode angeschlossen ist.
Zusätzlich legen wir fest, dass es sich bei der gelben LED um ein Bauteil handelt, das durch einen (Signal-)Ausgang angesteuert wird.
pinMode(modul_led_gelb, OUTPUT); // Die LED Gelb ist ein Ausgang
Wir ergänzen die Programmzeile in unserem Programm.
Die Programmzeile wird, genauso wie wir es in den vorherigen Aufgaben gelernt haben, im Setup-Teil ergänzt.
/* Variablen */
int modul_led_gruen = 10;
int modul_led_gelb = 11;
int modul_led_rot = 12;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_gruen, OUTPUT);
pinMode(modul_led_gelb, OUTPUT);
pinMode(modul_led_rot, OUTPUT);
} // ende setup
void loop()
{ // start setup
digitalWrite(modul_led_gruen, HIGH);
delay(1000);
digitalWrite(modul_led_gruen, LOW);
digitalWrite(modul_led_rot, HIGH);
delay(1000);
digitalWrite(modul_led_rot, LOW);
} // ende setup
An dieser Stelle möchten wir gemeinsam einen Blick in den Programmcode aus Schritt 5 werfen.
Sicherlich fällt dir auf, dass unser Programm mit den einzelnen Lektionen schon ziemlich lang geworden ist.
Es wird auch deutlich, warum es so wichtig ist, auf eine ordentliche Programmstruktur zu achten und die Variablen nachvollziehbar zu benennen.
Auch die Kommentare helfen uns dabei, immer den Überblick zu behalten.
Du merkst: Auch beim Programmieren sind Ordnung und Struktur sehr wichtig.
/* Variablen */
int modul_led_gruen = 10;
int modul_led_gelb = 11;
int modul_led_rot = 12;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_gruen, OUTPUT);
pinMode(modul_led_gelb, OUTPUT);
pinMode(modul_led_rot, OUTPUT);
} // ende setup
void loop()
{ // start setup
digitalWrite(modul_led_gruen, HIGH);
delay(1000);
digitalWrite(modul_led_gruen, LOW);
digitalWrite(modul_led_rot, HIGH);
delay(1000);
digitalWrite(modul_led_rot, LOW);
} // ende setup
Zurück zu unserer Ampelschaltung: In Schritt 5 haben wir den Setup-Teil unseres Programms erfolgreich abgeschlossen.
Jetzt müssen wir im Loop-Teil nur noch die Blinkreihenfolge der Ampel festlegen.
Wie eine Ampel schaltet, weißt du natürlich. Die grüne Ampel schaltet erst auf Gelb und dann auf Rot. Anschließend schaltet sie wiederum von Rot auf Gelb und anschließend wieder auf Grün.
In unserem Beispielcode haben wir das Ein- und Ausschalten der grünen LED, sowie das Ein- und Ausschalten der roten LED bereits dargestellt.
Wir müssen in unserem Loop-Teil jetzt also nur noch die gelbe LED ergänzen. Dies erfolgt wieder durch Ergänzen des Befehls „digitalWrite„.
digitalWrite(modul_led_gelb, HIGH); // Schalte LED Gelb an (Signal HIGH = 1)
Die Programmzeile ergänzen wir jetzt in unserem bestehenden Programmcode .
Nachdem wir die Zeile ergänzt haben, fügen wir direkt danach eine Pause von einer Sekunde ein.
delay(1000);
Ohne diese Pause würden sowohl die gelbe, als auch die rote Leuchtdiode zeitgleich aufleuchten.
/* Variablen */
int modul_led_gruen = 10;
int modul_led_gelb = 11;
int modul_led_rot = 12;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_gruen, OUTPUT);
pinMode(modul_led_gelb, OUTPUT);
pinMode(modul_led_rot, OUTPUT);
} // ende setup
void loop()
{ // start setup
digitalWrite(modul_led_gruen, HIGH);
delay(1000);
digitalWrite(modul_led_gruen, LOW);
digitalWrite(modul_led_gelb, HIGH);
delay(1000);
digitalWrite(modul_led_rot, HIGH);
delay(1000);
digitalWrite(modul_led_rot, LOW);
} // ende setup
Danach müssen wir die gelbe LED auch wieder ausschalten. Hierfür ergänzen wir erneut den Befehl „digitalWrite„.
Da wir die LED ausschalten möchten, ändern wir das „HIGH“ in unserem Befehl zu „LOW“.
digitalWrite(modul_led_gelb, LOW); // Schalte LED Gelb an (Signal LOW = 0)
Mit diesem letzten Schritt haben wir unsere Ampelschaltung erfolgreich umgesetzt!
Gratulation! Lade das Programm jetzt auf deinen Funduino Cube hoch und schaue nach, ob die Ampel wie gewünscht schaltet.
Damit der Straßenverkehr im echten Leben fließt und die Verkehrsteilnehmer nicht ständig anhalten müssen, dauern die Rot- und Grünphasen immer etwas länger als die Gelbphasen. Hast du eine Idee, wie wir dies in unserem Programmcode umsetzen können?
/* Variablen */
int modul_led_gruen = 10;
int modul_led_gelb = 11;
int modul_led_rot = 12;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_gruen, OUTPUT);
} // ende setup
void loop()
{ // start setup
digitalWrite(modul_led_gruen, HIGH);
delay(1000);
digitalWrite(modul_led_gruen, LOW);
digitalWrite(modul_led_rot, HIGH);
delay(1000);
digitalWrite(modul_led_rot, LOW);
} // ende setup
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.