In diesem Tutorial lernst du, wie du mehrere LEDs gleichzeitig mit unterschiedlichen Frequenzen, Verzögerungen und Tastverhältnissen mithilfe eines Arduino oder ESP32 zum Blinken bringst.
Das Blinken einer einzelnen LED ist einfach und eines der ersten Beispiele, die man beim Einstieg in die Arduino-Programmierung lernt. Das unabhängige Blinken mehrerer LEDs mit unterschiedlichen Frequenzen kann jedoch ziemlich knifflig werden. In diesem Tutorial verwenden wir die ezOutput-Bibliothek, um das zu vereinfachen. Außerdem zeige ich dir, wie du Frequenzen und Tastverhältnisse in Verzögerungszeiten umrechnest.
Aber bevor wir starten, werfen wir einen Blick auf die benötigten Bauteile.
Benötigte Bauteile
Hier die Liste der benötigten Bauteile. Ich habe für dieses Projekt einen Arduino Uno verwendet, aber jedes andere Arduino-Board oder ESP8266/ESP32-Board funktioniert genauso gut. Und natürlich, wenn du bereits LEDs und passende Widerstände (220Ω) hast, musst du diese nicht extra kaufen.
Arduino Uno
USB-Kabel für Arduino UNO
Dupont-Kabel-Set
Breadboard
Widerstands- & LED-Kit
Arduino IDE
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Was ist Frequenz
Bevor wir die Schaltung aufbauen und den Code schreiben, sprechen wir kurz darüber, was Frequenz eigentlich ist. Das wird die Sache später vereinfachen. Die einfachste Definition von Frequenz ist meiner Meinung nach folgende:
Frequenz ist die Anzahl der Wiederholungen eines Musters oder Ereignisses pro Sekunde.
Wenn zum Beispiel eine LED innerhalb einer Sekunde viermal ein- und ausgeschaltet wird, blinkt sie mit einer Frequenz von 4 Hertz (Hz). Siehe das Bild unten, das das Schaltsignal für eine LED veranschaulicht.
Das Ereignis des Umschaltens der LED passiert 4-mal innerhalb einer Sekunde. Daher beträgt die Frequenz 4 Hz. Wenn wir die LED zehnmal pro Sekunde ein- und ausschalten würden, blinkt sie mit einer Frequenz von 10Hz.
Üblicherweise wird die Frequenz mit folgender Formel angegeben: f ist definiert als 1 geteilt durch die Zeit T , die benötigt wird, um ein Muster (ein Umschalt-Ereignis) abzuschließen:
Es ist dasselbe, nur umgekehrt ; ) Wenn wir die LED viermal in einer Sekunde schalten (=4Hz), bedeutet das, dass T = 1/4 = 0,25 Sekunden für ein Umschalt-Ereignis benötigt werden. Setzen wir das in die obige Formel ein: 1/T = 1/0,25s = 4Hz.
Frequenz einer Sinuswelle
Beachte, dass Frequenz nicht auf Rechteckimpulse oder Umschalt-Ereignisse beschränkt ist. Wir können die Frequenz für jede Art von sich wiederholendem Muster oder Ereignis berechnen. Ein häufiges Beispiel ist eine Sinuswelle, die wir verwenden könnten, um die Helligkeit einer LED pulsierend (hoch- und runterdimmen) zu steuern.
Das folgende Beispiel zeigt eine Sinuswelle über zwei Perioden. Angenommen, eine Periode dauert 0,1 Sekunden. Die Sinuswelle hätte dann eine Frequenz von 10Hz.
Arduinos tone()-Funktion
Beachte, dass die Arduino-Sprache eine eingebaute Funktion namens tone() hat, mit der du ein Rechtecksignal mit einer Frequenz von 16Hz bis 4MHz (beim Arduino Uno) erzeugen kannst. Für die meisten Anwendungen, bei denen LEDs blinken sollen, ist jedoch selbst die niedrigste Frequenz von 16Hz meist zu schnell. Oft wollen wir langsamer blinken und können daher tone() nicht verwenden.
Außerdem kann tone() nur Rechtecksignale mit einem Tastverhältnis von 50% erzeugen. Lass uns kurz über Tastverhältnisse sprechen und warum das eine Einschränkung ist, wenn wir LEDs blinken lassen wollen.
Was ist Tastverhältnis
Angenommen, du möchtest eine LED jede Sekunde ein- und ausschalten. Das entspricht einer Frequenz von 1Hz. Aber wie lange soll die LED in dieser Sekunde an sein und wie lange aus? Wenn sie für 50% der Sekunde (=0,5) an sein soll, entspricht das einem Tastverhältnis von 50%. Die Definition des Tastverhältnisses lautet:
Das Tastverhältnis ist der prozentuale Anteil der Zeit, in der ein Signal auf HIGH ist, verglichen mit der Gesamtzeit einer Periode.
Wenn wir die LED nur 0,1 Sekunden lang einschalten und die restlichen 0,9 Sekunden ausschalten, entspricht das einem Tastverhältnis von 10%. Das Bild unten zeigt drei Rechtecksignale mit unterschiedlichen Tastverhältnissen.
Du könntest denken, dass du das PWM-Signal, das von analogWrite() erzeugt wird, verwenden kannst, um LEDs mit unterschiedlichen Tastverhältnissen blinken zu lassen. Aber die Frequenz des PWM-Signals ist viel zu hoch ( 490Hz / 980Hz ), um LEDs damit zu blinken, auch wenn du die Frequenz etwas ändern kannst. Das ist aber etwas komplex und liefert nicht die Frequenzen, die man normalerweise zum Blinken von LEDs möchte.
Eine einzelne LED blinken lassen
Eine einzelne LED mit einer bestimmten Frequenz und einem Tastverhältnis zu blinken, ist einfach. Nehmen wir unser Beispiel von vorhin: Wir wollen eine LED mit 1Hz und 50% Tastverhältnis blinken lassen. Das bedeutet, wir schalten die LED 0,5 Sekunden (500 ms) an, dann 0,5 Sekunden aus und wiederholen den Zyklus. Das ist im Grunde das bekannte Blink-Beispiel:
void loop() {
digitalWrite(ledPin, HIGH);
delay(500);
digitalWrite(ledPin, LOW);
delay(500);
}
Wir könnten das etwas eleganter und flexibler machen, indem wir eine Funktion blink() implementieren, die eine LED mit einer gegebenen Frequenz f und einem Tastverhältnis dc blinken lässt:
void blink(int ledPin, float f, float dc) {
digitalWrite(ledPin, HIGH);
delay(1000 * dc / f);
digitalWrite(ledPin, LOW);
delay(1000 * (1 - dc) / f);
}
Das ist im Wesentlichen dasselbe wie zuvor, aber wir berechnen die delay() basierend auf Frequenz und Tastverhältnis. Die Verzögerung für die LED-An-Phase ist 1000 * dc / f basierend auf der oben besprochenen Frequenzformel. Die Berechnung für die Aus-Phase ist dieselbe, aber mit dem verbleibenden Anteil 1 – dc statt dc.
Eine vollständige Implementierung für eine LED an Pin 9, die mit 1Hz und 50% Tastverhältnis blinkt, sieht so aus:
int ledPin = 9;
void setup() {
pinMode(ledPin, OUTPUT);
}
void blink(int ledPin, float f, float dc) {
digitalWrite(ledPin, HIGH);
delay(1000 * dc / f);
digitalWrite(ledPin, LOW);
delay(1000 * (1 - dc) / f);
}
void loop() {
// 1 Hz, 50% duty cycle
blink(ledPin, 1, 0.5);
}
Das funktioniert gut für eine einzelne LED, aber nicht für mehrere LEDs mit unterschiedlichen Frequenzen! Probier es aus. Zum Beispiel kannst du mit folgendem Code nicht zwei LEDs blinken lassen, eine mit 1Hz und die andere mit 2Hz.
// This doesn't work!
void loop() {
// 1 Hz, 50% duty cycle
blink(ledPin1, 1, 0.5);
// 2 Hz, 50% duty cycle
blink(ledPi2, 2, 0.5);
}
Der Grund ist, dass die Verzögerungen (Blinken) nicht unabhängig (parallel), sondern nacheinander ausgeführt werden.
Wenn du mehrere LEDs mit unterschiedlichen Frequenzen und Tastverhältnissen blinken lassen willst, wird es deutlich komplexer. Wir haben dazu ein Tutorial: Control Multiple LEDs With Different Delays with Arduino . Und wenn du mehr Hintergrundwissen zum Blinken von LEDs brauchst, schau dir How To Blink An LED Using Arduino (4 Different Ways an.
In diesem Tutorial verwenden wir jedoch die ezOutput Bibliothek, um mehrere blinkende LEDs zu steuern. Das macht unsere Aufgabe viel einfacher.
Verwendung der ezOutput-Bibliothek zum Blinken von LEDs
Zuerst musst du die ezOutput library über den Library Manager installieren, bevor du sie verwenden kannst.
Hauptfunktionen der ezOutput-Bibliothek
Die ezOutput-Bibliothek hat verschiedene Funktionen, aber wir benötigen nur drei davon.
Die ezOutput() Funktion nimmt einen Pin als Eingabe und erstellt ein ezOutput Objekt darum herum. Es stellt die speziellen Pin-Funktionen bereit, die wir als Nächstes besprechen.
ezOutput(int pin)
Mit der blink() Funktion kannst du einen Pin für bestimmte Zeitintervalle ausschalten ( low ) und einschalten ( high ) ( lowTime , highTime ). Die Zeitintervalle sind in Millisekunden.
void blink(unsigned long lowTime, unsigned long highTime)
Das könntest du auch mit der delay() Funktion machen, wie wir im obigen Beispiel gesehen haben. Aber die blink() Funktion hat den Vorteil, dass sie unabhängig für verschiedene Pins mit unterschiedlichen Verzögerungen aufgerufen werden kann.
Damit das funktioniert, musst du die loop()-Funktion des ezObject() innerhalb der Arduino-Hauptschleife aufrufen.
void loop(void)
Klingt kompliziert? Ist es aber nicht. Schauen wir uns ein Beispiel an.
Drei LEDs mit unterschiedlichen Verzögerungszeiten blinken lassen
Im folgenden Beispielcode lassen wir drei LEDs an den Pins 11, 10 und 9 mit drei unterschiedlichen Frequenzen und Tastverhältnissen blinken.
#include "ezOutput.h"
ezOutput led1(11);
ezOutput led2(10);
ezOutput led3(9);
void setup() {
led1.blink(500, 500); // 1Hz, dc=50%
led2.blink(250, 250); // 2Hz, dc=50%
led3.blink(10, 90); // 10Hz, dc=90%
}
void loop() {
led1.loop();
led2.loop();
led3.loop();
}
Bibliotheken und Objekte
Wir beginnen mit dem Einbinden der Bibliothek „ezOutput.h“. Dann erstellen wir drei Instanzen der ezOutput-Klasse namens led1, led2 und led3, jeweils für eine LED an den Pins 11, 10 und 9.
#include "ezOutput.h" ezOutput led1(11); ezOutput led2(10); ezOutput led3(9);
Setup-Funktion
In der setup() Funktion konfigurieren wir jede LED so, dass sie mit einer bestimmten Frequenz und einem Tastverhältnis blinkt, indem wir die blink() Methode der ezOutput Bibliothek verwenden. Die Zeitintervalle, die an die blink() Methode übergeben werden, sind so gewählt, dass sie die Frequenz und das Tastverhältnis in den Kommentaren repräsentieren.
led1.blink(500, 500); // 1Hz, 50% duty cycle led2.blink(250, 250); // 2Hz, 50% duty cycle led3.blink(10, 90); // 10Hz, 90% duty cycle
Zum Beispiel für led1 : Wenn wir eine Blinkfrequenz von 1Hz und ein Tastverhältnis von 50% wollen, müssen wir die LED 500 ms einschalten und dann weitere 500 ms ausschalten. Also übergeben wir 500 ms Aus-Zeit und 500 ms Ein-Zeit an blink, um das zu erreichen.
Wenn wir die Verzögerungszeiten halbieren (250 ms), blinkt unsere LED doppelt so schnell, was einer Frequenz von 2Hz für led2 entspricht.
Und wenn wir das Tastverhältnis ändern wollen, müssen wir das Verhältnis zwischen Ein- und Aus-Zeiten anpassen. Für led3 beträgt die Ein-Zeit 90 ms und die Aus-Zeit 10 ms, was ein Tastverhältnis von 90% und eine Frequenz von 10Hz ergibt.
Loop-Funktion
In der loop() Funktion rufen wir kontinuierlich die loop() Methode für jedes LED-Objekt auf. So wird sichergestellt, dass jede LED unabhängig und entsprechend der in der setup() Funktion gesetzten Blinkparameter blinkt.
void loop() {
led1.loop();
led2.loop();
led3.loop();
}
Dieser Code funktioniert gut, aber du musst Blinkfrequenzen und Tastverhältnisse in Ein- und Aus-Zeiten für die blink-Funktion umrechnen. Wir können das bequemer machen, indem wir diesen Teil in eine eigene Funktion verpacken.
Drei LEDs mit unterschiedlichen Frequenzen blinken lassen
Im folgenden Codebeispiel machen wir genau dasselbe wie im obigen Beispiel. Drei LEDs an den Pins 11, 10 und 9 blinken mit Frequenzen 1Hz, 2Hz, 10Hz und Tastverhältnissen 50%, 50%, 90%.
#include "ezOutput.h"
ezOutput led1(11);
ezOutput led2(10);
ezOutput led3(9);
void setFrequency(ezOutput &led, float f, float dc=0.5) {
led.blink(1000*(1-dc)/f, 1000*dc/f);
}
void setup() {
setFrequency(led1, 1, 0.5);
setFrequency(led2, 2, 0.5);
setFrequency(led3, 10, 0.9);
}
void loop() {
led1.loop();
led2.loop();
led3.loop();
}
Wir haben jedoch unsere eigene Funktion setFrequency() hinzugefügt, die eine gegebene Frequenz f und ein Tastverhältnis dc in die lowTime und highTime Parameter umwandelt, die für die blink() Funktion benötigt werden.
void setFrequency(ezOutput &led, float f, float dc=0.5) {
led.blink(1000*(1-dc)/f, 1000*dc/f);
}
Anstatt blink() können wir nun setFrequency() in der setup() Funktion direkt mit Frequenzen und Tastverhältnissen aufrufen.
void setup() {
setFrequency(led1, 1, 0.5);
setFrequency(led2, 2, 0.5);
setFrequency(led3, 10, 0.9);
}
Beachte, dass wir Tastverhältnisse als Verhältnis (0,9) und nicht als Prozentwert (90%) angeben. Wenn du Prozentwerte verwenden möchtest, teile den dc Parameter einfach durch 100 in der Funktion.
Mit der setFrequency() Funktion kannst du jetzt mit Frequenzen und Tastverhältnissen arbeiten, anstatt mit Ein- und Aus-Zeiten, wenn dir das lieber ist.
Dieser Code funktioniert auch für ESP32 und ESP8266. Wähle einfach das richtige Board aus und passe die Pin-Konstanten entsprechend an. Zum Beispiel verwende ich auf meinem WEMOS Lolin ESP32 lite Board folgende Pins:
ezOutput led1(GPIO_NUM_22); ezOutput led2(GPIO_NUM_19); ezOutput led3(GPIO_NUM_23);
Als Nächstes bauen wir die Schaltung mit den drei LEDs, die wir blinken lassen wollen.
Blink-Schaltung mit drei LEDs
Das folgende Bild zeigt die Blink-Schaltung mit den drei LEDs und den strombegrenzenden Widerständen.
Der Aufbau ist einfach. Verbinde zuerst Ground (GND) vom Arduino mit der Ground-Schiene des Breadboards (blaues Kabel). Dann platziere die drei LEDs. Achte darauf, dass die kurzen Pins der LEDs (Kathode) mit der Ground-Schiene verbunden sind.
Jeder der langen LED-Pins ist mit einem 220Ω strombegrenzenden Widerstand verbunden. Die Widerstände sind an die GPIO-Pins 11, 10 und 9 des Arduino angeschlossen. Und das war’s. Deine Blink-Schaltung ist fertig.
Das folgende kurze Video zeigt den Code und die Schaltung in Aktion. Die LEDs blinken mit Frequenzen von 1Hz, 2Hz, 10Hz und Tastverhältnissen von 50%, 50%, 90%.
Viel Spaß beim Experimentieren mit verschiedenen Frequenzen, Tastverhältnissen und mehr LEDs.
Fazit
Zusammenfassend haben wir erfolgreich gelernt, wie man mehrere LEDs mit unterschiedlichen Frequenzen, Verzögerungen und Tastverhältnissen mit einem Arduino oder ESP32 blinken lässt. Durch das Verständnis der Konzepte von Frequenz und Tastverhältnis konnten wir eine Schaltung zur Steuerung der LEDs aufbauen und den notwendigen Code schreiben, um die gewünschten Blinkmuster zu erzeugen.
Die ezOutput-Bibliothek hat das sehr einfach gemacht, und du hast gesehen, dass es leicht ist, eigene Funktionen hinzuzufügen, um es noch bequemer zu machen.
Wenn du Fragen hast, schau dir die FAQ an oder schreibe einen Kommentar.
Viel Spaß ; )
Häufig gestellte Fragen
F: Kann ich verschiedene LED-Typen mit unterschiedlichen Frequenzen in derselben Schaltung verwenden?
A: Ja, du kannst verschiedene LED-Typen mit unterschiedlichen Frequenzen in derselben Schaltung verwenden. Passe einfach die Verzögerungszeiten im Code für jede LED an, um die gewünschte Blinkfrequenz zu erreichen.
F: Ist es möglich, das Blinken mehrerer LEDs mit unterschiedlichen Frequenzen zu synchronisieren?
A: Obwohl es schwierig sein kann, das Blinken mehrerer LEDs mit stark unterschiedlichen Frequenzen zu synchronisieren, kannst du mit der Anpassung der Verzögerungszeiten experimentieren, um ein optisch ansprechendes Muster zu erzeugen. Verwende Arrays oder Funktionen, um die Blinkzeiten jeder LED zu verwalten.
F: Kann ich die Helligkeit jeder LED zusammen mit ihrer Frequenz steuern?
A: Ja, du könntest während der Ein-Zeit der LED ein PWM-Signal verwenden, um diesen Effekt zu erzielen. Die ezOutput-Bibliothek unterstützt das jedoch nicht direkt. Du müsstest den Code entsprechend anpassen und erweitern.
F: Wie kann ich mehr LEDs zur Schaltung hinzufügen und sie einzeln steuern?
A: Um mehr LEDs hinzuzufügen und sie einzeln zu steuern, verbinde jede LED mit einem separaten digitalen Pin am Arduino oder ESP32. Definiere dann im Code Variablen für die Verzögerungszeit und das Tastverhältnis jeder LED, um sie unabhängig zu steuern.
F: Wie viele LEDs kann ich gleichzeitig mit unterschiedlichen Frequenzen blinken lassen?
A: Die maximale Anzahl der LEDs, die du gleichzeitig mit unterschiedlichen Frequenzen blinken lassen kannst, hängt von der Rechenleistung und dem Speicher deines Mikrocontrollers ab. In der Regel kannst du mehrere LEDs mit unterschiedlichen Frequenzen steuern, solange genügend digitale Pins und Speicher für den Code vorhanden sind.
F: Kann ich externe Bauteile wie Transistoren oder Schieberegister verwenden, um die Anzahl der steuerbaren LEDs zu erweitern?
A: Ja, du kannst externe Bauteile wie Transistoren oder Schieberegister verwenden, um die Anzahl der steuerbaren LEDs zu erhöhen. Mit diesen Bauteilen kannst du effektiv mehr LEDs mit deinem Arduino oder ESP32 steuern und komplexere Lichtmuster erzeugen. Für mehr Details schau dir unser Tutorial an: More Arduino Outputs With 74HC595 Shift Register .
F: Wie berechne ich die Verzögerungszeit für eine bestimmte Blinkfrequenz?
A: Um die Verzögerungszeit für eine bestimmte Blinkfrequenz zu berechnen, kannst du die Formel verwenden: Verzögerungszeit = 1 / (2 * Frequenz). Wenn du zum Beispiel eine LED mit 2 Hz (bei 50% Tastverhältnis) blinken lassen möchtest, beträgt die Verzögerungszeit 250 Millisekunden.
F: Wie kann ich komplexere LED-Muster wie Fading- oder Puls-Effekte erzeugen?
A: Um komplexere LED-Muster wie Fading- oder Puls-Effekte zu erzeugen, kannst du zusätzliche Logik in deinen Code einbauen, z.B. lineare Interpolation für Fading oder sinusförmige Funktionen für Puls-Effekte. Durch die Steuerung der Helligkeitswerte über die Zeit kannst du dynamische Lichtmuster erzeugen.
F: Ist es möglich, das Blinken der LEDs mit externen Ereignissen oder Sensoren zu synchronisieren?
A: Ja, du kannst das Blinken der LEDs mit externen Ereignissen oder Sensoren synchronisieren, indem du Sensordaten oder Ereignisauslöser in deinen Code integrierst. Zum Beispiel kannst du die Blinkfrequenz basierend auf Sensorwerten wie Lichtintensität, Temperatur oder Bewegungserkennung anpassen.
F: Kann ich verschiedene Blinkmuster wie abwechselnde oder zufällige Sequenzen für mehrere LEDs implementieren?
A: Ja, du kannst verschiedene Blinkmuster wie abwechselnde oder zufällige Sequenzen für mehrere LEDs implementieren, indem du für jede LED individuelle Muster oder Sequenzen im Code definierst. Für solche Effekte ist die Verwendung eines Schieberegisters oft einfacher. Für mehr Details schau dir unser Tutorial an: More Arduino Outputs With 74HC595 Shift Register
F: Wie kann ich die LEDs in einem bestimmten Muster blinken lassen, z.B. Herzschlag oder Welle?
A: Um LEDs in bestimmten Mustern wie Herzschlag oder Welle blinken zu lassen, kannst du im Code benutzerdefinierte Sequenzen von Ein- und Aus-Zuständen für jede LED definieren. Durch Programmierung der Zeitpunkte und Übergänge zwischen diesen Zuständen kannst du einzigartige Blinkmuster erzeugen, die verschiedene Effekte nachahmen.
F: Kann ich Ton oder Musik verwenden, um das Blinken der LEDs mit Audio-Signalen zu synchronisieren?
A: Ja, du kannst das Blinken der LEDs mit Ton oder Musik synchronisieren, indem du Audiosignale analysierst oder Sound-Bibliotheken in deinen Code integrierst. Durch Erkennung von Beats oder Frequenzen im Audioeingang kannst du die Blinkmuster der LEDs an den Rhythmus oder die Intensität des Sounds anpassen und so audiovisuelle Effekte erzeugen.
F: Wie kann ich die LED-Muster interaktiv gestalten, sodass sie auf Benutzereingaben oder externe Befehle reagieren?
A: Um LED-Muster interaktiv und reaktionsfähig auf Benutzereingaben oder externe Befehle zu machen, kannst du Kommunikationsprotokolle wie Bluetooth oder Wi-Fi implementieren, um Befehle von Smartphone oder Computer zu empfangen. Indem du diese Eingaben im Code auswertest, kannst du die LED-Muster dynamisch an Benutzerinteraktionen oder externe Auslöser anpassen.
