Bemerkung
Hallo, willkommen in der SunFounder Raspberry Pi & Arduino & ESP32 Enthusiasten-Community auf Facebook! Tauche tiefer in die Welt von Raspberry Pi, Arduino und ESP32 zusammen mit anderen Enthusiasten ein.
Warum beitreten?
Expertenunterstützung: Löse nach dem Kauf auftretende Probleme und technische Herausforderungen mit Hilfe unserer Community und unseres Teams.
Lernen & Teilen: Tausche Tipps und Tutorials aus, um deine Fähigkeiten zu verbessern.
Exklusive Vorschauen: Erhalte frühzeitig Zugang zu neuen Produktankündigungen und ersten Einblicken.
Sonderrabatte: Profitiere von exklusiven Rabatten auf unsere neuesten Produkte.
Festliche Aktionen und Verlosungen: Nimm an Verlosungen und besonderen Feiertagsaktionen teil.
👉 Bereit, mit uns zu erkunden und zu erschaffen? Klicke auf [hier] und trete noch heute bei!
11. Die Farben des Regenbogens
Stell dir vor, du könntest mit Licht malen, indem du Rot, Grün und Blau mischst, um jede erdenkliche Farbe zu erzeugen – ähnlich wie das Mischen von Farben auf einer Palette, aber mit Lichtstrahlen.
Willkommen zu dieser Lektion, in der du die faszinierende Welt der RGB-LEDs erkunden wirst und erfährst, wie die Kombination von Primärfarben ein lebendiges Farbspektrum erschaffen kann. Dieser praxisorientierte Kurs führt dich durch die Funktionsprinzipien der RGB-LEDs und zeigt dir die praktischen Anwendungen von Programmierung und Schaltungsaufbau.
In dieser Lektion wirst du lernen:
Die Funktionsweise von RGB-LEDs zu verstehen.
Wie du in deinem Code Funktionen erstellst und nutzt, um Aufgaben zu vereinfachen und die Lesbarkeit zu verbessern.
Die Auswirkungen verschiedener Farbkombinationen zu erkunden, indem du die RGB-LED steuerst.
Pulse Width Modulation (PWM) zur fein abgestimmten Farbmischung mit der RGB-LED anzuwenden.
Deine Programmierfähigkeiten zu verbessern und den Code durch die Erstellung von Funktionen, die Parameter in Arduino verwenden, effizienter und übersichtlicher zu gestalten.
Aufbau der Schaltung
Benötigte Komponenten
1 * Arduino Uno R3 |
1 * RGB-LED |
3 * 220Ω Widerstand |
Verbindungskabel |
1 * USB-Kabel |
1 * Steckbrett |
1 * Multimeter |
|
Schritt-für-Schritt Bauanleitung
Folge dem Verdrahtungsdiagramm oder diesen Schritten, um die Schaltung aufzubauen.

Beginne mit einer RGB-LED.
RGB-LEDs emittieren Licht in verschiedenen Farben, indem sie rote, grüne und blaue LEDs in einem einzigen Gehäuse integrieren. Durch das Variieren der Spannung an den drei Pins können diese LEDs kombiniert werden, um bis zu 16.777.216 verschiedene Farben zu erzeugen.

Je nach Design können RGB-LEDs entweder gemeinsame Anode oder gemeinsame Kathode haben. Für dieses Projekt verwenden wir eine gemeinsame Kathoden-RGB-LED, bei der alle drei LEDs eine negative Verbindung teilen.
Gemeinsame Kathoden-RGB-LEDs haben eine gemeinsame negative Verbindung.
Gemeinsame Anoden-RGB-LEDs haben eine gemeinsame positive Verbindung.

Eine RGB-LED hat typischerweise 4 Pins; der längste ist die Masse. Achte beim Platzieren der RGB-LED darauf, dass der längste Pin der zweite von links ist, und ordne die Pins als Rot, GND, Grün und Blau von links nach rechts.

Du kannst auch ein Multimeter im Dioden-Testmodus verwenden, um die Farbe zu identifizieren, die jeder Pin emittiert.
Stelle das Multimeter auf den Durchgangstest für Widerstandsmessungen ein.

Berühre den schwarzen Prüfspitzen des Multimeters an den längsten Pin der RGB-LED und berühre die anderen Pins einzeln mit der roten Prüfspitze. Du wirst sehen, dass die RGB-LED in Rot, Grün oder Blau aufleuchtet.

Setze die RGB-LED in das Steckbrett ein, wobei der längste Pin in Loch 17D und die anderen drei Pins in 18C, 16C und 15C eingesetzt werden.

Setze drei 220 Ohm-Widerstände wie gezeigt ein, von Löchern 15E bis 15G, 16E bis 16G und 18E bis 18G.

Verbinde diese Widerstände mit den Pins 9, 10 und 11 des Arduino Uno R3 mittels Verbindungskabeln, wie abgebildet.

Verbinde den längsten Pin der RGB-LED mit der negativen Schiene des Steckbretts, indem du ein Verbindungskabel verwendest.

Codeerstellung - Eine RGB-LED zum Leuchten bringen
Öffne die Arduino IDE und starte ein neues Projekt, indem du im Menü „Datei“ „Neues Sketch“ auswählst.
Speichere dein Sketch als
Lesson11_Rainbow_Color
mitStrg + S
oder durch Klicken auf „Speichern“.Erstelle drei Variablen, um die drei Pins der RGB-LED zu speichern und setze sie auf OUTPUT.
const int redPin = 11;
const int greenPin = 10;
const int bluePin = 9;
void setup() {
// Füge hier deinen Setup-Code ein, der einmal ausgeführt wird:
pinMode(bluePin, OUTPUT); // Setze den blauen Pin der RGB-LED auf Ausgang
pinMode(greenPin, OUTPUT); // Setze den grünen Pin der RGB-LED auf Ausgang
pinMode(redPin, OUTPUT); // Setze den roten Pin der RGB-LED auf Ausgang
}
void loop() {
// Füge hier deinen Hauptcode ein, der wiederholt ausgeführt wird:
}
Setze im
void loop()
den roten Pin der RGB-LED aufHIGH
und die anderen beiden Pins aufLOW
.
Bemerkung
Da wir PWM-Pins 9, 10 und 11 verwenden, hast du die Möglichkeit, entweder digitalWrite()
oder analogWrite()
zu verwenden, um ein hohes oder niedriges Signal auszugeben.
In dieser Lektion setzen wir die Pins einfach auf hoch oder niedrig, daher verwenden wir digitalWrite()
.
void setup() {
// Füge hier deinen Setup-Code ein, der einmal ausgeführt wird:
pinMode(bluePin, OUTPUT); // Setze den blauen Pin der RGB-LED auf Ausgang
pinMode(greenPin, OUTPUT); // Setze den grünen Pin der RGB-LED auf Ausgang
pinMode(redPin, OUTPUT); // Setze den roten Pin der RGB-LED auf Ausgang
}
void loop() {
// Füge hier deinen Hauptcode ein, der wiederholt ausgeführt wird:
digitalWrite(bluePin, LOW); // Schalte den blauen Pin der RGB-LED aus
digitalWrite(greenPin, LOW); // Schalte den grünen Pin der RGB-LED aus
digitalWrite(redPin, HIGH); // Schalte den roten Pin der RGB-LED ein
}
Speichere den Code und klicke auf „Hochladen“, um ihn an dein Arduino Uno R3 zu senden. Schau dir das Ergebnis an.
Du wirst sehen, dass die RGB-LED rot aufleuchtet. Aber was, wenn du auch grün und blau zum Leuchten bringen möchtest? Wie solltest du den Code ändern?
Kopiere die drei digitalWrite()
-Befehle zweimal und setze den Pin, den du anzeigen möchtest, auf HIGH
, während die anderen auf LOW
gesetzt werden. Jede Farbe sollte für eine Sekunde leuchten.
const int redPin = 11;
const int greenPin = 10;
const int bluePin = 9;
void setup() {
// Füge hier deinen Setup-Code ein, der einmal ausgeführt wird:
pinMode(bluePin, OUTPUT); // Setze den blauen Pin der RGB-LED auf Ausgang
pinMode(greenPin, OUTPUT); // Setze den grünen Pin der RGB-LED auf Ausgang
pinMode(redPin, OUTPUT); // Setze den roten Pin der RGB-LED auf Ausgang
}
void loop() {
// Füge hier deinen Hauptcode ein, der wiederholt ausgeführt wird:
digitalWrite(bluePin, LOW); // Schalte den blauen Pin der RGB-LED aus
digitalWrite(greenPin, LOW); // Schalte den grünen Pin der RGB-LED aus
digitalWrite(redPin, HIGH); // Schalte den roten Pin der RGB-LED ein
delay(1000); // Warte 1 Sekunde
digitalWrite(bluePin, LOW); // Schalte den blauen Pin der RGB-LED aus
digitalWrite(greenPin, HIGH); // Schalte den grünen Pin der RGB-LED ein
digitalWrite(redPin, LOW); // Schalte den roten Pin der RGB-LED aus
delay(1000); // Warte 1 Sekunde
digitalWrite(bluePin, HIGH); // Schalte den blauen Pin der RGB-LED ein
digitalWrite(greenPin, LOW); // Schalte den grünen Pin der RGB-LED aus
digitalWrite(redPin, LOW); // Schalte den roten Pin der RGB-LED aus
delay(1000); // Warte 1 Sekunde
}
Lade den Code erneut hoch, um die Effekte zu sehen. Du wirst feststellen, dass die RGB-LED zwischen Rot, Grün und Blau wechselt.
Fragen:
Wenn du andere Farben erzeugen möchtest, was solltest du tun? Siehe dir das Diagramm unten an und fülle deine Ideen in deinem Handbuch aus.

Farbe |
Roter Pin |
Grüner Pin |
Blauer Pin |
---|---|---|---|
Rot |
HIGH |
LOW |
LOW |
Grün |
LOW |
HIGH |
LOW |
Blau |
LOW |
LOW |
HIGH |
Gelb |
|||
Pink |
|||
Cyan |
|||
Weiß |
Codeerstellung - Farben anzeigen
Auf unserem Weg, die Kontrolle über RGB-LEDs zu meistern, haben wir gesehen, wie wir mit digitalWrite()
die LED in Grundfarben leuchten lassen können. Um das volle Farbspektrum, das eine RGB-LED erzeugen kann, zu erkunden, werden wir nun analogWrite()
verwenden, um PWM-Signale (Pulsweitenmodulation) zu senden und so eine Vielzahl von Farbtönen zu erzeugen.
Schauen wir uns an, wie wir dies im Code umsetzen können.
Öffne die Arduino IDE und starte ein neues Projekt, indem du im Menü „Datei“ „Neues Sketch“ auswählst.
Speichere dein Sketch als
Lesson11_PWM_Color_Mixing
mitStrg + S
oder durch Klicken auf „Speichern“.Erstelle drei Variablen, um die drei Pins der RGB-LED zu speichern und setze sie auf OUTPUT.
const int redPin = 11;
const int greenPin = 10;
const int bluePin = 9;
void setup() {
// Setup-Code, der einmal ausgeführt wird:
pinMode(bluePin, OUTPUT); // Setze den blauen Pin der RGB-LED auf Ausgang
pinMode(greenPin, OUTPUT); // Setze den grünen Pin der RGB-LED auf Ausgang
pinMode(redPin, OUTPUT); // Setze den roten Pin der RGB-LED auf Ausgang
}
Verwende
analogWrite()
, um PWM-Werte an die RGB-LED zu senden. Aus Lektion 9 wissen wir, dass PWM-Werte die Helligkeit einer LED ändern können, und der PWM-Bereich liegt zwischen 0-255. Um Rot anzuzeigen, setzen wir den PWM-Wert des roten Pins der RGB-LED auf 255 und die anderen beiden Pins auf 0.
const int redPin = 11;
const int greenPin = 10;
const int bluePin = 9;
void setup() {
// Setup-Code, der einmal ausgeführt wird:
pinMode(bluePin, OUTPUT); // Setze den blauen Pin der RGB-LED auf Ausgang
pinMode(greenPin, OUTPUT); // Setze den grünen Pin der RGB-LED auf Ausgang
pinMode(redPin, OUTPUT); // Setze den roten Pin der RGB-LED auf Ausgang
}
void loop() {
// Hauptcode, der wiederholt ausgeführt wird:
analogWrite(bluePin, 0); // Setze den PWM-Wert des blauen Pins auf 0
analogWrite(greenPin, 0); // Setze den PWM-Wert des grünen Pins auf 0
analogWrite(redPin, 255); // Setze den PWM-Wert des roten Pins auf 255
}
Mit dieser Konfiguration wird nach dem Hochladen des Codes auf das Arduino Uno R3 die RGB-LED rot leuchten.
Die Funktion
analogWrite()
ermöglicht es der RGB-LED, nicht nur die sieben Grundfarben anzuzeigen, sondern auch viele andere verschiedene Farbtöne. Nun kannst du die Werte der Pins 9, 10 und 11 einzeln anpassen und die beobachteten Farben in deinem Handbuch notieren.
Roter Pin |
Grüner Pin |
Blauer Pin |
Farbe |
---|---|---|---|
0 |
128 |
128 |
|
128 |
0 |
255 |
|
128 |
128 |
255 |
|
255 |
128 |
0 |
Codeerstellung - Parametrisierte Funktionen
Die Verwendung der analogWrite()
-Funktion zur Anzeige verschiedener Farben kann den Code lang und unübersichtlich machen, wenn du viele Farben gleichzeitig anzeigen möchtest. Daher müssen wir Funktionen erstellen.
Im Gegensatz zur vorherigen Lektion bereiten wir uns darauf vor, eine Funktion mit Parametern zu erstellen.
Eine parametrisierte Funktion ermöglicht es dir, spezifische Werte an die Funktion zu übergeben, die dann diese Werte verwendet, um ihre Aufgaben auszuführen. Dies ist äußerst nützlich, um Eigenschaften wie die Farbintensität dynamisch anzupassen. Es macht deinen Code flexibler und leichter lesbar.
Beim Definieren einer parametrisierten Funktion gibst du an, welche Werte sie benötigt, um zu arbeiten, indem du die Parameter in Klammern direkt nach dem Funktionsnamen auflistest. Diese Parameter fungieren als Platzhalter, die durch tatsächliche Werte ersetzt werden, wenn die Funktion aufgerufen wird.
So definierst du eine parametrisierte Funktion, um die Farbe einer RGB-LED einzustellen:
Öffne das zuvor gespeicherte Sketch
Lesson11_PWM_Color_Mixing
. Klicke auf „Speichern unter…“ im Menü „Datei“ und benenne es inLesson11_PWM_Color_Mixing_Function
um. Klicke auf „Speichern“.Beginne damit, die Funktion nach dem
void loop()
mit dem Schlüsselwortvoid
, gefolgt vom Funktionsnamen und den Parametern in Klammern, zu deklarieren. Für unseresetColor
-Funktion verwenden wir drei Parameter –red
,green
undblue
–, die jeweils die Intensität der entsprechenden Farbkomponente der RGB-LED darstellen.
void loop() {
// Hauptcode, der wiederholt ausgeführt wird:
}
void setColor(int red, int green, int blue) {
}
Im Funktionskörper verwenden wir den Befehl
analogWrite()
, um PWM-Signale an die Pins der RGB-LED zu senden. Die ansetColor
übergebenen Werte bestimmen die Helligkeit jeder Farbe. Die Parameterred
,green
undblue
werden hier direkt verwendet, um die Intensität jedes LED-Pins zu steuern.
// Funktion zur Einstellung der Farbe der RGB-LED
void setColor(int red, int green, int blue) {
// PWM-Wert für rot, grün und blau an die RGB-LED senden
analogWrite(redPin, red);
analogWrite(greenPin, green);
analogWrite(bluePin, blue);
}
Nun kannst du die neu erstellte
setColor()
-Funktion imvoid loop()
aufrufen. Da du eine Funktion mit Parametern erstellt hast, musst du die Argumente in die Klammern()
einfügen, z. B.(255, 0, 0)
. Vergiss nicht, Kommentare hinzuzufügen.
void loop() {
// Hauptcode, der wiederholt ausgeführt wird:
setColor(255, 0, 0); // Anzeige der Farbe Rot
}
// Funktion zur Einstellung der Farbe der RGB-LED
void setColor(int red, int green, int blue) {
// PWM-Wert für rot, grün und blau an die RGB-LED senden
analogWrite(redPin, red);
analogWrite(greenPin, green);
analogWrite(bluePin, blue);
}
Wir wissen bereits, dass wir durch die Angabe verschiedener Werte für die drei Pins der RGB-LED unterschiedliche Farben erzeugen können. Aber wie können wir die RGB-LED genau in der gewünschten Farbe zum Leuchten bringen? Dafür benötigen wir eine Farbpalette. Öffne Paint (diese Software ist in Windows enthalten) oder eine beliebige Zeichenanwendung auf deinem Computer.

Wähle eine Farbe aus, die dir gefällt, und notiere ihre RGB-Werte.
Bemerkung
Beachte, dass du vor der Farbauswahl die Helligkeit auf die gewünschte Position einstellen solltest.

Füge die ausgewählte Farbe in die
setColor()
-Funktion imvoid loop()
ein und verwende diedelay()
-Funktion, um die Anzeigedauer jeder Farbe festzulegen.
void loop() {
// Hauptcode, der wiederholt ausgeführt wird:
setColor(255, 0, 0); // Anzeige der Farbe Rot
delay(1000); // Warte 1 Sekunde
setColor(0, 128, 128); // Anzeige der Farbe Türkis
delay(1000); // Warte 1 Sekunde
setColor(128, 0, 255); // Anzeige der Farbe Lila
delay(1000); // Warte 1 Sekunde
setColor(128, 128, 255); // Anzeige der Farbe Hellblau
delay(1000); // Warte 1 Sekunde
setColor(255, 128, 0); // Anzeige der Farbe Orange
delay(1000); // Warte 1 Sekunde
}
Unten findest du den vollständigen Code; du kannst auf „Hochladen“ klicken, um den Code auf das Arduino Uno R3 hochzuladen und die Effekte zu sehen.
const int redPin = 11;
const int greenPin = 10;
const int bluePin = 9;
void setup() {
// Setup-Code, der einmal ausgeführt wird:
pinMode(bluePin, OUTPUT); // Setze den blauen Pin der RGB-LED auf Ausgang
pinMode(greenPin, OUTPUT); // Setze den grünen Pin der RGB-LED auf Ausgang
pinMode(redPin, OUTPUT); // Setze den roten Pin der RGB-LED auf Ausgang
}
void loop() {
// Hauptcode, der wiederholt ausgeführt wird:
setColor(255, 0, 0); // Anzeige der Farbe Rot
delay(1000); // Warte 1 Sekunde
setColor(0, 128, 128); // Anzeige der Farbe Türkis
delay(1000); // Warte 1 Sekunde
setColor(128, 0, 255); // Anzeige der Farbe Lila
delay(1000); // Warte 1 Sekunde
setColor(128, 128, 255); // Anzeige der Farbe Hellblau
delay(1000); // Warte 1 Sekunde
setColor(255, 128, 0); // Anzeige der Farbe Orange
delay(1000); // Warte 1 Sekunde
}
// Funktion zur Einstellung der Farbe der RGB-LED
void setColor(int red, int green, int blue) {
// PWM-Wert für rot, grün und blau an die RGB-LED senden
analogWrite(redPin, red);
analogWrite(greenPin, green);
analogWrite(bluePin, blue);
}
Vergiss nicht, deinen Code zu speichern und deinen Arbeitsplatz aufzuräumen.
Zusammenfassung
Durch eine Reihe von Codierübungen wirst du Sketche schreiben, die die Farbe der RGB-LED dynamisch ändern. Beginnend mit einfachen Befehlen zur Steuerung jeder Farbe wirst du dann deinen Code refaktorisieren, um Funktionen zu verwenden, wodurch dein Setup modularer und wartungsfreundlicher wird. Dieser Ansatz macht den Code nicht nur sauberer, sondern vermittelt dir auch die Bedeutung von Funktionen in der Programmierung.