Potentiometer zählen zu den variablen Widerständen. Mit einer Drehbewegung des Potentiometers können wir diesen Widerstandswert erhöhen oder verringern. Du kennst Potentiometer garantiert auch aus dem Alltag: zum Beispiel als Drehknopf zum Einstellen der Lautstärke an deinem Radio oder als Dimmer für deine Deckenlampe.
In dieser Lektion möchten wir uns diese Eigenschaft des Drehpotentiometers genauer ansehen.
Die grüne Leuchtdiode auf unserem Funduino Cube soll in Abhängigkeit des Widerstandswertes unseres Potentiometers aufleuchten.
Dabei soll der Widerstandswert unseres Potentiometers das Blinkintervall unserer grünen LED vorgeben.
Wir starten mit dem Hinzufügen des Blocks für das Potentiometer.
Den Block findest du unter „Sensoren„, relativ weit unten.
Ziehe den Block mit der linken Maustaste in deine ROBOTERKONFIGURATION.
Anschließend kannst du einen Namen für deinen Block vergeben. Wir nennen unseren Block „Potentiometer„.
Nachdem wir den Block erfolgreich zu unserer ROBOTERKONFIGURATION hinzugefügt haben, müssen wir jetzt den Pin angeben, an dem das Potentiometer mit dem Funduino Cube verbunden ist.
Schaue jetzt auf deinen Funduino Cube und lies den Pin ab. An welchem analogen Eingang ist das Potentiometer mit dem Funduino Cube verbunden?
Richtig, das ist der analoge Eingang A6.
Nachdem wir die Verbindung zwischen dem Potentiometer und dem Mikrocontroller in unserer ROBOTERKONFIGURATION eingestellt habe, fügen wir jetzt noch unsere grüne LED hinzu.
Den Baustein für die LED findest du unter „Aktion„.
Toll gemacht! Unsere ROBOTERKONFIGURATION ist jetzt abgeschlossen. Wir gehen jetzt zum PROGRAMM über.
In dieser Lektion möchten wir eine LED in Abhängigkeit des analogen Widerstandswertes (zwischen 0 und 1023 bei 5V anliegender Spannung) des Potentiometers blinken lassen.
Beispiel:
Wenn ein Widerstandswert von 500 vorliegt, soll die grüne LED für 500ms (0,5 Sekunden) aufleuchten und danach für 500ms ausgeschaltet bleiben.
Wenn wir den Widerstandswert auf 1000 erhöhen, soll die grüne LED für 1000ms (1 Sekunde) aufleuchten und danach für 1000ms ausgeschaltet bleiben.
Doch woher weiß der Mikrocontroller auf unserem Funduino Cube, welcher Messwert gerade vorliegt?
Schließlich können wir den Widerstandswert mit einer Drehbewegung am Potentiometer beliebig einstellen, oder?
Die Lösung liegt in sogenannten Variablen. Mit einer Variable können wir, so wie es der Name schon vermuten lässt, variable, also sich verändernde Zahlenwerte sichern und innerhalb unseres Programms an beliebigen Stellen abrufen.
In dieser Lektion hilft uns eine Variable zum Beispiel dabei, den Widerstandswert als Zahl zu speichern. Und genau damit starten wir jetzt!
Wir fügen zu unserem PROGRAMM eine Variable hinzu, indem wir auf das helle + Symbol in unserem PROGRAMM klicken.
Anschließend vergeben wir für diese Variable einen Namen. Damit wir die Übersicht behalten, nennen wir auch diese Variable Potentiometer.
Danach müssen wir dem Mikrocontroller noch erklären, welche Art von Variable sich hinter unserer Variable „Potentiometer“ verbirgt.
Wir haben unter anderem die Wahl zwischen „Zahl“, „Zeichenkette“ (Buchstaben) oder „Farbe“.
Mit unserem Potentiometer möchten wir einen Zahlenwert in der Variable speichern. Wir wählen hier deshalb den Punkt „Zahl“ aus.
In dem Mathematik Baustein, der hinter unserer Variable steht, geben wir einen Startwert vor. Dieser ist meistens „0„. Wenn wir die Variable „Potentiometer“ im weiteren Programmverlauf mit keinen neuen Informationen füllen sollten, bleibt der Wert „0“ hinterlegt.
Eigentlich ganz logisch, oder?
Nachdem wir unsere Variable „Potentiometer“ erfolgreich definiert haben, fügen wir den ersten Baustein für Variablen zu unserem PROGRAMM hinzu.
Den Baustein den wir verwenden möchten, heißt „Schreibe [Variable]„.
In unserem konkreten Beispiel heißt dieser Baustein „Schreibe Potentiometer„.
Wir fügen diesen Baustein mit einem Linksklick zu unserem PROGRAMM hinzu.
Dein PROGRAMM sollte jetzt so aussehen, wie in Abbildung Schritt 5 dargestellt.
Wir haben in dem PROGRAMM zum jetzigen Zeitpunkt festgelegt, wie unsere Variable heißt und welche Art von Wert wir in ihr speichern möchten (Zahl).
Jetzt fehlt eigentlich nur noch der Zahlenwert, der in unserer Variable gespeichert werden soll.
Den Zahlenwert unseres Potentiometers möchten wir direkt aus dem Programm-Block in unsere Variable schreiben lassen.
Hierfür wählen wir den Block für das Potentiometer unter „Sensoren“ aus und ziehen dieses in unser PROGRAMM.
Schaue jetzt in Abbildung Schritt 7 und überprüfe, ob dein PROGRAMM genauso aussieht, es dort dargestellt.
Zur Wiederholung:
Wir haben in unserem PROGRAMM jetzt festgelegt, dass wir eine Variable mit dem Namen „Potentiometer“ anlegen möchten, in welcher ein Zahlenwert gespeichert werden soll.
Dieser Zahlenwert wird anschließend direkt vom Potentiometer in unsere Variable mit dem Namen „Potentiometer“ geschrieben.
Wir erinnern uns an den ersten Teil unserer Aufgabenstellung zurück:
„Die grüne Leuchtdiode auf unserem Funduino Cube soll in Abhängigkeit des Widerstandswertes unseres Potentiometers aufleuchten. „
Wir ergänzen unser PROGRAMM also noch um unsere grüne Leuchtdiode.
Jetzt erinnern wir uns an den zweiten Teil unserer Aufgabenstellung zurück:
„Dabei soll der Messwert unseres Potentiometers die Blinkdauer unserer grünen LED vorgeben.“
Wir ergänzen PROGRAMM deshalb um einen „Warte ms“ Block, den du im linken Menü unter „Kontrolle“ findest.
An Stelle des Mathematik-Bausteins (500), fügen wir jetzt unsere Variable ein. Hierfür löschen wir zunächst den Mathematik-Baustein.
Anschließend navigieren wir in das linke Menü und wählen unter „Variablen“ den Baustein „Potentiometer“ aus.
Diesen Block ziehen wir mit einem Linksklick in unser PROGRAMM und fügen Ihnen an den Baustein „Warte ms“ an.
Toll gemacht, das war gar nicht so einfach!
Dein Programm sieht jetzt so aus, wie in Abbildung Schritt 11 dargestellt.
Da wir die LED blinken lassen möchten, müssen wir jetzt noch zwei Blöcke ergänzen. Weißt du noch, wie das geht?
Blicke jetzt in Abbildung Schritt 12 und vergleiche dein PROGRAMM mit dem aus der Abbildung.
Wenn du alles richtig gemacht hast, kannst du dein PROGRAMM auf den Funduino Cube laden.
Drehe doch mal am Potentiometer und schaue, wie sich die Blinkfrequenz der grünen LED verändert.
Frage:
Wie müsste das PROGRAMM und die ROBOTERKONFIGURATION eigentlich aussehen, wenn wir bei einem Widerstandswert von weniger als 512 die grüne LED und bei mehr als 512 die rote LED leuchten lassen möchten?
Das Potentiometer ist mit dem Pin A6 des Mikrocontrollers verbunden. Bei den anlogen Pins müsst Ihr vor der Zahl für den Pin immer den Buchstaben A angeben. Nur so weiß der Mikrocontroller, dass der Pin A6 und nicht D6 (digital) gemeint ist.
Die Variable für die grüne LED ist wie gewohnt mit dem digitalen Pin 10 des Mikrocontrollers verbunden.
Den Widerstandswert des Potentiometers speichern wir in einer separaten Variable. Diese Variable nennen wir „widerstandswert“ und geben ihr den Startwert 0.
Aus der vorherigen Lektion weißt du bereits, dass in einem Schaltkreis mit 5V Spannung ein analoger Wert zwischen 0 und 1023 erwartet wird. In unserer Variable wird deshalb ein Widerstandswert zwischen 0 und 1023 abgespeichert, den wir später mit dem Mikrocontroller weiter verarbeiten können.
/* Variablen */
int modul_potentiometer = A6;
int modul_led_Gruen = 10;
int widerstandswert = 0;
Im Setup definieren wir den Pin der LED als Spannungsausgang. Den analogen Pin des Potentiometers müssen wir nicht als Ein-oder-Ausgang definieren, da analoge Pins standardmäßig immer ein Eingang sind.
/* Variablen */
int modul_potentiometer = A6;
int modul_led_Gruen = 10;
int widerstandswert = 0;
/* Setup */
void setup()
{ // start setup
pinMode(modul_led_Gruen, OUTPUT);
} // ende setup
Im Loop wird zuerst der Messwert des Potentiometers in der Variable „widerstandswert“ gespeichert. Dafür verwenden wir den „analogRead“-Befehl.
Zur Erinnerung: Der Widerstandswert beträgt je nach Stellung des Drehpotentiometers zwischen 0 und 1023.
/* Variablen */
int modul_potentiometer = A6;
int modul_led_Gruen = 10;
int widerstandswert = 0;
/* Setup */
void setup()
{ // start setup
pinMode(modul_led_Gruen, OUTPUT);
} // ende setup
/* loop */
void loop()
{ // start loop
widerstandswert = analogRead(modul_potentiometer);
}
Nun schalten wir die LED mit dem „digitalWrite“-Befehl ein. Laut der Aufgabenstellung soll die LED für die Dauer des Widerstandswerts leuchten.
Habt ihr eine Idee, wie wir dies umsetzen können?
/* Variablen */
int modul_potentiometer = A6;
int modul_led_Gruen = 10;
int widerstandswert = 0;
/* Setup */
void setup()
{ // start setup
pinMode(modul_led_Gruen, OUTPUT);
} // ende setup
/* loop */
void loop()
{ // start loop
widerstandswert = analogRead(modul_potentiometer);
digitalWrite(modul_led_Gruen, HIGH);
}
In der Variable „widerstandswert“ ist der aktuelle Widerstandswert des Potentiometers gespeichert. Also könnten wir doch eigentlich den „delay“-Befehl mit der Variable „widerstandswert“ kombinieren. Dafür schreiben wir in die Klammer des „delay“-Befehls den Variablennamen, also „widerstandswert“ anstelle eines festen Zahlenwerts.
Früher: delay(5000);
Neu: delay(widerstandswert);
Wenn wir diese Pause nach dem Ein- oder Ausschalten der Leuchtdiode in unserem Programmcode platzieren, wird der Schaltzustand der Leuchtdiode für die Dauer des Widerstandswertes in Millisekunden gehalten.
Wir beginnen mit dem Einschalten der Leuchtdiode. Dafür verwenden wir den „digitalWrite“-Befehl. Danach fügen wir den Befehl „delay(widerstandswert)“ in unseren Programmcode ein. Dadurch würde die LED aufleuchten und der Mikrocontroller eine Pause entsprechend des Widerstandswertes einlegen. Anschließend schalten wir die Leuchtdiode mit dem Befehl „digitalWrite“ wieder aus. Auch hiernach fügen wir den Befehl „delay(widerstandswert)“ in unseren Programmcode ein. Ladet diesen Sketch jetzt auf euren Funduino Cube hoch und dreht etwas am Potentiometer. Was könnt Ihr beobachten?
/* Variablen */
int modul_potentiometer = A6;
int modul_led_Gruen = 10;
int widerstandswert = 0;
/* Setup */
void setup()
{ // start setup
pinMode(modul_led_Gruen, OUTPUT);
} // ende setup
/* loop */
void loop()
{ // start loop
widerstandswert = analogRead(modul_potentiometer);
digitalWrite(modul_led_Gruen, HIGH);
delay(widerstandswert);
digitalWrite(modul_led_Gruen, LOW);
delay(widerstandswert);
} // ende loop
Hier folgt eine Zusammenfassung des Codes:
Zuerst erstellen wir für die LED und den Potentiometer eine Variable. Um den Widerstandswert des Potentiometers zu speichern, erstellen wir eine weitere Variable.
Im Setup bestimmen wir, dass der Pin der grünen LED ein Spannungsausgang ist. Den Potentiometer müssen wir hier nicht weiter definieren, weil analoge Pins standardmäßig ein Eingang sind.
Im Loop wird zuerst der Widerstandswert in der Variable „widerstandswert“ gespeichert. Anschließend schalten wir die grüne LED ein und warten für die Dauer des aktuellen Widerstandswerts in Millisekunden.
Anschließend schalten wir die wieder LED aus und ergänzen eine letzte Wartezeit. Auch diese Wartezeit entspricht dem Widerstandswert in Millisekunden.
Welche Änderung müssten wir in unserem Programmcode vornehmen, um uns den Widerstandswert im seriellen Monitor anzeigen zu lassen?
/* Variablen */
int modul_potentiometer = A6;
int modul_led_Gruen = 10;
int widerstandswert = 0;
/* Setup */
void setup()
{ // start setup
pinMode(modul_led_Gruen, OUTPUT);
} // ende setup
/* loop */
void loop()
{ // start loop
widerstandswert = analogRead(modul_potentiometer);
digitalWrite(modul_led_Gruen, HIGH);
delay(widerstandswert);
digitalWrite(modul_led_Gruen, LOW);
delay(widerstandswert);
} // 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.