Leuchtdioden können in jedem Projekt eingesetzt werden. Oft geht es dabei nicht nur um die einfache Signalisierung von Zuständen, sondern auch um visuelle Effekte.
Hier kommen RGB-LEDs zum Einsatz, d. h. LEDs, die in praktisch jeder Farbe leuchten können. In den letzten Jahren hat es hier einen Durchbruch gegeben. Ein einfacher Test wird zeigen, welchen Vorteil programmierbare LEDs (WS2812) haben.
Bestellen Sie ein Set mit Elementen und beginnen Sie mit dem Lernen in der Praxis! Hier gehts zum Shop >>
Was sind programmierbare Dioden?
Programmierbare Dioden, manchmal auch als intelligente Dioden bezeichnet, können für viele Anfänger rätselhafte Elemente sein. Wie macht sich ihre „Intelligenz“ bemerkbar? Ist ein spezielles Programmiergerät erforderlich? Um euch nicht länger im Ungewissen zu lassen, beginne ich mit einer kurzen Antwort auf die obigen Fragen.
Natürlich brauchen die Dioden kein Programmiergerät, ihre Programmierbarkeit liegt darin, dass jede Diode einen eingebauten Schaltkreis hat, mit dem wir kommunizieren werden. Der interne Controller stellt alle Parameter ein und die Diode leuchtet von diesem Zeitpunkt an in der gewählten Farbe.
Im Moment ist noch nicht jedem klar, wo dieser Vorteil gegenüber herkömmlichen LEDs liegt, wir werden das Schritt für Schritt herausfinden. Als Anreiz, der Lichteffekt, den man mit solchen modernen LEDs erzielen kann. Und das alles mit nur einem Arduino-Pin!
Zunächst ist es jedoch an der Zeit, über gewöhnliche RGB-LEDs in der Praxis zu sprechen!
Fertige Sets für Forbot-Kurse
Die Komponenten für die Übungen aus dem Arduino-Kurs (Stufe 2) sind als fertige Sets erhältlich! Darin enthalten sind programmierbare Dioden, analoge und digitale Thermometer, 7-Segment-Anzeigen und ein Bewegungssensor (PIR).
Vorbereiten des Arbeitsplatzes für den Arduino-Kurs
Zwei technische Aspekte zu Beginn. Einige Leser haben den Stoff der ersten Stufe des Arduino-Kurses bereits geübt. Andere sind erst jetzt eingestiegen. Ich glaube jedoch, dass, wie ich im vorherigen Artikel empfohlen habe, alle auf einem ähnlichen Niveau sind.
Bestellung in den Projekten - Unterlage
Je weiter die Projekte fortgeschritten sind, desto mehr Verbindungen entstehen zwischen der Kontaktplatine und dem Arduino. Das führt oft zu Unordnung und Fehlern. Deshalb liegt dem Komponenten-Set von eine universelle Forbot-Unterlage bei, um Ordnung in unsere Projekte zu bringen.
Klebe die Gummifüße auf die Unterseite der Unterlage. Klebe keine Löcher zu. Sie werden sich als nützlich erweisen, wenn du zusätzliche Module an der Unterlage befestigen oder das Ganze irgendwo dauerhaft fixieren willst.
Klebe die Füße auf die Seite, auf der sich keine Beschriftung befindet!
Als nächstes wird die Kontaktplatte aufgeklebt (auf der Unterseite befindet sich ein selbstklebendes Schwämmchen). Schließlich wird der Arduino aufgeschraubt. Es ist erforderlich, Kunststoff-Abstandshalter zwischen der Platine und der Unterlage zu platzieren. Es müssen nicht alle Befestigungslöcher verwendet werden, 2 auf der Diagonale reichen aus:
Externes Netzteil für den Arduino
In diesem Kurs werden wir Projekte erstellen, die normal funktionieren – nicht nur vorübergehende Demos. Daher wäre eine Stromversorgung über USB oder eine kleine Batterie nicht sinnvoll. Um Probleme zu vermeiden, enthalten die Sets auch ein Netzteil, das an den Arduino angeschlossen wird. Wie auf dem Bild oben zu sehen ist.
Beim Programmieren bzw. Anschließen des USB-Kabels muss die Verbindung nicht getrennt werden.
Der Anschluss des Netzteils bringt uns neben der stabilen Spannung auch einen sehr wichtigen Vorteil. Wir werden Zugang zu 12V Spannung am VIN-Pin haben, die wir bereits im nächsten Teil verwenden werden!
Form und Farbe des Netzteils aus den Sets können von denen auf den Fotos abweichen.
Dies beeinträchtigt jedoch in keiner Weise die Funktionalität.
RGB-LEDs in der Praxis - traditionelles Vorgehen
In der vorherigen Stufe des Arduino-Kurses haben wir gewöhnliche Leuchtdioden verwendet. Jede hatte zwei Anschlüsse (Kathode und Anode) und leuchtete in einer Farbe. Darüber hinaus war es dank PWM möglich, ihre Helligkeit zu verändern.
Bei Problemen überprüfe die zusätzlichen Informationen über Leuchtdioden und PWM.
RGB-LEDs (Rot, Grün, Blau) bieten weitaus mehr Möglichkeiten, da die Hersteller drei Lichtstrukturen in sie einbauen. Rot, Grün und Blau – wir können jede davon separat steuern. Dadurch kann die Diode erstens in drei Grundfarben leuchten, und zweitens ist es natürlich möglich, Farben zu mischen.
Zwei RGB-LEDs mit mattierten Linsen sind im Lieferumfang enthalten. Solche LEDs leuchten nicht so hell wie die in transparenten Gehäusen, aber sie funktionieren viel besser, wenn Sie einen schönen Farbmix wünschen.
RGB-Dioden gibt es in Ausführungen mit einer gemeinsamen Kathode und Anode. In unserem Fall verwenden wir die Version mit einer gemeinsamen Kathode. Das bedeutet, dass das längste Bein mit GND verbunden ist und die anderen Beine über Widerstände mit positiver Spannung versorgt werden.
Erste Verwendung der RGB-Diode
Um die Diode zu testen, schließe sie nach folgendem Schema an:
- Rot, über einen 1k-Widerstand, an Pin 3.
- Gemeinsame Kathode, direkt an Masse.
- Grün, über einen 1k-Widerstand, an Pin 5.
- Blau, über einen 1k-Widerstand, an Pin 6.
Wenn du die Beine von Dioden und Widerständen abschneidest, solltest du zwei Dinge beachten:
- Schneide sie nicht zu kurz ab,
- hebe die abgeschnittenen Teile auf – sie werden als Verbindungen auf der Kontaktplatte nützlich sein.
Es ist Zeit für unser erstes einfaches Programm. Diesmal wollen wir das Licht jeder Farbe einzeln testen und schließlich alle Farben kombinieren.
#define Rot 3
#define Grün 5
#define Blau 6
void setup() {
pinMode(rot, OUTPUT); // Pins, die als Ausgänge mit der Diode verbunden sind
pinMode(grün, OUTPUT);
pinMode(blau, OUTPUT);
}
void loop() {
digitalWrite(rot, HIGH); // Leuchtet nur rot
delay(2000);
digitalWrite(rot, LOW); // Leuchtet nur grün
digitalWrite(grün, HIGH);
delay(2000);
digitalWrite(grün, LOW); // Leuchtet nur blau
digitalWrite(blau, HIGH);
delay(2000);
digitalWrite(blau, LOW);
digitalWrite(rot, HIGH); // Jede Diode der Reihe nach zum Leuchten bringen, ohne die vorherigen zu deaktivieren
delay(2000);
digitalWrite(grün, HIGH);
delay(2000);
digitalWrite(blau, HIGH);
delay(2000);
digitalWrite(rot, LOW); // Alle Dioden ausschalten
digitalWrite(blau, LOW);
digitalWrite(grün, LOW);
delay(2000);
}
In der Praxis wird es genau so sein, wie wir es erwarten:
Das gleichzeitige Einschalten aller Farben ergibt natürlich Weiß. Mit der PWM, die wir bereits kennengelernt haben, können wir die Stärke jeder Farbe separat einstellen. So können wir jede beliebige Farbe erzeugen. Bevor wir zu einem solchen Beispiel übergehen, wollen wir eine zweite Diode anschließen.
Anschluss von mehreren (herkömmlichen) RGB-LEDs
Um die zweite RGB-Diode in vollem Umfang nutzen zu können, ist es am bequemsten, drei weitere PWM-Kanäle zu verwenden. Da wir sie nicht anderweitig verwenden, ist das nicht problematisch.
Diesmal wird es so sein:
- Rot, über einen 1k-Widerstand, an Pin 9.
- Gemeinsame Kathode, direkt an Masse.
- Grün, über einen 1k-Widerstand, an Pin 10.
- Blau, über einen 1k-Widerstand, an Pin 11.
Der Form halber ein einfaches Programm zum Testen des Betriebs beider Dioden:
//Definition der Anschlüsse der ersten Diode
#define rot 3
#define grün 5
#define blau 6
//Definition der Anschlüsse der zweiten Diode
#define rot2 9
#define grün2 10
#define blau2 11
void setup() {
pinMode(rot, OUTPUT); //Konfiguration der Anschlüsse als Ausgang
pinMode(grün, OUTPUT);
pinMode(blau, OUTPUT);
pinMode(rot2, OUTPUT);
pinMode(grün2, OUTPUT);
pinMode(blau2, OUTPUT);
}
void loop() {
digitalWrite(rot, HIGH); //Blinken der Dioden in verschiedenen Farben
digitalWrite(grün2, HIGH);
delay(1000);
digitalWrite(rot, LOW);
digitalWrite(grün2, LOW);
digitalWrite(blau, HIGH);
digitalWrite(rot2, HIGH);
delay(1000);
digitalWrite(blau, LOW);
digitalWrite(rot2, LOW);
}
Die Wirkung des Programms besteht darin, dass die Dioden in verschiedenen Farben blinken:
Herkömmliche RGB-LEDs - Farbmischung
Jetzt können wir zum interessanteren Teil übergehen, nämlich die Tatsache auszunutzen, dass wir mit solchen Dioden beliebige Farben erreichen können. Es genügt, das PWM-Signal entsprechend zu erzeugen. Ich glaube, dass jeder die Idee bereits verstanden hat, deshalb beschränke ich mich auf ein einfaches Beispiel. So können wir schneller zu den programmierbaren Dioden übergehen.
Zunächst einmal das Programm in seiner einfachsten Version. Das PWM wird mit der Funktion analogWrite(Pin, Füllung) gesteuert, wobei die Füllung ein Wert von 0 bis 255 ist, was eine Regelung im Bereich von 0-100% bedeutet.
Mehr über PWM findet sich in Teil 5 des Arduino-Kurses, Stufe I.
Schreiben wir ein Programm, das die beiden Farben jeder LED gleichmäßig anpasst, für die dritte Farbe werden wir uns auf den Zufall verlassen. Beginnen wir mit einer einfachen for-Schleife:
//Definition der Anschlüsse der ersten Diode
#define rot 3
#define grün 5
#define blau 6
//Definition der Anschlüsse der zweiten Diode
#define rot2 9
#define grün2 10
#define blau2 11
void setup() {
pinMode(rot, OUTPUT); //Konfiguration der Anschlüsse als Ausgang
pinMode(grün, OUTPUT);
pinMode(blau, OUTPUT);
pinMode(rot2, OUTPUT);
pinMode(grün2, OUTPUT);
pinMode(blau2, OUTPUT);
}
void loop() {
int änderung = 0;
for (änderung = 0; änderung < 255; änderung++) { //Sanfter Farbwechsel
analogWrite(rot, 0);
analogWrite(grün, änderung);
analogWrite(blau, 255 - änderung);
analogWrite(rot2, änderung);
analogWrite(grün2, 255 - änderung);
analogWrite(blau2, 0);
delay(10); //Kurze Verzögerung, damit der Effekt für das menschliche Auge sichtbar wird
}
}
Die Schleife wird 255 Mal ausgeführt. Jedes Mal, wenn sie durchlaufen wird, wird die Variable Änderung um eins erhöht. Dieser Wert wird dann als Füllung einer der LED-Farben festgelegt und von der Füllung der anderen Farbe subtrahiert, die standardmäßig 100 % beträgt.
Im Fall der ersten Diode leuchtet die Diode bei jeder Ausführung der Schleife immer stärker in Grün und immer schwächer in Blau. Bei der zweiten Diode gewinnt Rot an Stärke und Grün wird schwächer.
Um die dritte Farbe zu verwenden, verwenden wir die Funktion, die eine Zufallszahl zurückgibt, die wir in Teil 10 des Arduino-Kurses, Stufe I, besprochen haben. Für einen gleichmäßigeren Effekt werden wir sie vor jeder Schleife erzeugen. Der folgende Code sollte uns zwei LEDs mit zufälligen Farbwechseln liefern.
//Definition der Anschlüsse der ersten Diode
#define rot 3
#define grün 5
#define blau 6
//Definition der Anschlüsse der zweiten Diode
#define rot2 9
#define grün2 10
#define blau2 11
void setup() {
pinMode(rot, OUTPUT); //Konfiguration der Anschlüsse als Ausgang
pinMode(grün, OUTPUT);
pinMode(blau, OUTPUT);
pinMode(rot2, OUTPUT);
pinMode(grün2, OUTPUT);
pinMode(blau2, OUTPUT);
randomSeed(analogRead(A5)); //Saatgut für Zufallszahlengenerator
}
void loop() {
int änderung = 0;
int zufälligeÄnderung = random(255);
for (änderung = 0; änderung < 255; änderung++) { //Sanfter Farbwechsel
analogWrite(rot, zufälligeÄnderung);
analogWrite(grün, änderung);
analogWrite(blau, 255 - änderung);
analogWrite(rot2, änderung);
analogWrite(grün2, 255 - änderung);
analogWrite(blau2, zufälligeÄnderung);
delay(10);
}
}
Es ist in Ordnung, aber es könnte besser sein – nach der Ausführung der for-Schleife kehren wir abrupt zum Anfang zurück, was zu einem unschönen Farbsprung führt. Um dies zu verbessern, müsste man die Farben auch sanft in die umgekehrte Richtung wechseln.
Dieses Mal werde ich eine nicht sehr anspruchsvolle Lösung vorschlagen – ich habe die Schleife kopiert und die Bedingung so geändert, dass sie beim zweiten Mal „rückwärts“ ausgeführt wird. Das ist natürlich keine sehr schöne Lösung, aber im Moment soll das Programm nur dieses Blinken ausführen, also kann man es sich leisten, es auf diese Weise zu programmieren.
Der endgültige Code des Beispiels sieht wie folgt aus:
//Definition der Anschlüsse der ersten Diode
#define rot 3
#define grün 5
#define blau 6
//Definition der Anschlüsse der zweiten Diode
#define rot2 9
#define grün2 10
#define blau2 11
void setup() {
pinMode(rot, OUTPUT); //Konfiguration der Anschlüsse als Ausgang
pinMode(grün, OUTPUT);
pinMode(blau, OUTPUT);
pinMode(rot2, OUTPUT);
pinMode(grün2, OUTPUT);
pinMode(blau2, OUTPUT);
randomSeed(analogRead(A5)); //Saatgut für Zufallszahlengenerator
}
void loop() {
int änderung = 0;
int zufälligeÄnderung = random(255);
for (änderung = 0; änderung < 255; änderung++) { //Sanfter Farbwechsel
analogWrite(rot, zufälligeÄnderung);
analogWrite(grün, änderung);
analogWrite(blau, 255 - änderung);
analogWrite(rot2, änderung);
analogWrite(grün2, 255 - änderung);
analogWrite(blau2, zufälligeÄnderung);
delay(10);
}
for (änderung = 255; änderung > 0; änderung--) { //Sanfter Farbwechsel "rückwärts"
analogWrite(rot, zufälligeÄnderung);
analogWrite(grün, änderung);
analogWrite(blau, 255 - änderung);
analogWrite(rot2, änderung);
analogWrite(grün2, 255 - änderung);
analogWrite(blau2, zufälligeÄnderung);
delay(10);
}
}
Die Auswirkungen in der Praxis sind in der nachstehenden Animation zu sehen:
Wir haben ein zufällig leuchtendes Gadget erschaffen, das einen interessanten visuellen Effekt haben könnte, wenn es mehr LEDs gäbe. Hier tritt ein Problem auf, denn bisher erforderte das Hinzufügen jeder zusätzlichen LED drei neue PWM-Kanäle. Durch den Anschluss von zwei RGB-LEDs haben wir bereits die Möglichkeiten unseres Arduino UNO (6 Kanäle) ausgeschöpft.
Bei der Verwendung aufwändigerer Programme und einiger neuer elektronischer Bauteile könnten noch ein paar Dioden hinzugefügt werden. Allerdings würden das Programm und der Schaltplan sehr, sehr schnell kompliziert werden.
Was wäre, wenn alle LEDs mit weniger Anschlüssen gesteuert werden könnten? Hier kommen natürlich die programmierbaren LEDs zum Einsatz, die wir von nun an verwenden werden.
Was ist eine programmierbare Diode?
Die LED-Technologie erfreut sich immer größerer Beliebtheit. Einfarbige Hintergrundbeleuchtung mit LEDs ist nicht mehr ungewöhnlich. In allen möglichen Gadgets und in der Leuchtreklame wurden gerne Streifen aus RGB-LEDs verwendet. Die Steuerung jeder einzelnen Diode wäre jedoch schwierig.
Daher wurden spezielle Schaltkreise entwickelt, die neben den LEDs angebracht werden. Diese ermöglichten es, die Farbe und Helligkeit mehrerer LEDs auf einfache Weise zu steuern. Die Beliebtheit dieser Lösung führte zur Entwicklung der WS2812-Chips. Das heißt, die Kombination eines RGB-Diodentreibers mit einer… RGB-LED. Alles in einem Gehäuse – normalerweise in der SMD-Technik (Oberflächenmontage).
So sind programmierbare RGB-LEDs entstanden. Dank der digitalen Kommunikation können wir Hunderte von Dioden mit einer einzigen Signalleitung steuern!
Ich gehe ferner davon aus, dass du ein fertiges RGB-Modul verwendest, so dass ich die Aspekte auslasse, die bei der Verwendung einzelner Dioden wichtig sind. Die Bauteil-Sets enthalten einen Streifen von 8 solcher Dioden. Jede zieht bis zu 30 mA, insgesamt also etwa 240 mA. Der Streifen kann mit einer Spannung von 4 V bis 7 V versorgt werden.
Je nach Variante kann er 3 oder 4 Anschlüsse haben. Dies macht keinen Unterschied. Bei einigen Modulen wird die Masse auf zwei Pins herausgeführt.
Mit dem bloßen Auge fallen diese LEDs nicht besonders auf. Erst wenn man heranzoomt, sieht man das, was am interessantesten ist. Der Treiber und die einzelnen Strukturen sind gut sichtbar.
Anschluss der WS2812-Diode
Unabhängig von der Anzahl der Dioden müssen wir immer drei Leitungen in das Modul einführen:
- Steuersignal, meist bezeichnet als: DIN, Data IN,
- die positive Stromschiene (4-7V), meist bezeichnet als: VIN, V oder + Zeichen,
- die Systemmasse, die meist mit GND oder – bezeichnet wird.
Überprüfe die Reihenfolge der Pinbelegung direkt auf dem Modul oder in der Dokumentation des Boardherstellers!
Es gibt viele ähnlich aussehende Module auf dem Markt, und ich kann nicht garantieren, dass die Anschlüsse immer auf dieselbe Weise angeordnet sind. Daher stelle ich aus Sicherheitsgründen keinen Montageplan zur Verfügung – ich arbeite mit Signalbezeichnungen.
Wir montieren das Modul auf der Kontaktplatte. Dann verbinden wir die Masse (zwei, falls vorhanden) mit der Schaltungsmasse und legen 5 V an die positive Stromschiene an. Parallel zu den Stromversorgungspins schließen wir einen Elektrolytkondensator an. Bei dieser Anzahl von Dioden sind 100uF ausreichend.
Anschließend schließen wir das Steuersignal an. Im Fall unserer Übung wird dies der Pin A0 sein. Gemäß den Empfehlungen des Herstellers tun wir dies nicht direkt. Zwischen dem Arduino-Anschluss und der Diodenleitung sollten wir einen Widerstand aus dem Bereich von 300-500R einstecken. In unserem Fall schließen wir dort zwei parallel geschaltete 1k-Widerstände an (was 500R ergibt).
Die Anordnung auf der Kontaktplatte sieht wie folgt aus:
Kommunikation mit den Dioden - fertige Bibliothek
Die Kommunikation mit den Dioden selbst erfolgt über ein spezielles Single-Wire-Interface. Dank der vorgefertigten Bibliothek brauchen wir uns jedoch nicht mit technischen Fragen zu befassen.
Falls erforderlich, wird ein entsprechender Artikel auf Forbot erscheinen.
Wir werden nun die beliebte NeoPixel-Bibliothek von Adafruit verwenden. Natürlich müssen wir sie zunächst installieren, ein Prozess, der je nach Compiler-Quelle variiert.
Bei Verwendung der Arduino-IDE, die von Arduino.cc heruntergeladen wird
Wählen Sie aus dem Menü:
Entwurf > Bibliothek einbinden > Bibliotheken verwalten
Gib dann Adafruit NeoPixel in das Suchfeld ein, wähle die entsprechende Bibliothek in der Liste aus und installiere sie dann:
Bei Verwendung der Arduino IDE, die von Arduino.org heruntergeladen wird
Wir laden die NeoPixel-Bibliothek von GitHub herunter, verwende einfach die Schaltfläche: Clone oder Download:
Wir benennen das Archiv von Adafruit_NeoPixel-master in Adafruit_NeoPixel um.
Dann wählen wir in der Arduino IDE:
Entwurf > Bibliothek importieren… > Bibliothek hinzufügen…
Wähle das soeben heruntergeladene Archiv (entpacke es nicht) und klicke auf Öffnen. Die Bibliothek sollte sich nach einer Weile selbst zu unserer IDE hinzufügen. Der einfachste Weg, dies zu überprüfen, ist die Auswahl von:
Datei > Beispiele
Ganz unten sollte eine Registerkarte mit Beispielprogrammen von NeoPixel zu sehen sein:
Grundfunktionen der NeoPixel-Bibliothek
Wenn die Installation erfolgreich verlaufen ist, können wir weitergehen und unser erstes Programm schreiben. Jedes Programm, das unsere Diodenstreifen verwendet, muss einen Verweis auf die Bibliothek und ihre Initialisierung enthalten. In der Praxis sieht das folgendermaßen aus:
#include <Adafruit_NeoPixel.h> //Hinzufügen der Bibliothek
//Konfiguration des Streifens
Adafruit_NeoPixel Streifen = Adafruit_NeoPixel(8, A0, NEO_GRB + NEO_KHZ800);
void setup() {
Streifen.begin(); //Initialisierung
Streifen.show();
}
void loop() {
}
Der beleuchtete Streifen ist der wichtigste. Hier erstellen wir ein Objekt namens Streifen, auf den wir später Bezug nehmen werden. Als nächstes geben wir in Klammern Informationen über das Modul an.
Die ersten beiden Parameter sind die wichtigsten. In diesem Fall steht 8 für die Anzahl der Dioden im Streifen, und A0 bezieht sich natürlich auf den Arduino-Pin, an den wir ihn angeschlossen haben. Der letzte Parameter ist die Information über die Version der Dioden selbst. Im Moment brauchen wir uns darum nicht zu kümmern.
Als Beispiel könnten wir unsere Dioden an einen anderen Pin, z.B. 3, anschließen und das Ganze als Lichtschlange statt als Streifen bezeichnen. Die Konfiguration würde dann wie folgt aussehen:
Adafruit_NeoPixel Licht_schlange= Adafruit_NeoPixel(8, 3, NEO_GRB + NEO_KHZ800);
Bleiben wir jedoch bei der ersten Version der Initialisierung und fahren wir mit dem ersten Programm fort.
Erster Test der programmierbaren Diode
Wir haben völlige Freiheit bei der Steuerung der LEDs. Wir können jeder eine andere Farbe und eine andere Helligkeit zuweisen. Dazu müssen wir sie in der folgenden Form ansprechen:
Streifen.setPixelColor(Diode, Farbe);
Der erste Parameter den wir angeben ist die Nummer der Diode (von Null beginnend). Der zweite Parameter ist die Farbe. Wie in der Computerwelt üblich, müssen wir sie als eine große Zahl ausdrücken.
Für uns Menschen ist es viel einfacher, wenn wir die Farbe mit drei kleineren Zahlen beschreiben können. Dann kann jede dieser Zahlen die Helligkeit einer Komponente darstellen, d. h. wir können die Helligkeit für Rot, Grün und Blau getrennt angeben. Hier kommt uns eine weitere Konstruktion zu Hilfe: Streifen.Color(0, 0, 0).
In der Praxis wird sie wie folgt verwendet:
- Streifen.setPixelColor(0, Streifen.Color(255, 0, 0)) – Diode 1 leuchtet rot
- Streifen.setPixelColor(0, Streifen.Color(0, 255, 0)) – Diode 1 leuchtet grün
- Streifen.setPixelColor(0, Streifen.Color(0, 0, 255)) – Diode 1 leuchtet blau
- Streifen.setPixelColor(6, Streifen.Color(100, 0, 255)) – Diode Nr. 7 leuchtet maximal hell in Blau und schwächer in Rot.
Schauen wir mal, ob wir die erste Diode in zum Laufen bringen können:
#include <Adafruit_NeoPixel.h> //Hinzufügung einer Bibliothek
//Konfiguration des Streifens
Adafruit_NeoPixel Streifen = Adafruit_NeoPixel(8, A0, NEO_GRB + NEO_KHZ800);
void setup() {
Streifen.begin(); //Initialisierung
Streifen.show();
Streifen.setPixelColor(0, Streifen.Color(0, 255, 0)); //Diode 1 leuchtet grün
}
void loop() {
}
Ich habe den Befehl in der Funktion setup aufgerufen, weil ich die LED nur einmal einschalten wollte. Es bestand keine Notwendigkeit, dies in einer Schleife zu tun. Nach der Ausführung des Programms…. passiert jedoch nichts! Warum eigentlich?
Wann immer ein Befehl oder eine Gruppe von Befehlen gesendet wird, die auf den LEDs sichtbar sein sollen, sollte der Befehl Streifen.show() ausgeführt werden;
Die korrekte Version des Programms, bei der die erste LED bereits zu 100 % grün leuchtet, sieht wie folgt aus:
#include <Adafruit_NeoPixel.h> //Hinzufügen der Bibliothek
//Konfiguration des Streifens
Adafruit_NeoPixel Streifen = Adafruit_NeoPixel(8, A0, NEO_GRB + NEO_KHZ800);
void setup() {
Streifen.begin(); //Initialisierung
Streifen.show();
Streifen.setPixelColor(0, Streifen.Color(0, 255, 0)); //Diode Nr 1 leuchtet grün
Streifen.show();
}
void loop() {
}
In der Praxis sieht das folgendermaßen aus:
Mit diesen wenigen Funktionen werden wir von nun an interessante visuelle Effekte erzeugen können. Im Moment werden wir zwei erstellen, die in den nächsten Teilen nützlich sein werden, wenn wir einen einfachen Alarm auslösen. Es handelt sich um zwei Arten der Signalisierung, ähnlich wie bei Polizeileuchten.
Alarmmelder
Die erste Version des Alarmmelders wird sehr einfach sein. Wir wollen, dass alle LEDs abwechselnd rot oder blau leuchten. Natürlich werden wir nicht jede von ihnen manuell ansteuern, sondern zwei for-Schleifen verwenden. Die Aufgabe der ersten Schleife ist es, alle LEDs auf Rot zu setzen:
int i = 0;
for (i = 0; i < 8; i++) {
Streifen.setPixelColor(i, Streifen.Color(255, 0, 0)); //Diode Nr. i leuchtet in der gewählten Farbe
}
Streifen.show();
Ich möchte, dass die LEDs gleichzeitig die Farbe wechseln. Aus diesem Grund wurde der Befehl Streifen.show() erst nach der Ausführung der Schleife aufgerufen.
Wenn du nicht verstehst, worum es bei show() geht, dann führe dieses Beispiel in aller Ruhe durch und mach weiter. Beim zweiten Alarmmelder werden wir das Gegenteil tun, und dann wird der Unterschied deutlich sichtbar sein.
Damit unser Alarmmelder schnell blinken kann, müssen wir eine zweite Farbe und eine kleine Verzögerung hinzufügen. Das Programm, das dieses Beispiel umsetzt, sieht wie folgt aus:
#include <Adafruit_NeoPixel.h> //Hinzufügen einer Bibliothek
//Konfiguration des Streifens
Adafruit_NeoPixel Streifen = Adafruit_NeoPixel(8, A0, NEO_GRB + NEO_KHZ800);
void setup() {
Streifen.begin(); //Initialisierung
Streifen.show();
}
void loop() {
int i = 0;
for (i = 0; i < 8; i++) {
Streifen.setPixelColor(i, Streifen.Color(255, 0, 0)); //Diode Nr i leuchtet in der gewählten Farbe
}
Streifen.show();
delay(250);
for (i = 0; i < 8; i++) {
Streifen.setPixelColor(i, Streifen.Color(0, 0, 255)); //Diode Nr i leuchtet in der gewählten Farbe
}
Streifen.show();
delay(250);
}
Der Effekt des Alarmmelders in der Praxis ist unten zu sehen:
Alarmmelder - zweite Version
Diesmal soll der Alarmmelder aus 4 roten und 4 blauen LEDs bestehen. Außerdem sollen sie nicht auf einmal aufleuchten, sondern nacheinander. Damit dies innerhalb einer Schleife geschieht, ruft man show() auf und fügt eine Verzögerung ein.
for (i = 0; i < 8; i++) {
Streifen.setPixelColor(i, Streifen.Color(0, 0, 255)); //Diode Nr i leuchtet in der gewählten Farbe
Streifen.show();
delay(100);
}
Wenn man eine solche Schleife laufen lässt, wird jede Diode nacheinander blau. Nun erweitern wir das Programm so, dass sich die Farbe ändert – dafür brauchen wir natürlich nur eine Bedingung. In der einfachsten Form sieht das wie folgt aus:
#include <Adafruit_NeoPixel.h> //Hinzufügen einer Bibliothek
//Konfiguration des Streifens
Adafruit_NeoPixel Streifen = Adafruit_NeoPixel(8, A0, NEO_GRB + NEO_KHZ800);
void setup() {
Streifen.begin(); //Initialisierung
Streifen.show();
}
void loop() {
int i = 0;
for (i = 0; i < 8; i++) {
if (i < 4) {
Streifen.setPixelColor(i, Streifen.Color(255, 0, 0)); //Diode Nr i leuchtet in der gewählten Farbe
} else {
Streifen.setPixelColor(i, Streifen.Color(0, 0, 255)); //Diode Nr i leuchtet in der gewählten Farbe
}
Streifen.show();
delay(100);
}
Streifen.clear();
}
Beachte die vorletzte Zeile des Programms – das ist der neue Befehl Streifen.clear(), der für das Leeren des gesamten Streifens verantwortlich ist, oder anders ausgedrückt, für das Ausschalten aller LEDs. Ohne diesen Befehl würde unser Effekt nur einmal ausgeführt werden. In der Praxis läuft das obige Programm wie folgt ab:
Die oben dargestellten Effekte waren nur eine Einführung. Wir werden Dioden auf immer fortschrittlichere Weise verwenden, wenn wir die Beispiele in anderen Artikeln weiterverfolgen. Als Hausaufgabe möchte ich euch ermutigen, mit euren eigenen Effekten zu experimentieren.
Ich empfehle auch, einen Blick auf die in der Bibliothek enthaltenen Beispielprogramme zu werfen. Bitte denke aber daran, sie entsprechend zu konfigurieren! Diese Programme sind zu finden unter:
Datei > Beispiele > Adafruit NeoPixel
Die Funktionsweise eines dieser Programme ist im folgenden Video zu sehen:
Wann handelt es sich um herkömmliche Dioden und wann um programmierbare Dioden?
Einige Leser werden sich wahrscheinlich die Frage stellen: Sollten wir dann die traditionellen RGB-LEDs ganz vergessen“? Meiner Meinung nach, nein. Wenn wir unser Gerät mit einer einzigen Steuerung ausstatten wollen, dann ist eine normale Diode vielleicht besser geeignet.
Wenn das Projekt jedoch die Verwendung mehrerer RGB-LEDs vorsieht, sollte man ohne zu zögern auf die WS2812 zurückgreifen. Dies vereinfacht sowohl die hardwaretechnische Seite als auch die Programmierung erheblich.
Zusammenfassung
Der Hauptzweck dieses Teils war es, in der Praxis zu sehen, wie sich herkömmliche Dioden von solchen mit eingebauten Treibern unterscheiden. Der mitgelieferte Diodenstreifen wird uns in den meisten der nachfolgenden Teile begleiten. Es wird unter anderem als Signalleuchte bei einem Alarm dienen und auch eine Skala für unsere Thermometer sein.
Im nächsten Teil werden wir die Signalleuchte um eine einfache Alarmsirene ergänzen, die einen abschreckenden Ton erzeugt.
Bestellen Sie ein Set mit Elementen und beginnen Sie mit dem Lernen in der Praxis! Hier gehts zum Shop >>
