Tinkercad Übung 13 - RGB LED Farben mischen (2)

Farben mit Potentiometer mischen

In dieser Übung stellst du mit Potentiometern die Farbe einer RGB-LED ein.
  • Empfohlenes Vorwissen: Bedienung Tinkercad Circuits, Übung 12, Prozeduren, Funktionen, Variablen, Arithmetik
  • Neue Inhalte: Potentiometer auslesen mit analogRead(), map()

Schritt 1 - Demo-Entwurf öffnen und inspizieren

In Übung 12 hast du mit Hilfe von Tastern die Farbe einer RGB-LED eingestellt und gemischt. Das ging allerdings nur in festen Stufen (schrittweise). Jetzt wollen wir das Ganze stufenlos schaffen.

Öffne und kopiere diesen Demo-Entwurf:
https://www.tinkercad.com/things/5Xv0A4vkM9f-kkg-robotik-ubung-13-starter
Abbildung 1 - RGB LED und 3 Potentiometer

In der Schaltung in Abbildung 1 ist eine RGB-LED verbaut. Wie diese anzusteuern ist, hast du in Übung 12 gelernt. Das Programm im Demo-Entwurf konfiguriert bereits alle PWM-Pins der RGB-LED als Ausgang und stellt mit analogWrite() die Helligkeiten der einzelnen Farbkanäle und somit eine Farbe ein.

Anstatt der 6 Taster zum Einstellen der 3 Farbkanäle verwendet diese Schaltung Potentiometer. Diese hast du schon kurz in Übung 2 kennen gelernt. Ein Potentiometer ist ein variabler Widerstand. In der Simulation kann man diesem mit einem Drehknopf einstellen. Wie bereits in Übung 2 erwähnt, besteht ein Potentiometer intern eigentlich aus 2 variablen Widerständen, die in Summe immer den Gesamtwiderstand ergeben.

Platziert man 2 Widerstände in Serie in einem Stromkreis, fließt durch beide Widerstände derselbe Strom. Die Spannung, mit der der Strom durch den Stromkreis getrieben wird, wird von den beiden Widerständen vollständig wieder "verbraucht".

Im folgenden Beispiel sind 2 1,5V-AA-Batterien in Serie geschaltet. Es stehen also insgesamt 3V zur Verfügung. Diese 3 Volt werden von den beiden Widerständen wieder verbraucht. Momentan haben beide Widerstände denselben Widerstandswert, weswegen sich die zur Verfügung stehende Spannung zu gleichen Anteilen aufteilt. Über jedem Widerstand fallen also 1,5V ab. Solch eine Schaltung nennt man Spannungsteiler.

Starte die Simulation und beobachte die Spannungen, die die Multimeter messen:
(Falles es hier nicht lädt: Hier ist der Link.)


Die Anteile der Spannungen, die über den einzelnen Widerständen gemessen werden richten sich nach dem Verhältnis der Widerstandswerte:
  • oberer Widerstand gleich unterer Widerstand: jeweils 1/2 der Gesamtspannung
  • oberer Widerstand doppelt so groß wie unterer Widerstand: oben 2/3 und unten 1/3 der Gesamtspannung
Ersetzen wir die beiden Widerstände (und damit den Spannungsteiler) durch ein Potentiometer. Drehst du am Knopf, wird das Widerstands-Verhältnis aus den beiden inneren Widerständen verändert. Der Gesamtwiderstand bleibt dabei immer gleich.

Starte die Simulation, drehe am Potentiometer und beobachte die durch die Multimeter gemessenen Spannungen (Falles es hier nicht lädt: Hier ist der Link.):


Die Spannung des mittleren Anschlusses des Multimeters kann man also einstellen. Das machen wir uns zu Nutze, denn der Arduino kann auch Spannungen messen. Im Folgenden wirst du ein Programm schreiben, dass die Spannung des unteren Multimeters misst, also zwischen Potentiometer und GND (Minus-Pol).

Schritt 2 - Potentiometer auslesen

Du kennst bereits folgende Möglichkeiten mit einem Pin zu interagieren:

Pin als Ausgang konfigurieren:
  • digitalWrite(pin, Wert), digital, HIGH/LOW (Übung 5)
  • analogWrite(pin, Wert), "analog", PWM-Tastverhältnis zwischen 0 und 255 (Übung 11)
Pin als Eingang konfigurieren:
  • digitalRead(pin), digital, HIGH/LOW (Übung 6)
Jetzt kommt neu dazu, nicht nur den Zustand eines Pins auszulesen (entweder an/5V/HIGH oder aus/0V/LOW), sondern direkt die Spannung zu messen wie mit einem Multimeter. Diese Spannung kann zwischen 0V und 5V liegen:
  • analogRead(pin), analog, Spannung skaliert als Zahl zwischen 0 und 1023
Zum Beispiel:

int spannung_potentiometer_rot = analogRead(POTENTIOMETER_PIN_ROT);

Das geht mit allen Arduino-Pins, die mit einem "A" gekennzeichnet sind. Auf dem Arduino Uno sind das die Pins A0A1A2A3A4 und A5 (in der Simulation unten am Arduino). Alle anderen Pins können nur für digitalRead() verwendet werden. digitalRead() können die analogen Pins aber auch.

Schau doch mal in der Arduino-Referenz nach, was die zu dem Befehl analogRead() zu sagen haben:

Die gemessene Spannung wird auf einen Wertebereich von 0 bis 1023 abgebildet, ist also nicht wirklich analog, da die Auflösung begrenzt ist (wir können nur 1024 unterschiedliche Spannungen messen):
  • 0V ≙ 0
  • 2,5V ≙ 511
  • 5V ≙ 1023
Füge dem Programm im Demo-Entwurf eine Prozedur potentiometer_auslesen() hinzu, die alle 3 Potentiometer mit analogRead() ausliest und die Werte in den Helligkeits-Variablen abspeichert. Füge diese Prozedur in loop() hinzu, damit sie regelmäßig ausgeführt wird.

// Konstanten:
const int POTENTIOMETER_PIN_ROT = A0;
const int POTENTIOMETER_PIN_GRUEN = A1;
const int POTENTIOMETER_PIN_BLAU = A2;

Starte die Simulation und drehe an den Potentiometer-Drehknöpfen.
Drehe mal ganz langsam an einem Potentiometer. Was beobachtest du? Kommt dir das bekannt vor?
Abbildung 2 - LED-Helligkeit mit Potentiometer einstellen.

Schritt 3 - Richtigen Wertebereich einhalten

Vielleicht ist dir aufgefallen, dass ein Potentiometer einen Farbkanal nicht nur ein Mal von dunkel zu hell verstellt, sondern mehrere Male, d.h.:
  1. Potentiometer ganz nach links gedreht: LED aus
  2. Potentiometer langsam nach rechts drehen: LED wird heller
  3. LED geht wieder aus
  4. LED wird heller
  5. LED geht wieder aus
  6. ...
Wenn du gerade Übung 12 durchgearbeitet hast, kommt dir dieses Verhalten bekannt vor.

Wir haben nämlich den Wertebereich von analogWrite() nicht eingehalten: Das PWM-Tastverhältnis (die LED-Helligkeit) ist vom Typ byte, kann also nur Zahlen zwischen 0 und 255 beinhalten. Wird die Zahl zu groß, gibt es einen Überlauf.

analogRead() hingegen gibt uns Werte zwischen 0 und 1023 zurück und wir schreiben das dann in die Helligkeitsvariable, die wiederum in analogWrite() eingesetzt wird.

Der Rückgabewert von analogRead() muss also klein skaliert werden, damit er als Parameter für analogWrite() verwendet werden kann. Das Verhältnis aus 1023 und 255 ist

1023 / 255 ≈ 4

Wir können also rechnen:

helligkeit_led = potentiometer_spannung / 4

oder

helligkeit_led = potentiometer_spannung * 0.25  // also mal 1/4

Schreibe eine Funktion, die als Parameter die gemessene Potentiometer-Spannung aufnimmt und das klein skalierte PWM-Tasterverhältnis wieder zurück gibt. Benutze diese Funktion in der potentiometer_auslesen() Prozedur.

Starte die Simulation und drehe an den Potentiometer-Drehknöpfen.
Drehe mal ganz langsam an einem Potentiometer. Ist das Problem repariert?

Schritt 4 - map()

Es gibt bereits eine fertige Arduino-Funktion, die uns dabei hilft:

int skalierte_zahl = map(zahl, von_min, von_max, zu_min, zu_max);

Lies dir die Beschreibung zu der Funktion in der Arduino-Referenz durch:

von_min ist der kleinste erwartete Wert von zahl und von_max der größte. Die Funktion map() skaliert zahl dann zu den neuen Grenzen zu_min und zu_max (entweder größer oder kleiner) und gibt die skalierte Zahl wieder zurück.

Ersetze die Rechnung aus Schritt 3 mit der map()-Funktion. Starte die Simulation und prüfe, ob noch alles wie vorher funktioniert.

Zusammenfassung

In dieser Übung hast du ein an einen Arduino angeschlossenes Potentiometer ausgelesen, den Messwert kleiner skaliert und damit die Helligkeit der einzelnen Farbkanäle einer RGB-LED gesteuert. Außerdem hast du die map()-Funktion kennen gelernt.

Kommentare

Beliebte Posts aus diesem Blog

Tinkercad Übung 6 - LED mit Taster ansteuern

Tinkercad Übung 11 - LED dimmen

Tinkercad Übung 15 - Ultraschallsensor auslesen