Zum Inhalt springen
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.

    Jmx0O2RpdiBjbGFzcz0mcXVvdDtudi1pZnJhbWUtZW1iZWQmcXVvdDsmZ3Q7Jmx0O2lmcmFtZSB0aXRsZT0mcXVvdDtaZXJvIFBvaW50IE1vZHVsZSAoWlBNKSBmcm9tIHRoZSBTdGFyZ2F0ZSBVbml2ZXJzZSZxdW90OyB3aWR0aD0mcXVvdDsxMjAwJnF1b3Q7IGhlaWdodD0mcXVvdDs2NzUmcXVvdDsgc3JjPSZxdW90O2h0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkLzh1Mmk3Sl9adjZzP2ZlYXR1cmU9b2VtYmVkJnF1b3Q7IGZyYW1lYm9yZGVyPSZxdW90OzAmcXVvdDsgYWxsb3c9JnF1b3Q7YWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGNsaXBib2FyZC13cml0ZTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZSZxdW90OyBhbGxvd2Z1bGxzY3JlZW4mZ3Q7Jmx0Oy9pZnJhbWUmZ3Q7Jmx0Oy9kaXYmZ3Q7

    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.


    Sieh dir jetzt meinen neuen Arduino-Videokurs an: Jetzt ansehen!


    #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


    3 Gedanken zu „Zero Point Module – mit Arduino und WS2812“

    1. Super Idee, bin Cosplayer Stargate hab 1 Stargate gebaut. Aber kapier nicht wie man schleifen macht. Hab in der VHS ein Anfänger Kurs gemacht. Das hat mir ein bisschen geholfen die Sketche zu machen. Aber ich arbeite ja mit neopixel Sketchen und weil ich es nicht kapiere mit schleifen muss ich 54 Zeilen oder mehr schreiben um jede einzelne Led programmierten. Kannste du mir weiter helfen? Schöne Grüße
      Peter

    Schreibe einen Kommentar

    Deine E-Mail-Adresse wird nicht veröffentlicht.

     

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