Mit Sensoren können wir die unterschiedlichsten Dinge auf der Welt erkennen und auswerten. Es ist daher fast schon als selbstverständlich zu betrachten, dass es auch einen Sensor zur Erkennung der Helligkeit gibt. Auf dem Funduino Cube ist zur Messung der Helligkeit ein Fotowiderstand montiert.
Im Zusammenhang mit einem regulären Widerstand ergibt sich aus technischer Sicht ein Spannungsteiler. Je nach Stärke des Lichts ändert sich die Spannung zwischen den beiden Bauteilen. Diese Spannung wird dann vom Mikrocontroller gemessen und als Lichtstärke ausgewertet.
In dieser Lektion möchten wir unseren Augen etwas gutes tun und eine Überwachungsstation bauen, die uns anzeigt, wenn es in unserem Raum zu dunkel ist.
Wenn es in unserem Raum zu dunkel ist, soll eine rote LED aufleuchten. Ansonsten soll eine grüne LED aufleuchten.
Im ersten Schritt fügen wir unseren Fotowiderstand zu unserer ROBOTERKONFIGURATION hinzu.
Doch Achtung: Der Fotowiderstand ist nicht als eigener Baustein in der ROBOTERKONFIGURATION geführt. Wir greifen deshalb auf den Baustein „Sensor analog“ zurück.
Warum analog? Der Fotowiderstand gibt Zahlenwerte in einem Zahlenbereich (bei 5V anliegender Spannung ist das der Bereich von 0-1023) zurück.
Wir können dadurch ein ganzes Helligkeitsspektrum erfassen.
Den passenden Baustein findest du im Menü auf der linken Seite unter „Sensoren„.
Nachdem wir diesen Baustein in unsere ROBOTERKONFIGURATION eingefügt haben, vergeben wir für diesen einen Namen.
In unserem Aufbau soll der Baustein jetzt „LDRFotowiderstand“ heißen.
Jetzt müssen wir nur noch den Pin bestimmen, an dem unser Fotowiderstand mit dem Mikrocontroller auf unserem Funduino Cube verbunden ist.
Auf deinem Funduino Cube ist dies der Pin A7.
Toll gemacht!
In unserer Aufgabenstellung wird vorgegeben, dass in Abhängigkeit der Helligkeit entweder eine rote LED oder eine grüne LED aufleuchten soll.
Wir ergänzen unsere ROBOTERKONFIGURATION deshalb um die beiden LEDs.
Unsere ROBOTERKONFIGURATION ist durch das Hinzufügen der LEDs vollkommen abgeschlossen. Wir können uns jetzt dem PROGRAMM zuwenden.
Unsere Aufgabenstellung sieht vor, dass eine rote LED immer dann leuchtet, wenn ein gewünschter Helligskeitswert unterschritten wird.
Ansonsten soll die grüne LED leuchten und uns dadurch signalisieren, dass die Helligkeit im Raum nicht ausreichend ist.
Wir fügen deshalb im ersten Schritt eine bereits bekannte Schleife/Bedingung zu unserem PROGRAMM hinzu.
Anschließend müssen wir unsere Schleife um einen Operator-Block erweitern.
Dieser Operator-Block wird uns im Laufe des PROGRAMMS dabei unterstützen, die richtige Leuchtdiode in Abhängigkeit der Helligkeit anzusteuern.
Wir ergänzen diesen Operator-Block in unserer Schleife.
Es fällt auf, dass sich in unserem Operator-Block noch zwei leere Felder befinden, die wir in den nächsten Schritten jetzt füllen möchten.
Welche Inhalte müssen wir jetzt ergänzen?
„Wenn die Helligkeit unterschritten wird, dann soll…“
Richtig, wir müssen auf jeden Fall einen Block zum Auslesen des Sensorwertes unseres Fotowiderstands ergänzen.
Zunächst navigieren wir hierfür in das Menü an der linken Bildschirmseite und ziehen den Block für unseren analogen Sensoren, unseren Fotowiderstand, in die erste frei Fläche in unserem Operator-Block.
Diesen Block finden wir im Menü „Sensoren„.
Der folgenden Abbildung kannst du entnehmen, wie dein PROGRAMM jetzt aussehen sollte.
Toll gemacht! Mit diesem Schritt haben wir grundsätzlich erst einmal die Helligkeit mit unserem Fotowiderstand ausgelesen.
Jetzt möchten wir ergänzen, ab welchem Schwellenwert unsere LEDs ein- bzw. ausgeschaltet werden sollen.
Den Block für eine einfache Zahleneingabe, wie wir Sie jetzt für unser PROGRAMM benötigen, findest du unter „Mathematik„.
Füge diesen Block jetzt zu deinem PROGRAMM hinzu.
Wenn wir unser PROGRAMM jetzt in unsere Sprache übersetzen würden, wäre die Aussage wie folgt:
„Wenn der analoge Wert von unserem Fotowiderstand gleich 0 beträgt, dann…“.
Da wir die rote LED immer dann einschalten möchten, wenn ein von uns festgesetzter Helligkeitswert unterschritten wird (also kleiner als… ist), ändern wir jetzt den Operatoren in unserem Operator-Block von „= (gleich)“ auf „< (kleiner)„.
Wir erinnern uns an die ersten Schritte zurück: Analoge Sensoren, die mit 5V angesteuert werden, bilden ein Zahlenspektrum von 0-1023 ab.
Wir nehmen in unserem Aufbau an, dass es in unserem Raum ab einem Helligkeitswert von „512“ so dunkel ist, dass wir nicht mehr gut lesen können. Deshalb tragen wir in unseren Mathematik-Baustein den Wert „512“ ein.
Toll gemacht!
Wir übersetzen zur Kontrolle noch einmal unser PROGRAMM in eine für uns verständliche Sprache:
„Wenn der analoge Wert von unserem Fotowiderstand kleiner 512 beträgt, dann…“.
Wir müssen in unserem letzten Schritt nur noch die beiden Leuchtdioden ergänzen. Natürlich weißt du schon längst, wie das geht. Falls nicht, schaue dir die früheren Lektionen noch einmal genauer an.
Der Fotowiderstand ist ein Sensor, welcher die Lichtstärke misst. Dies gelingt, indem sich der Widerstand in
Abhängigkeit der Lichtintensität verändert.
Wir haben bereits gelernt, dass ein Mikrocontroller Signale verarbeitet. Bei einem Signal handelt es sich immer
um eine elektronische Spannung, die vom Mikrocontroller interpretiert oder ausgewertet wird. Dadurch, dass
sich bei einer Veränderung der Lichtintensität der Spannungswert im Stromkreis des Fotowiderstandes
verändert, können wir mit Hilfe des Mikrocontrollers stufenlos erkennen und auswerten, wie hell oder dunkel
es gerade ist.
In vorherigen Anleitungen ging es immer um digitale Signale. Digital bedeutet, dass eine Spannung AN oder
AUS ist. In diesem Zusammenhang spricht man in der Digitaltechnik auch von NULLEN und EINSEN oder 0 und
1. Zum Beispiel die Leuchtdiode wird mit einem digitalen Signal angesteuert, nämlich 5V AN oder 5V AUS. Bei
der Programmierung werde diese Spannungen, bzw. diese beiden Zustände interpretiert als 1 (HIGH) oder 0
(LOW).
Doch nun ist es anders. Zwischen dem Fotowiderstand und dem Festwiderstand entwickelt sich je nach
Lichtstärke eine Spannung die zwischen 0V und der angeschlossenen 5V Spannung liegt. Das kann 3,45V sein,
oder 0,78V sein oder 4,9V sein. Auf jeden Fall alles andere als 5V AN oder 5V AUS.
Es handelt sich hier um einen analogen Spannungswert. Analog bedeutet, dass die auszuwertende Spannung
einen beliebigen Wert annehmen kann.
Der Mikrocontroller ist in der Lage, diese Spannung zu messen und zu verarbeiten. Um dies zu ermöglichen,
haben Mikrocontroller ganz besondere Pins, die sich von den digitalen Pins unterscheiden.
Es handelt sich um die analogen Eingänge. Ein „Arduino NANO“ oder „Funduino NANO“ Controller hat beispielsweise acht dieser
Eingänge mit den Bezeichnungen A0 bis A7.
Wenn ein Mikrocontroller ein analoges Signal auswertet, wird der gemessene Spannungswert in einen
Zahlenwert umgewandelt.
Je nach Mikrocontroller kann es hier verschiedene Auflösungen, also
Zahlenbereiche, geben. Der NANO-Controller wandelt die Spannungen zwischen 0V und 5V in einen
Zahlenbereich zwischen 0 und 1023 um.
0V entspricht dem Zahlenwert 0
1V entspricht dem Zahlenwert 204
2V entspricht dem Zahlenwert 408
…
5V entspricht dem Zahlenwert 1023
Der Fotowiderstand ist mit dem Pin A7 des Mikrocontrollers verbunden.
Wenn wir diese Information jetzt in unserem Programmcodes definieren möchten, müssen wir angeben, dass am Mikrocontroller ein analoger Signaleingang erwartet wird. Dies gelingt, indem wir den Wert Anschlusspin „7“ um den Buchstaben A (für analog) ergänzen. Nur so weiß der Mikrocontroller, dass der Pin A7 (analog) und nicht D7 (digital) gemeint ist.
Die Variable für die grüne LED ist wie gewohnt mit dem Pin 10 des Mikrocontrollers verbunden. Die Variable für die rote LED ist mit dem Pin 12 verbunden.
/* Variablen Bauteile */
int modul_fotowiderstand = A7;
int modul_led_gruen = 10;
int modul_led_rot = 12;
Um die Aufgabenstellung zu erfüllen, müssen wir zunächst den Widerstandswert des Fotowiderstandes in einer Variable speichern.
Diese Variable nennen wir „widerstandswert“ und weisen ihr den Startwert 0 zu.
/* Variablen Bauteile */
int modul_fotowiderstand = A7;
int modul_led_gruen = 10;
int modul_led_rot = 12;
int widerstandswert = 0;
Im Setup kennzeichnen wir die Variable des Fotowiderstandes als „INPUT“, da der Mikrocontroller ein eingehendes Spannungssignal aus dem Stromkreis des Fotowiderstandes auswertet.
Die beiden LEDs werden als „OUTPUT“ gekennzeichnet, der Mikrocontroller diese in Abhängigkeit des gemessenen Widerstandswertes mit einem Spannungssignal ein- oder ausschalten soll.
/* Variablen Bauteile */
int modul_fotowiderstand = A7;
int modul_led_gruen = 10;
int modul_led_rot = 12;
int widerstandswert = 0;
void setup()
{ // start setup
pinMode(modul_fotowiderstand, INPUT);
pinMode(modul_led_gruen, OUTPUT);
pinMode(modul_led_Rot, OUTPUT);
} // ende setup
Im Loop wird zuerst der Messwert des Fotowiderstandes in der Variable „widerstandswert“ gespeichert. Dafür verwenden wir den „analogRead“-Befehl.
Der Messwert bewegt sich dabei zwischen 0 und 1023. Dies entspricht dem niedrigstem beziehungsweise höchstem Wert in einem Stromkreis mit 5V anliegender Spannung.
Das ist übrigens nicht nur bei dem Fotowiderstand so, sondern allgemein bei Sensoren, die mit 5V Spannung verwendet werden. Die analogen Werte reichen dabei immer von 0 bis 1023.
/* Variablen Bauteile */
int modul_fotowiderstand = A7;
int modul_led_gruen = 10;
int modul_led_rot = 12;
int widerstandswert = 0;
void setup()
{ // start setup
pinMode(modul_fotowiderstand, INPUT);
pinMode(modul_led_gruen, OUTPUT);
pinMode(modul_led_rot, OUTPUT);
} // ende setup
void loop()
{ // start loop
widerstandswert = analogRead(modul_fotowiderstand);
} // ende loop
In der Variable „widerstandswert“ ist nun ein Wert zwischen 0 und 1023 gespeichert. Damit können wir die Helligkeit in unserem Zimmer bestimmen.
Laut der Aufgabenstellung soll die rote LED leuchten, wenn es in unserem Zimmer zu dunkel wird. Wir nehmen an, dass es ab einem Widerstandswert von 512 zu dunkel ist, um noch gut lesen zu können. Deshalb soll dann die rote LED angehen.
Diese Annahme übertragen wir in unseren Programmcode mit der bereits bekannten If-Bedingung. Den genauen Codeabschnitt kannst du aus der nachfolgenden Abbildung entnehmen.
Was machen wir, wenn der Widerstandswert über 512 liegt? Wir gucken uns dieses Problem im nächsten Schritt mal genauer an…
/* Variablen Bauteile */
int modul_fotowiderstand = A7;
int modul_led_gruen = 10;
int modul_led_rot = 12;
int widerstandswert = 0;
void setup()
{ // start setup
pinMode(modul_fotowiderstand, INPUT);
pinMode(modul_led_gruen, OUTPUT);
pinMode(modul_led_Rot, OUTPUT);
} // ende setup
void loop()
{ // start loop
widerstandswert = analogRead(modul_fotowiderstand);
if (widerstandswert < 512)
{ // start if
digitalWrite(modul_led_gruen, LOW);
digitalWrite(modul_led_rot, HIGH);
} // ende if
} // ende loop
Wir können die If-Abfrage um das englische Wort „else“ (dts. „sonst“) erweitern. Aus der IF-Abfrage wird somit eine If-Else-Abfrage.
Eine If-Else-Abfrage ist in der Lage, einen „sonstigen-Fall“ auszuführen. Dieser „sonstige-Fall“ wird immer dann ausgeführt, wenn die IF-Bedingung nicht erfüllt worden ist.
Unsere Aufgabenstellung sieht vor, dass immer dann eine rote LED leuchten soll, wenn der Widerstandswert weniger als 512 beträgt und es somit in unserem Zimmer zu dunkel ist, um ein Buch zu lesen.
Sonst, also wenn der Widerstandswert mehr als 512 beträgt, soll die grüne LED auf dem Funduino Cube aufleuchten.
Wir beginnen die Else-Anweisung mit dem Schlüsselwort „else“. Anschließend folgt eine geöffnete geschweifte Klammer. In diese Klammer tragen wir jetzt unsere Anweisung ein, die ausgeführt werden soll, wenn die Bedingung nicht erfüllt ist. In unserem Beispiel also, wenn der Widerstandswert mehr als 512 beträgt.
Wir beenden diesen Code-Bereich mit einer schließenden geschweiften Klammer.
Erweitert nun die If-Abfrage zu einer If-Else-Abfrage. Den grundlegenden Aufbau könnt ihr in hier entnehmen.
if (Bedingung)
{
was soll passieren?
} else
{
Was sonst?
}
Eure If-Else-Abfrage sollte also jetzt wie in der Abbildung rechts aussehen. Da es im Raum also hell genug wäre, um gut lesen zu können, schalten wir die rote LED aus und die Grüne ein.
Die rote Leuchtdiode auf deinem Funduino Cube leuchtet auf? Dann halte den Funduino Cube doch mal in die nähe deines Zimmerfensters und beobachte, was passiert.
Welche Veränderung kannst du wahrnehmen?
/* Variablen Bauteile */
int modul_fotowiderstand = A7;
int modul_led_gruen = 10;
int modul_led_rot = 12;
int widerstandswert = 0;
void setup()
{ // start setup
pinMode(modul_fotowiderstand, INPUT);
pinMode(modul_led_gruen, OUTPUT);
pinMode(modul_led_Rot, OUTPUT);
} // ende setup
void loop()
{ // start loop
widerstandswert = analogRead(modul_fotowiderstand);
if (widerstandswert < 512)
{ // start if
digitalWrite(modul_led_gruen, LOW);
digitalWrite(modul_led_rot, HIGH);
} // ende if
else // wenn der Lichtwert ueber 512 liegt...
{ // start else
digitalWrite(modul_led_rot, LOW);
digitalWrite(modul_led_gruen, HIGH);
} // ende else
} // ende loop
Jetzt folgt eine Zusammenfassung des Codes:
Zunächst erstellen wir drei Variablen für die benötigten Module. Achtet darauf, dass wir bei der Fotowiderstands-Variable das „A“ vor die 7 schreiben müssen. Ansonsten würde der Mikrocontroller denken, dass der digitale Pin 7 gemeint wäre.
Jetzt ergänzen wir noch eine Variable, um den Widerstandswert zu speichern. Sie bekommt den Startwert 0.
Im Setup legen wir die LEDs als Ausgang fest und den Fotowiderstand als Eingang.
Im Loop wird zuerst der Widerstandswert in der Variable „widerstandswert“ gespeichert. In der If-Else-Abfrage wird geprüft, ob der Widerstandswert kleiner als 512 ist. Wenn das der Fall ist, geht dir rote LED an und die Grüne geht aus. Wenn der Widerstandswert über 512 liegt, geht die grüne LED an und die rote LED geht aus.
/* Variablen Bauteile */
int modul_fotowiderstand = A7; // Variable Fotowiderstand
int modul_led_gruen = 10; // Variable gruene LED
int modul_led_rot = 12; // variable rote LED
int widerstandswert = 0;
void setup()
{ // start setup
pinMode(modul_fotowiderstand, INPUT); // Fotowiderstand ist ein Input
pinMode(modul_led_gruen, OUTPUT); // LEDs sind Outputs
pinMode(modul_led_rot, OUTPUT); // LEDs sind Outputs
} // ende setup
void loop()
{ // start loop
widerstandswert = analogRead(modul_fotowiderstand);
if (widerstandswert < 512) // wenn Lichtwert unter 512 ist...
{ // start if
digitalWrite(modul_led_gruen, LOW); // ...dann geht die gruene LED aus...
digitalWrite(modul_led_rot, HIGH); // ...und die rote LED an
} // ende if
else // wenn der Lichtwert ueber 512 liegt...
{ // start else
digitalWrite(modul_led_rot, LOW); // ...geht die rote LED aus...
digitalWrite(modul_led_gruen, HIGH); // ...und die gruene LED an
} // ende else
} // 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.