17 Nov

LED-Lichterkette(n) mit Arduino steuern

Mit einem Arduino UNO und drei billigen LED-Lichterketten könnt ihr für Stimmung in der dunklen Jahreszeit sorgen. Es funktioniert (vermutlich) auch mit einer anderen Anzahl von Lichterketten – ich hatte aber nur drei zur Hand. Ich biete euch hier eine Grundanleitung, damit ihr eure Lichterkettenträume mit Arduino verwirklichen könnt. 😉

LED Lichterketten mit Arduino steuern

 

Grundsätzliches

Das hier ist gewissermaßen die USB-Lichterkette 2.0, aber mit mehr Power. Nachdem ich letztes Jahr die kleine batteriebetriebene Lichterkette mit verschiedenen Leuchte-Modi auf USB umgebastelt habe, wollte ich gerne einen zweiten Versuch starten. Diesmal aber mit einem Arduino UNO* zur Steuerung. Für dieses Beispiel habe ich deshalb simple batteriebetriebene LED-Lichterketten verwendet und die Batteriehalter abgeschnitten. Kann man vielleicht mal für ein anderes Projekt gebrauchen. 😉

Die LED Lichterkette vorher: Ins Batteriefach gehören 2x1,5V

Die LED Lichterkette vorher: Ins Batteriefach gehören 2×1,5V

Meine Lichterketten sind an ein Stück Leiterplatte gelötet, das über 4 Stifte verfügt. So kann man alles auf das Arduino UNO stecken. Die Leiterplatte und die Kabel habe ich danach noch mit Heißkleber überzogen. Nicht schön, aber katzensicher: die Kabel reißen nicht so schnell ab und es gibt auch keine versehentlichen Kurzschlüsse.

Verwendet habe ich für dieses Beispiel (!):

  • 3 Lichterketten (je 2×1,5V)
  • Arduino UNO*
  • ein Stückchen Leiterplatte
  • ein Stück Stiftleiste (4 Stifte)
  • für den echten/sicheren Betrieb: Vorwiderstände

Außerdem Lötkolben und Lot*, Heißklebepistole (und Heißkleber :-P) sowie Isolierband zum Markieren.

Wichtiger Sicherheitshinweis: Das hier ist nur ein Beispiel, um zu zeigen, wie ihr theoretisch eure LED-Lichterketten steuern könnt. Wenn ihr die Lichterketten wirklich über längere Zeit per Arduino betreiben wollt, solltet ihr Vorwiderstände (z. B. 330 Ohm) benutzen. Das erhöht die Lebenszeit der LEDs und wirkt gegebenenfalls auch Wärmeentwicklung vor. Außerdem solltet ihr grundsätzlich eure selbstgebastelten Lichterketten nicht unbeaufsichtigt lassen! Das gilt insbesondere dann, wenn euer Arduino z.B. an eine Steckdose oder starke Powerbank angeschlossen ist. Wenn Board oder LEDs warm werden oder verkokelt riechen, trennt sie sofort vom Strom!

 

Schritt 1: Die Lichterkette fachgerecht zerstören.

Öffnet das Batteriefach und seht nach, wie die Batterien eingelegt werden müssen. Heißt: Welches Kabel später an GND kommt und welches an einen Pin.

So sieht das Batteriefach der Lichterkette von innen aus.

So sieht das Batteriefach der Lichterkette von innen aus.

Zieht die Kabel vorsichtig raus (oder schneidet sie ab). Am besten markiert ihr zwischendrin die Kabel (z.B. mit etwas Isolierband). Falls die Ketten noch zusammengeschnürt sind, nehmt sie bloß noch nicht auseinander! Sonst habt ihr den totalen Kabelsalat.

Die drei Lichterketten sind markiert und fertig zum Löten.

Die drei Lichterketten sind markiert und fertig zum Löten.

 

Schritt 2: Alles irgendwie zusammenbasteln.

Schneidet/sägt/brecht ein Stück aus der Leiterplatte. Brecht 4 zusammenhängende Stifte aus der Stiftleiste. Markiert ggf. die Lochreihen auf der Platte.

Ich habe mich für die Reihenfolge GND, R, G, B entschieden. Mein „Mini-Shield“ verwendet also die 4 Pins GND, 13, 12, 11. Wenn euch das Anlöten von Stiften zu nervig ist, könnt ihr auch Kabelreste o.ä. verwenden.

Leiterplatte, Stifte und UNO, probeweise kombiniert.

Leiterplatte, Stifte und UNO, probeweise kombiniert.

Die Kabel werden durchgezogen und (nach einem kurzen Funktionstest) festgelötet: Die drei GND-Kabel in die linke Reihe, dann die anderen drei Kabel entsprechend ihrer Farbmakierung/Lichterkette.

Lichterketten-Funktionstest vor dem Löten.

Lichterketten-Funktionstest vor dem Löten.

Wenn alles zusammengelötet ist, könnt ihr noch Heißkleber auftragen. Das hält die Kabel dort, wo sie sein sollen.

 

Und jetzt? Blinken.

Für den ersten Test da oben habe ich das normale Blink-Beispiel aus dem Arduino-Sketchbook um die anderen zwei Pins erweitert.

 digitalWrite(13, HIGH); // rote LEDs an
 digitalWrite(12, HIGH); // gruene LEDs an
 digitalWrite(11, HIGH); // blaue LEDs an
 delay(2000); // 2 Sekunden warten
 
 digitalWrite(13, LOW); // rote LEDs aus
 digitalWrite(12, LOW); // gruene LEDs aus
 digitalWrite(11, LOW); // blaue LEDs aus
 delay(1000); // 2 Sekunden warten

Ihr könnt das Ganze auch etwas durchmischen, z.B. indem ihr nach diesem großen Block nur die rote Lichterkette oder nur die blaue Lichterkette blinken lasst.

 digitalWrite(13, HIGH); // rote LEDs an
 delay(2000); // 2 Sekunden warten
 
 digitalWrite(13, LOW); // rote LEDs aus
 delay(1000); // 2 Sekunden warten

 digitalWrite(11, HIGH); // blaue LEDs an
 delay(2000); // 2 Sekunden warten
 
 digitalWrite(11, LOW); // blaue LEDs aus
 delay(1000); // 2 Sekunden warten

 

Zu langweilig? Zufällig blinken.

Mein absolutes Lieblingsblinken wird durch Zufallswerte gesteuert. Es ist angelehnt an ein anderes Beispiel aus dem Arduino-Sketchbook, nämlich Blink Without Delay. Aber ich habe dieses Beispiel u.a. um eine Random-Funktion erweitert.

Zunächst werden aber Konstanten und Variablen benötigt. Dies erfolgt vor dem setup()-Teil.

// Die 3 Pins der Lichterketten als Konstanten definieren
 const int red = 13; // rote LEDs
 const int green = 12; // grüne LEDs
 const int blue = 11; // blaue LEDs
 
 // Variablen für den Zustand der LED und für den Zufallswert
 int ledState = LOW; // Variable für Status der LED (an oder aus)
 int ledRand = 0; // Variable für Zufallswert

void setup() {
 //Pins auf Output setzen
 pinMode(red, OUTPUT);
 pinMode(green, OUTPUT);
 pinMode(blue, OUTPUT);

}

Die Konstanten haben den Vorteil, dass wir theoretisch Farbsequenzen damit schreiben können. Die Variablen brauchen wir für den Zustand der LED (siehe Blink Without Delay) und für den Zufallswert.

Dieser Zufallswert wird durch die Funktion ledRandom() ermittelt:

void ledRandom() {

 ledRand = random(7); // Zufallszahl entspricht einer Zahl zwischen 0 und 6.
 
 switch (ledRand) { // Je nachdem, welchen Wert ledRand hat, wird eine der Blink-Optionen gewählt
 case 0:
 digitalWrite(red, ledState);
 digitalWrite(blue, ledState);
 digitalWrite(green, ledState);
 break;
 
 case 1:
 digitalWrite(red, ledState);
 break;
 
 case 2:
 digitalWrite(green, ledState);
 break;
 
 case 3:
 digitalWrite(blue, ledState);
 
 break;
 
 case 4:
 digitalWrite(red, ledState);
 digitalWrite(green, ledState);
 break;
 
 case 5:
 digitalWrite(blue, ledState);
 digitalWrite(green, ledState);
 break;
 
 case 6:
 digitalWrite(blue, ledState);
 digitalWrite(red, ledState);
 break;
 } 
}

Ich habe 7 verschiedene Möglichkeiten angegeben: Bei 0 werden alle LEDs angesprochen, bei 1 nur die roten, bei 2 die grünen, bei 3 die blauen, usw. Hier sieht man den Nutzen von Konstanten: Statt nur Pins anzugeben, kann ich einfach die Farbbezeichnung verwenden.

 

 

Den Zufall richtig einbinden

Der nächste Teil – loop() – zeigt, was es mit dem (von Blink Without Delay entlehnten) ledState auf sich hat und wie man den Zufallsgenerator einbindet:

void loop() {
 
 // nach Blink Without Delay: Status der LEDs umkehren.
 if (ledState == LOW) {
 ledState = HIGH;
 } else {
 ledState = LOW;
 }

// Zufalls-LEDs aufrufen
 ledRandom();

// Warten
 delay(3000);
}

ledState wird nämlich ins Gegenteil umgekehrt. Heißt: Aus wird an. Oder an wird aus. Danach wird ledRandom() aufgerufen, der LED-Status also ein bis drei LED-Ketten zugewiesen. Nach der Wartezeit von  Wartezeit und es loopt erneut.

So werden mal alle, mal eine, mal zwei, mal keine LED-Kette ein- oder ausgeschaltet. Wer die gelegentliche komplette Dunkelheit nicht mag, könnte auch mehr Möglichkeiten bei Switch-Case hinzufügen und ohne die ledState-Variable arbeiten. Mich stört es aber nicht. 🙂