WS2812B: der magische RGB-LED-Streifen

WS2812B RGB LED-Streifen

Sicherlich müssen Sie Ihren DIY-Projekten einen Hauch von Farbe verleihen. Dafür verwenden viele Hersteller das berühmte WS2812B RGB-LED-Streifen, mit denen Sie eine abwechslungsreiche Farbsteuerung und attraktive Lichteffekte für Ihre Projekte erzielen. Natürlich sind sie Streifen, die vollständig mit den Arduino-Boards kompatibel sind, sodass Sie keine Probleme haben, wenn Sie versuchen, sie zu integrieren.

Du findest sie in Längen von 1 MeterZum Beispiel, obwohl sie abhängig von der Art der Dichte der LEDs für jeden Meter, den sie haben, variieren können. Zum Beispiel gibt es 30 LEDs bis 144 LEDs. Wenn Sie jedoch längere Längen benötigen, um eine größere Oberfläche zu erhalten, haben Sie auch andere Optionen auf dem Markt, z. B. RGB-LED-Panels, oder Sie können immer mehrere Streifen verwenden ...

Diese Streifen sind nichts weiter als eine Reihe von zusammengebauten RGB-LEDs und auf einer gemeinsamen Stütze montiert, um sie in Streifen zu gruppieren. Der Betrieb ist jedoch identisch mit den separaten RGB-LEDs.

Was ist WS2812B?

RGB WS2812B beleuchteter LED-Streifen

Eigentlich ist der WS2812B nicht der Streifen selbst, sondern jeder von die Zellen oder kleine RGB-LED-Platten, die enthalten. Sie können in Form eines Streifens oder einer Platte gruppiert werden, sodass Sie verschiedene Konfigurationen hinsichtlich ihrer Anzahl und Form vornehmen können. Die Streifen, aus denen sich zusammensetzt, sind flexible Streifen, aber Sie können WS2812B auch auf Leiterplatten finden, die dies nicht sind.

Wenn Sie möchten, können Sie die Geräte finden WS2812B separat um die Formen zu erstellen, die Sie selbst benötigen. Zum Beispiel kosten etwa 100 Einheiten in der Regel etwas mehr als 10 Euro.

RGB LED-Streifenschneiden

Sie sollten auch wissen, dass Sie sie werfen Sie können sie schneiden Mit einer Schere, wo immer Sie sie brauchen, bedeutet dies nicht, dass sie nicht mehr funktioniert. Sie können also nur die RGB-LEDs verwenden, die Sie benötigen. In der Tat hat es einige Markierungen (drei Kupferkissen), die Sie durchschneiden können. Wenn Sie diese Pads durchschneiden, haben Sie drei Spuren auf einer Seite des Streifens und auf der anderen Seite, falls Sie die anderen Teile wiederverwenden möchten. In diesen können Sie die Pins für eine einfache Verbindung löten.

Pinbelegung und Datenblatt

WS2812B in einer einfachen Zelle

Es ist eine unabhängige WS2812B-Zelle mit ihren Ein- und Ausgängen

Weitere Informationen zu Ihrem RGB-LED-Streifen WS2812B Du kannst lesen das Datenblatt Dort können Sie alle Details zu Abmessungen und technischen Merkmalen einsehen, um zu erfahren, wie diese ordnungsgemäß verwendet werden. Außerdem müssen Sie alle Betriebsbereiche und Grenzwerte kennen.

Um PinoutEs ist auch kein großes Problem, diese Streifen haben eine einfache Verbindung, die Sie von Anfang an ohne zu viel Wissen beherrschen können. Es sind nur drei verfügbar, obwohl jede WS2812B-Zelle tatsächlich mehr Verbindungen hat ...

Du musst einfach conect Auf jedem Streifen befindet sich der Vcc-Pin, der den Streifen von Arduino oder einem anderen Netzteil auf die 5 V speist, der GND natürlich auf Masse und schließlich der DI, der der andere ist, der an einen beliebigen Ausgang des Mikrocontrollers geht, um den zu aktivieren RGB-LEDs auf dem Streifen.

Wenn du siehst eine WS2812B-Zelle Sie werden sehen, dass es den Data In- oder DI-Eingang sowie die Vcc- und GND-Stromversorgung hat. Dann hat es drei weitere Ausgänge, diese werden mit der nächsten Zelle des Streifens verbunden, und die Ausgänge der nächsten Zelle werden mit dem Eingang des nächsten verbunden und so weiter, bis der gesamte Streifen fertig ist ...

Genau das ist es DI oder Dateneingabe Diejenige, die für die Konfiguration der RGB-LEDs interessant ist, und dieselbe wird mit Data Out oder DO verbunden, die dieselben Informationen zum nächsten Link im Streifen weiterleiten. Und so breitet es sich über den Streifen aus.

Kaufen Sie WS2812B RGB LED Strips

RGB LED Streifenrolle

Sie können zu einem nicht zu hohen Preis kaufen in verschiedenen Fachgeschäften. Sie haben sie auch in Amazon in verschiedenen Formaten. Einige Beispiele sind:

Testen mit Arduino und WS2812B

Arduino UNO mit WS2812B-Schema

Wie Sie sich vorstellen können, ist es mit nur drei Stiften sehr einfach verbinde dich mit arduino wie Sie in der Abbildung oben sehen können. Sie müssen nur 5 V und GND an den WS2812B-Streifen und den DI an einen gewünschten Ausgang auf Arduino anschließen. Denken Sie daran, dass Sie beim Ändern Ihrer PIN auch den Quellcode ändern müssen, damit das Programm ordnungsgemäß funktioniert.

Die Bibliothek wurde verwendet FAST-LED-Master um die Sache zu vereinfachen und einfache Funktionen zum Ansteuern von RGB-LEDs zu erhalten. Um es herunterzuladen und ordnungsgemäß in die Arduino IDE zu integrieren, laden Sie einfach die Bibliothek von diesem Link herunter, entpacken Sie die ZIP-Datei, benennen Sie das entpackte Verzeichnis oder den entpackten Ordner in FastLED um und verschieben Sie diesen Ordner an den Ort, an dem die Arduino IDE-Bibliotheken in Ihrer Installation installiert sind . Öffnen Sie dann die Arduino IDE erneut und sie ist fertig ...

Um Skizzencodekann es ganz einfach sein wie der folgende Code. Wenn Sie nicht kopieren und einfügen möchten, finden Sie es unter den bereits vorhandenen Beispielen. Gehen Sie also zu Datei> Beispiele> FastLED> ColorPalette.

Denken Sie daran, Pin 14 vom Beispiel auf 5 zu ändern, den ich im Diagramm verwendet habe. Oder Sie können eine Verbindung zu Pin 14 herstellen und vermeiden, den Code zu ändern. Wie Sie es vorziehen.
#include <FastLED.h>

#define LED_PIN     5
#define NUM_LEDS    14
#define BRIGHTNESS  64
#define LED_TYPE    WS2811
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

#define UPDATES_PER_SECOND 100

// This example shows several ways to set up and use 'palettes' of colors
// with FastLED.
//
// These compact palettes provide an easy way to re-colorize your
// animation on the fly, quickly, easily, and with low overhead.
//
// USING palettes is MUCH simpler in practice than in theory, so first just
// run this sketch, and watch the pretty lights as you then read through
// the code.  Although this sketch has eight (or more) different color schemes,
// the entire sketch compiles down to about 6.5K on AVR.
//
// FastLED provides a few pre-configured color palettes, and makes it
// extremely easy to make up your own color schemes with palettes.
//
// Some notes on the more abstract 'theory and practice' of
// FastLED compact palettes are at the bottom of this file.



CRGBPalette16 currentPalette;
TBlendType    currentBlending;

extern CRGBPalette16 myRedWhiteBluePalette;
extern const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM;


void setup() {
    delay( 3000 ); // power-up safety delay
    FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
    FastLED.setBrightness(  BRIGHTNESS );
    
    currentPalette = RainbowColors_p;
    currentBlending = LINEARBLEND;
}


void loop()
{
    ChangePalettePeriodically();
    
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* motion speed */
    
    FillLEDsFromPaletteColors( startIndex);
    
    FastLED.show();
    FastLED.delay(1000 / UPDATES_PER_SECOND);
}

void FillLEDsFromPaletteColors( uint8_t colorIndex)
{
    uint8_t brightness = 255;
    
    for( int i = 0; i < NUM_LEDS; i++) {
        leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, currentBlending);
        colorIndex += 3;
    }
}


// There are several different palettes of colors demonstrated here.
//
// FastLED provides several 'preset' palettes: RainbowColors_p, RainbowStripeColors_p,
// OceanColors_p, CloudColors_p, LavaColors_p, ForestColors_p, and PartyColors_p.
//
// Additionally, you can manually define your own color palettes, or you can write
// code that creates color palettes on the fly.  All are shown here.

void ChangePalettePeriodically()
{
    uint8_t secondHand = (millis() / 1000) % 60;
    static uint8_t lastSecond = 99;
    
    if( lastSecond != secondHand) {
        lastSecond = secondHand;
        if( secondHand ==  0)  { currentPalette = RainbowColors_p;         currentBlending = LINEARBLEND; }
        if( secondHand == 10)  { currentPalette = RainbowStripeColors_p;   currentBlending = NOBLEND;  }
        if( secondHand == 15)  { currentPalette = RainbowStripeColors_p;   currentBlending = LINEARBLEND; }
        if( secondHand == 20)  { SetupPurpleAndGreenPalette();             currentBlending = LINEARBLEND; }
        if( secondHand == 25)  { SetupTotallyRandomPalette();              currentBlending = LINEARBLEND; }
        if( secondHand == 30)  { SetupBlackAndWhiteStripedPalette();       currentBlending = NOBLEND; }
        if( secondHand == 35)  { SetupBlackAndWhiteStripedPalette();       currentBlending = LINEARBLEND; }
        if( secondHand == 40)  { currentPalette = CloudColors_p;           currentBlending = LINEARBLEND; }
        if( secondHand == 45)  { currentPalette = PartyColors_p;           currentBlending = LINEARBLEND; }
        if( secondHand == 50)  { currentPalette = myRedWhiteBluePalette_p; currentBlending = NOBLEND;  }
        if( secondHand == 55)  { currentPalette = myRedWhiteBluePalette_p; currentBlending = LINEARBLEND; }
    }
}

// This function fills the palette with totally random colors.
void SetupTotallyRandomPalette()
{
    for( int i = 0; i < 16; i++) {
        currentPalette[i] = CHSV( random8(), 255, random8());
    }
}

// This function sets up a palette of black and white stripes,
// using code.  Since the palette is effectively an array of
// sixteen CRGB colors, the various fill_* functions can be used
// to set them up.
void SetupBlackAndWhiteStripedPalette()
{
    // 'black out' all 16 palette entries...
    fill_solid( currentPalette, 16, CRGB::Black);
    // and set every fourth one to white.
    currentPalette[0] = CRGB::White;
    currentPalette[4] = CRGB::White;
    currentPalette[8] = CRGB::White;
    currentPalette[12] = CRGB::White;
    
}

// This function sets up a palette of purple and green stripes.
void SetupPurpleAndGreenPalette()
{
    CRGB purple = CHSV( HUE_PURPLE, 255, 255);
    CRGB green  = CHSV( HUE_GREEN, 255, 255);
    CRGB black  = CRGB::Black;
    
    currentPalette = CRGBPalette16(
                                   green,  green,  black,  black,
                                   purple, purple, black,  black,
                                   green,  green,  black,  black,
                                   purple, purple, black,  black );
}


// This example shows how to set up a static color palette
// which is stored in PROGMEM (flash), which is almost always more
// plentiful than RAM.  A static PROGMEM palette like this
// takes up 64 bytes of flash.
const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM =
{
    CRGB::Red,
    CRGB::Gray, // 'white' is too bright compared to red and blue
    CRGB::Blue,
    CRGB::Black,
    
    CRGB::Red,
    CRGB::Gray,
    CRGB::Blue,
    CRGB::Black,
    
    CRGB::Red,
    CRGB::Red,
    CRGB::Gray,
    CRGB::Gray,
    CRGB::Blue,
    CRGB::Blue,
    CRGB::Black,
    CRGB::Black
};



// Additionl notes on FastLED compact palettes:
//
// Normally, in computer graphics, the palette (or "color lookup table")
// has 256 entries, each containing a specific 24-bit RGB color.  You can then
// index into the color palette using a simple 8-bit (one byte) value.
// A 256-entry color palette takes up 768 bytes of RAM, which on Arduino
// is quite possibly "too many" bytes.
//
// FastLED does offer traditional 256-element palettes, for setups that
// can afford the 768-byte cost in RAM.
//
// However, FastLED also offers a compact alternative.  FastLED offers
// palettes that store 16 distinct entries, but can be accessed AS IF
// they actually have 256 entries; this is accomplished by interpolating
// between the 16 explicit entries to create fifteen intermediate palette
// entries between each pair.
//
// So for example, if you set the first two explicit entries of a compact 
// palette to Green (0,255,0) and Blue (0,0,255), and then retrieved 
// the first sixteen entries from the virtual palette (of 256), you'd get
// Green, followed by a smooth gradient from green-to-blue, and then Blue.



Schreiben Sie den ersten Kommentar

Hinterlasse einen Kommentar

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

*

*

  1. Verantwortlich für die Daten: Miguel Ángel Gatón
  2. Zweck der Daten: Kontrolle von SPAM, Kommentarverwaltung.
  3. Legitimation: Ihre Zustimmung
  4. Übermittlung der Daten: Die Daten werden nur durch gesetzliche Verpflichtung an Dritte weitergegeben.
  5. Datenspeicherung: Von Occentus Networks (EU) gehostete Datenbank
  6. Rechte: Sie können Ihre Informationen jederzeit einschränken, wiederherstellen und löschen.