Zero Point Module Arduino WS2812

Zero Point Module – mit Arduino und WS2812

Sebastian hat gefragt, ob ich ihm helfen könnte, den Code für das Leuchten eines Zero Point Moduls aus Stargate zu programmieren. Da ich die Serie sehr gern mag, bin ich gern behilflich. Auf Thingiverse gibt es ein Modell zum 3D-Drucken von SO3D, von dem auch das Titelbild ist (CC BY-NC 4.0). In diesem Projekt ist ebenfalls ein LED-Streifen eingesetzt. Hier gibt es sogar ein Video dazu:

Wir benötigen Ihre Zustimmung um den Inhalt von YouTube laden zu können.

Mit dem Klick auf das Video werden durch den mit uns gemeinsam Verantwortlichen Youtube [Google Ireland Limited, Irland] das Video abgespielt, auf Ihrem Endgerät Skripte geladen, Cookies gespeichert und personenbezogene Daten erfasst. Damit kann Google Aktivitäten im Internet verfolgen und Werbung zielgruppengerecht ausspielen. Es erfolgt eine Datenübermittlung in die USA, diese verfügt über keinen EU-konformen Datenschutz. Weitere Informationen finden Sie hier.

Jmx0O2RpdiBjbGFzcz0mcXVvdDtudi1pZnJhbWUtZW1iZWQmcXVvdDsmZ3Q7Jmx0O2lmcmFtZSB0aXRsZT0mcXVvdDtaZXJvIFBvaW50IE1vZHVsZSAoWlBNKSBmcm9tIHRoZSBTdGFyZ2F0ZSBVbml2ZXJzZSZxdW90OyB3aWR0aD0mcXVvdDsxMjAwJnF1b3Q7IGhlaWdodD0mcXVvdDs5MDAmcXVvdDsgc3JjPSZxdW90O2h0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkLzh1Mmk3Sl9adjZzP2ZlYXR1cmU9b2VtYmVkJnF1b3Q7IGZyYW1lYm9yZGVyPSZxdW90OzAmcXVvdDsgYWxsb3c9JnF1b3Q7YWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGNsaXBib2FyZC13cml0ZTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZSZxdW90OyBhbGxvd2Z1bGxzY3JlZW4mZ3Q7Jmx0Oy9pZnJhbWUmZ3Q7Jmx0Oy9kaXYmZ3Q7

Bauteile

Schaltplan

Zero Point Module Arduino WS2812

Sehen wir uns die Schaltung an. Dabei handelt es sich um ein Arduino UNO, dessen GND und 5V+ an den Anschlüssen des WS2812 Moduls anliegen. Der digitale Pin 3 ist über einen Widerstand (300 – 500 Ohm) mit dem Data-IN Pin des WS2812 Strips verbunden. Zwischen GND und 5V+ ist noch ein Elektrolyt-Kondensator (500 – 1000 uF, 16V) angeschlossen.

Programmtext

Ich habe zwei Programme geschrieben. Das erste Programm lässt einzelne LEDs in unterschiedlicher Geschwindigkeit aufblinken. Dabei kann die Anzahl der maximal gleichzeitig leuchtender LEDs und die Animationsgeschwindigkeit eingestellt werden.

#include <Adafruit_NeoPixel.h>                        // Bibliothek für die Neopixel LEDs (WS2812)

#define PIN 6                                         // Pin, an dem die LEDs angeschlossen sind
#define NUMPIXELS 9                                   // Anzahl der LEDs

int maxBrightness = 200;                              // maximale Helligkeit der LEDs
int animationSpeed = 40;                              // setzte die Animationsgeschwindigkeit (je höher, desto langsamer)

/* ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** */

int theValue[NUMPIXELS];                              // speichert den Leuchtwert
int theSpeed[NUMPIXELS];                              // speichert die Geschwindigkeit pro LED
int theDirection[NUMPIXELS];                          // speichert die Animationsrichtung (hell zu dunkel oder andersherum)

Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);  // erzeugt ein Neopixel-Objekt für den LED-Leuchtstreifen

void setup() {
  pixels.begin();                                     // initialisiere die Neopixel-LEDs (WS2812)
  randomSeed(analogRead(5));                          // started den Zufalls-Nummerngenerator
  for (int i = 0; i < NUMPIXELS; i++) {               // für alle LEDs
    theDirection[i] = 1;                              // setze die Dimm-Richtung auf 1 (von dunkel zu hell)
    theSpeed[i] = random(5);                          // erzeuge zufällige Geschwindigkeit für jede LED
  }
}

void loop() {
  for (int i = 0; i < NUMPIXELS; i++) {               // für jeden Pixel
    theValue[i] += theSpeed[i] * theDirection[i];     // kalkuliere den Lichtwert
    if (theValue[i] >= maxBrightness) {               // falls die maximale Helligkeit überschritten wird
      theValue[i] == maxBrightness;                   // setze die Helligkeit auf den Maximalwert
      theDirection[i] = -1;                           // setze die Dimm-Richtung auf -1 (von hell zu dunkel)
    } else if (theValue[i] <= 0) {                    // falls die minimale Helligkeit unterschritten wird
      theValue[i] == 0;                               // setze die Helligkeit auf 0
      theDirection[i] = 1;                            // setze die Dimm-Richtung auf 1 (von dunkel zu hell)
      theSpeed[i] = random(10);                       // erzeuge eine neue zufällige Geschwindigkeit
    }
    pixels.setPixelColor(i, pixels.Color(theValue[i], theValue[i], 0));   // weise den Lichtwert den LEDs im roten und grünen Kanal zu
  }
  pixels.show();                                      // übertrage die Daten an die LEDs 
  delay(animationSpeed);                              // warte in der Animationsgeschwindigkeit
}

Das zweite Programm lässt alle LEDs unterschiedlich schnell aufleuchten:

#include <Adafruit_NeoPixel.h>                        // Bibliothek für die Neopixel LEDs (WS2812)

#define PIN 3                                         // Pin, an dem die LEDs angeschlossen sind
#define NUMLIGHTS 6                                   // Anzahl maximal gleichzeitig leuchtender LEDs
#define NUMPIXELS 9                                   // Anzahl der LEDs des LED-Strips

int maxBrightness = 200;                              // maximale Helligkeit der LEDs
int animationSpeed = 40;                              // setzte die Animationsgeschwindigkeit (je höher, desto langsamer)

/* ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** */

int theValue[NUMPIXELS];                              // speichert den Leuchtwert
int theSpeed[NUMPIXELS];                              // speichert die Geschwindigkeit pro LED
int theDirection[NUMPIXELS];                          // speichert die Animationsrichtung (hell zu dunkel oder andersherum)
int theLights[NUMLIGHTS];
int thePixel[NUMLIGHTS];

Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);  // erzeugt ein Neopixel-Objekt für den LED-Leuchtstreifen

void setup() {
  pixels.begin();                                     // initialisiere die Neopixel-LEDs (WS2812)
  randomSeed(analogRead(5));                          // started den Zufalls-Nummerngenerator
  for (int i = 0; i < NUMLIGHTS; i++) {               // 
    theDirection[i] = 1;                              // setze die Dimm-Richtung auf 1 (von dunkel zu hell)
    theSpeed[i] = random(5);                          // erzeuge zufällige Geschwindigkeit für jede LED
    thePixel[i] = random(NUMPIXELS);                  // suche eine LED aus
  }
}

void loop() {
  for (int i = 0; i < NUMLIGHTS; i++) {
    theValue[i] += theSpeed[i] * theDirection[i];     // kalkuliere den Lichtwert
    if (theValue[i] >= maxBrightness) {               // falls die maximale Helligkeit überschritten wird
      theValue[i] == maxBrightness;                   // setze die Helligkeit auf den Maximalwert
      theDirection[i] = -1;                           // setze die Dimm-Richtung auf -1 (von hell zu dunkel)
    } else if (theValue[i] <= 0) {                    // falls die minimale Helligkeit unterschritten wird
      theValue[i] == 0;                               // setze die Helligkeit auf 0
      theDirection[i] = 1;                            // setze die Dimm-Richtung auf 1 (von dunkel zu hell)
      theSpeed[i] = random(10);                       // erzeuge eine neue zufällige Geschwindigkeit
      pixels.setPixelColor(thePixel[i], pixels.Color(0, 0, 0));
      pixels.show();  
      thePixel[i] = random(NUMPIXELS);
    }
    pixels.setPixelColor(thePixel[i], pixels.Color(theValue[i], theValue[i], 0));   // weise den Lichtwert den LEDs im roten und grünen Kanal zu
  }
  pixels.show();                                      // übertrage die Daten an die LEDs
  delay(animationSpeed);                              // warte in der Animationsgeschwindigkeit
}

Und zu guter Letzt noch eine Version, in der alle LEDs eine minimale Helligkeit beibehalten. Diese lässt sich über minBrightness einstellen.

#include <Adafruit_NeoPixel.h>                        // Bibliothek für die Neopixel LEDs (WS2812)

#define PIN 3                                         // Pin, an dem die LEDs angeschlossen sind
#define NUMLIGHTS 3                                   // Anzahl maximal gleichzeitig leuchtender LEDs
#define NUMPIXELS 9                                   // Anzahl der LEDs des LED-Strips

int maxBrightness = 200;                              // maximale Helligkeit der LEDs
int minBrightness = 20;                               // minimale Helligkeit der LEDs
int animationSpeed = 40;                              // setzte die Animationsgeschwindigkeit (je höher, desto langsamer)

/* ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** */

int theValue[NUMPIXELS];                              // speichert den Leuchtwert
int theSpeed[NUMPIXELS];                              // speichert die Geschwindigkeit pro LED
int theDirection[NUMPIXELS];                          // speichert die Animationsrichtung (hell zu dunkel oder andersherum)
int theLights[NUMLIGHTS];
int thePixel[NUMLIGHTS];

Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);  // erzeugt ein Neopixel-Objekt für den LED-Leuchtstreifen

void setup() {
  pixels.begin();                                     // initialisiere die Neopixel-LEDs (WS2812)
  randomSeed(analogRead(5));                          // started den Zufalls-Nummerngenerator
  for (int i = 0; i < NUMLIGHTS; i++) {               // 
    theDirection[i] = 1;                              // setze die Dimm-Richtung auf 1 (von dunkel zu hell)
    theSpeed[i] = random(5);                          // erzeuge zufällige Geschwindigkeit für jede LED
    thePixel[i] = random(NUMPIXELS);                  // suche eine LED aus
  }
}

void loop() {
  for (int i = 0; i < NUMLIGHTS; i++) {
    theValue[i] += theSpeed[i] * theDirection[i];     // kalkuliere den Lichtwert
    if (theValue[i] >= maxBrightness) {               // falls die maximale Helligkeit überschritten wird
      theValue[i] == maxBrightness;                   // setze die Helligkeit auf den Maximalwert
      theDirection[i] = -1;                           // setze die Dimm-Richtung auf -1 (von hell zu dunkel)
    } else if (theValue[i] <= minBrightness) {        // falls die minimale Helligkeit unterschritten wird
      theValue[i] == minBrightness;                   // setze die Helligkeit auf minBrightness
      theDirection[i] = 1;                            // setze die Dimm-Richtung auf 1 (von dunkel zu hell)
      theSpeed[i] = random(10);                       // erzeuge eine neue zufällige Geschwindigkeit
      pixels.setPixelColor(thePixel[i], pixels.Color(minBrightness, minBrightness, 0));
      pixels.show();  
      thePixel[i] = random(NUMPIXELS);
    }
    pixels.setPixelColor(thePixel[i], pixels.Color(theValue[i], theValue[i], 0));   // weise den Lichtwert den LEDs im roten und grünen Kanal zu
  }
  pixels.show();                                      // übertrage die Daten an die LEDs
  delay(animationSpeed);                              // warte in der Animationsgeschwindigkeit
}

Hiermit sollten sich wohl einige Zero Point Module bauen lassen :-)


Wenn dir das Projekt gefallen hat und du von weiteren interessanten Projekten inspiriert werden willst, sieh dir doch mal mein neues E-Book »Arduino Projekte Volume 1« an!

  • Die beliebtesten Arduino-Projekte von StartHardware
  • Inklusive Schaltplan, Beschreibung und Code
  • Arduino-Schnellstart-Kapitel
  • Kompakter Programmierkurs


Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

 

Diese Website verwendet Akismet, um Spam zu reduzieren. Erfahre mehr darüber, wie deine Kommentardaten verarbeitet werden.