WS2812 en NeoPixel met Arduino aansturen

FunduinoLaatst bijgewerkt op 05.01.2017

Einzelne Pixel, Helligkeitsstufen und Farben am LED-Ring steuern

WS2812- und SK6812-LEDs, auch NeoPixel genannt, werden vor allem in LED-Streifen und großen Displays verwendet. Das Besondere daran ist, dass die einzelnen LEDs miteinander vernetzt sind. Jede LED lässt sich einzeln ansteuern, obwohl nur drei Kabel nötig sind: die Spannungsversorgung mit Plus und Minus sowie eine Datenleitung. Über diese Datenleitung steuerst du mit einem Mikrocontroller – in diesem Fall natürlich aus der Arduino-Reihe – alle LEDs an.

Eine gute Library zu den WS2812- und SK6812-LEDs gibt es von Adafruit. Dort werden die LEDs als „NeoPixel“ bezeichnet. Die Library kann alle Versionen der genannten LEDs ansteuern: sowohl die LEDs mit den drei Farben Rot, Grün und Blau (RGB) als auch die Versionen mit integrierter weißer LED (RGBW). Außerdem bietet Adafruit eine sehr umfangreiche Informationsseite und einige Sketche rund um das Thema NeoPixel an.

In unseren Anleitungen zu diesem Thema starten wir nicht sofort mit tollen Regenbogeneffekten, sondern mit der Ansteuerung einzelner Pixel in unterschiedlichen Helligkeitsstufen. Vielfarbige Regenbogeneffekte entstehen durch sogenannte Schleifen, die wiederum auf andere Schleifen für die Farbänderung zurückgreifen. Um diese Inhalte zu entzerren, beginnen wir möglichst unkompliziert.

Hinweis: Damit die Sketche in dieser Anleitung funktionieren, musst du vorab in der Arduino-Software die Library „Adafruit NeoPixel“ installieren. Du findest sie über die Funktion „Bibliothek einbinden“ in der Arduino-Software.

Runder LED-Ring mit WS2812-LEDs, auch NeoPixel genannt — LED-Ring mit WS2812-LEDs

Quadratische LED-Matrix mit 8x8 WS2812-LEDs — LED-Matrix mit 8x8 WS2812-LEDs

1 / 2

Den Befehl setPixelColor verstehen

Der wichtigste Befehl in den folgenden Sketchen lautet pixels.setPixelColor(x, pixels.Color(0,255,0)); Er enthält in der Klammer zwei Informationen.

Das Erste ist eine Zahl – hier als „x“ bezeichnet – und gibt die Nummer der LED an, die leuchten soll. Die zweite Information pixels.Color(0,255,0) enthält gleichzeitig Farbe und Helligkeit. Dazu stehen in der Klammer drei Zahlen, jeweils durch ein Komma getrennt: Die erste Zahl steht für Rot, die zweite für Grün und die dritte für Blau.

Für die Zahlen kannst du Werte zwischen 0 und 255 wählen. Je kleiner die Zahl, desto schwächer leuchtet die entsprechende Farbe. Beim Wert 0 bleibt die LED komplett dunkel, beim Wert 255 leuchtet sie in maximaler Stärke. Aktivierst du zwei oder drei Farben gleichzeitig, ergibt sich eine Farbmischung – beim letzten Beispiel unten leuchten alle drei farbigen LEDs zusammen und das Licht erscheint weiß.

In unserem Beispiel verwenden wir einen Ring mit 40 WS2812-LEDs. Du kannst diese Anleitung aber mit jedem anderen WS2812- bzw. NeoPixel-Modul durchführen. Wichtig ist nur, dass du im jeweiligen Sketch die Gesamtanzahl der LEDs angibst – in der Zeile #define NUMPIXELS 40. Die Zahl steht für die Anzahl der vorhandenen LEDs.

Farbwerte für RGB-LEDs

pixels.setPixelColor(x, pixels.Color(255,0,0));     // Rot
pixels.setPixelColor(x, pixels.Color(0,255,0));     // Grün
pixels.setPixelColor(x, pixels.Color(0,0,255));     // Blau
pixels.setPixelColor(x, pixels.Color(255,255,0));   // Gelb
pixels.setPixelColor(x, pixels.Color(0,255,255));   // Türkis
pixels.setPixelColor(x, pixels.Color(255,255,255)); // Weiß

RGB-LEDs oder RGBW-LEDs

Je nachdem, ob dein Modul RGB-LEDs oder RGBW-LEDs mit zusätzlicher weißer LED hat, gibst du das in der Zeile an, in der du die NeoPixel benennst:

Bei RGBW-LEDs kannst du im darauffolgenden Befehl alle vier LEDs ansteuern. Dazu ergänzt du in der Farbklammer eine vierte Zahl:

RGB- oder RGBW-LEDs festlegen

// Verwendung von RGB-LEDs:
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
// Verwendung von RGBW-LEDs:
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRBW + NEO_KHZ800);

Farbwerte für RGBW-LEDs

pixels.setPixelColor(x, pixels.Color(255,0,0,0));     // Rot
pixels.setPixelColor(x, pixels.Color(0,255,0,0));     // Grün
pixels.setPixelColor(x, pixels.Color(0,0,255,0));     // Blau
pixels.setPixelColor(x, pixels.Color(255,255,0,0));   // Gelb
pixels.setPixelColor(x, pixels.Color(0,255,255,0));   // Türkis
pixels.setPixelColor(x, pixels.Color(255,255,255,0)); // Weiß durch Farbmischung der drei farbigen LEDs
pixels.setPixelColor(x, pixels.Color(0,0,0,255));     // Weiß durch separate Ansteuerung der weißen LED

Den LED-Ring verkabeln

So verkabelst du den LED-Ring bzw. die LED-Matrix mit dem Arduino UNO:

DI (Digital Input) am Ring / an der Matrix – Pin D9 am Arduino UNO
GND am Ring / an der Matrix – GND am Arduino UNO
VCC am Ring / an der Matrix – 5V am Arduino UNO

Schaltplan: LED-Ring mit DI an Pin D9, GND an GND und VCC an 5V des Arduino UNO — NeoPixel-Ring am Arduino UNO

Eine LED im Kreis wandern lassen

In diesem Sketch wandert eine LED im Kreis: Die LEDs werden der Reihe nach aktiviert, während die jeweils vorherige LED abgeschaltet wird. Die Variable „i“ zählt dabei von 0 bis 39 und beginnt danach wieder bei 0.

Das Ergebnis sollte so aussehen wie auf dem folgenden Bild.

Die Zahlen 39 und 40 im Loop gehören zu einem Ring mit 40 LEDs. Wenn du ein Modul mit einer anderen LED-Anzahl verwendest, musst du außer NUMPIXELS auch diese beiden Zahlen anpassen.

LED-Ring mit einer einzelnen grün leuchtenden LED — So sieht das Ergebnis aus: eine grüne LED wandert im Kreis

Programmcode – Eine LED wandert im Kreis

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif
int i = 0;
#define PIN 9 // Hier wird angegeben, an welchem digitalen Pin die WS2812 LEDs bzw. NeoPixel angeschlossen sind
#define NUMPIXELS 40 // Hier wird die Anzahl der angeschlossenen WS2812 LEDs bzw. NeoPixel angegeben
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
int pause = 100; // 100 Millisekunden Pause bis zur Ansteuerung der nächsten LED.
void setup()
{
  pixels.begin(); // Initialisierung der NeoPixel
}
void loop()
{
  pixels.setPixelColor(i, pixels.Color(0,150,0)); // Pixel leuchtet in der Farbe Grün
  pixels.setPixelColor(i-1, pixels.Color(0,0,0)); // Der vorherige Pixel wird abgeschaltet
  pixels.show(); // Durchführen der Pixel-Ansteuerung
  if (i==0) pixels.setPixelColor(39, pixels.Color(0,0,0)); // Im Fall von Pixel "0" muss die vorherige (39) ausgeschaltet werden.
  pixels.show(); // Durchführen der Pixel-Ansteuerung
  delay(pause);
  i = i+1; // Die Variable "i" wird um eine Zahl vergrößert. Die neue Zahl "i" ist dann die nächste LED im LED-Ring
  if (i==40) i=0; // Wenn die Variable den Wert 40 erreicht hat, wird sie auf "0" zurückgesetzt, da die Nummerierung der LEDs nur von 0 bis 39 geht.
}

Mehrere LEDs nacheinander ansteuern

Für diesen Sketch verwenden wir erneut einen LED-Ring mit 40 WS2812-LEDs. Diesmal leuchten fünf LEDs nacheinander auf, und zwar jede etwas schwächer als die vorherige – von 255 über 150, 50 und 10 bis 1. Danach schaltet der Sketch alle fünf LEDs wieder aus und beginnt von vorne.

Programmcode – Fünf LEDs nacheinander in abnehmender Helligkeit

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif
#define PIN 9 // Hier wird angegeben, an welchem digitalen Pin die WS2812 LEDs bzw. NeoPixel angeschlossen sind
#define NUMPIXELS 40 // Hier wird die Anzahl der angeschlossenen WS2812 LEDs bzw. NeoPixel angegeben
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
int pause = 100; // 100 Millisekunden Pause bis zur Ansteuerung der nächsten LED.
void setup()
{
  pixels.begin(); // Initialisierung der NeoPixel
}
void loop()
{
  pixels.setPixelColor(0, pixels.Color(0,255,0)); // Der erste Pixel (Nummer 0) leuchtet grün
  pixels.show(); // Durchführen der Pixel-Ansteuerung
  delay(pause); // Pause, in dieser Zeit wird nichts verändert.
  pixels.setPixelColor(1, pixels.Color(0,150,0)); // Der zweite Pixel (Nummer 1) leuchtet etwas schwächer
  pixels.show(); // Durchführen der Pixel-Ansteuerung
  delay(pause); // Pause, in dieser Zeit wird nichts verändert.
  pixels.setPixelColor(2, pixels.Color(0,50,0)); // Der dritte Pixel (Nummer 2) leuchtet noch schwächer
  pixels.show(); // Durchführen der Pixel-Ansteuerung
  delay(pause); // Pause, in dieser Zeit wird nichts verändert.
  pixels.setPixelColor(3, pixels.Color(0,10,0)); // Der vierte Pixel (Nummer 3) leuchtet nur noch schwach
  pixels.show(); // Durchführen der Pixel-Ansteuerung
  delay(pause); // Pause, in dieser Zeit wird nichts verändert.
  pixels.setPixelColor(4, pixels.Color(0,1,0)); // Der fünfte Pixel (Nummer 4) glimmt nur noch
  pixels.show(); // Durchführen der Pixel-Ansteuerung
  delay(pause); // Pause, in dieser Zeit wird nichts verändert.
  // Zurücksetzen aller Pixelfarben auf Stufe "0" (aus)
  pixels.setPixelColor(0, pixels.Color(0,0,0));
  pixels.setPixelColor(1, pixels.Color(0,0,0));
  pixels.setPixelColor(2, pixels.Color(0,0,0));
  pixels.setPixelColor(3, pixels.Color(0,0,0));
  pixels.setPixelColor(4, pixels.Color(0,0,0));
  pixels.show(); // Durchführen der Pixel-Ansteuerung
  delay(pause); // Pause, die LEDs bleiben in dieser Zeit aus
}

Bedrahtete WS2812-LEDs verkabeln und ansteuern

Es gibt die WS2812-LEDs auch in bedrahteter Form. Die Programmierung dieser LEDs erfolgt genau wie bei den LEDs in der flachen Bauform. Schwieriger ist bei dieser Variante nur die Verkabelung, denn du musst jede LED mit der Spannungsversorgung sowie mit dem Dateneingang und dem Datenausgang verbinden. Hilfreich ist dabei eine Skizze mit der Beschriftung der Anschlüsse.

Im folgenden Aufbau haben wir drei bedrahtete WS2812-LEDs in einem Breadboard befestigt. Jede LED wird separat mit GND und 5V versorgt. Den Dateneingang der ersten LED verbindest du mit Pin 6 am Arduino UNO. Den Datenausgang der ersten LED verbindest du mit dem Dateneingang der zweiten LED und den Datenausgang der zweiten LED mit dem Dateneingang der dritten LED. Der Datenausgang der dritten LED bleibt unverkabelt.

Mit dem folgenden Sketch leuchten die drei LEDs nacheinander in unterschiedlichen Farben auf.

Skizze einer bedrahteten WS2812-LED mit Beschriftung der vier Anschlüsse — Anschlüsse einer bedrahteten WS2812-LED

Schaltskizze mit drei bedrahteten WS2812-LEDs, Datenleitung von Pin 6 des Arduino UNO durchgereicht — Drei bedrahtete WS2812-LEDs im Breadboard

1 / 2

Programmcode – Drei bedrahtete WS2812-LEDs

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h> // Required for 16 MHz Adafruit Trinket
#endif
#define PIN 6 // Pin für die Datenleitung
#define NUMPIXELS 3 // Anzahl der WS2812 LEDs bzw. NeoPixel
Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
void setup()
{
  pixels.begin(); // Initialisierung der LEDs
}
void loop() {
  pixels.setPixelColor(0, pixels.Color(0, 150, 0));
  pixels.show();   // Senden der aktualisierten Daten an die WS2812 LEDs
  delay(500);
  pixels.clear(); // Deaktivieren aller LEDs
  pixels.setPixelColor(1, pixels.Color(150, 0, 0));
  pixels.show();   // Senden der aktualisierten Daten an die WS2812 LEDs
  delay(500);
  pixels.clear(); // Deaktivieren aller LEDs
  pixels.setPixelColor(2, pixels.Color(0, 0, 150));
  pixels.show();   // Senden der aktualisierten Daten an die WS2812 LEDs
  delay(500);
  pixels.clear(); // Deaktivieren aller LEDs
}