WS2812B: den magiske RGB LED-strip

Isaac

9 minutter

WS2812B RGB LED-strip

Du skal helt sikkert tilføje et strejf af farve til dine DIY-projekter. Til dette bruger mange producenter den berømte WS2812B RGB LED-strimler, som du kan opnå en varieret farvekontrol og ret attraktive lyseffekter til dine projekter. Selvfølgelig er de strimler, der er fuldt kompatible med Arduino-kort, så du har ikke noget problem, når du prøver at integrere dem.

Du kan finde dem i længder på 1 meterfor eksempel, selv om de kan variere afhængigt af typen af ​​lysdioder for densitet for hver meter, de har. For eksempel er der fra 30 lysdioder til 144 lysdioder. Men hvis du har brug for længere længder for at opnå en større overflade, har du også andre muligheder på markedet, såsom RGB LED-paneler, eller du kan altid bruge flere strimler ...

Disse strimler er intet mere end en række samlede RGB-LED'er og monteret på en fælles støtte for at gruppere dem i strimler. Men dens funktion er identisk med de separate RGB-lysdioder.

Hvad er WS2812B?

RGB WS2812B oplyst LED-strip

Faktisk er WS2812B ikke selve stripen, men hver af dem cellerne eller små RGB LED-plader, der inkluderer. De kan grupperes i form af en strimmel eller et panel, så du kan foretage forskellige konfigurationer med hensyn til antal og form. De strimler, der udgør, er fleksible strimler, men du kan også finde WS2812B på PCB-paneler, der ikke er det.

Hvis du vil, kan du finde enhederne WS2812B separat at skabe de figurer, du har brug for selv. F.eks. Koster ca. 100 enheder normalt lidt mere end € 10.

rgb led strimmelskæring

Du skal også vide, at du smider dem du kan klippe dem med en saks, hvor end du har brug for, betyder det ikke, at de holder op med at arbejde. Så du kan kun have de RGB-LED'er, du har brug for. Faktisk har den nogle markeringer (tre kobberpuder), som du kan skære igennem. Hvis du skærer igennem disse puder, har du tre spor på den ene side af strimlen og på den anden, hvis du vil genbruge de andre stykker, i dem kan du lodde stifterne for nem tilslutning.

Pinout og datablad

WS2812B i en simpel celle

Det er en uafhængig WS2812B-celle med dens ind- og udgange

For mere information om din RGB LED-strip WS2812B Du kan læse databladet der tilbydes af hver producent, der kan du konsultere alle detaljer om dimensioner og tekniske egenskaber for at vide, hvordan du bruger dem korrekt, ud over at kende alle driftsområder og begrænsninger.

Med hensyn til pinoutDet er heller ikke et stort problem, disse strimler har en simpel forbindelse, som du kan mestre fra starten uden for meget viden. Der er kun tre tilgængelige, selvom hver WS2812B-celle faktisk har flere forbindelser ...

Du skal simpelthen forbinde på hver strimmel Vcc-stift, der føder strimlen til 5V fra Arduino eller fra en anden strømforsyning, GND til jord, selvfølgelig, og til sidst DI, som er den anden, der går til enhver udgang fra mikrocontrolleren for at aktivere RGB-lysdioder på strimlen.

Hvis du ser på en WS2812B-celle Du vil se, at den har Data In- eller DI-indgangen og Vcc- og GND-strømforsyningen. Derefter vil den have tre andre udgange, de vil være forbundet til den næste celle på strimlen, og den næste celle vil have sine udgange tilsluttet indgangen til den næste og så videre, indtil hele strimlen er afsluttet ...

Det er netop det DI eller dataindgang den der er interessant at konfigurere RGB-lysdioderne, og den samme forbindes til Data Out eller DO, der fører de samme oplysninger til det næste link på stripen. Og så spreder det sig over hele stripen.

Køb WS2812B RGB LED Strips

RGB LED-striprulle

Du kan køb til en ikke for høj pris i forskellige specialbutikker. Du har dem også i Amazon i forskellige formater. Nogle eksempler er:

Test med Arduino og WS2812B

Arduino UNO med WS2812B-skema

Som du kan forestille dig, er det med kun tre ben meget let at Opret forbindelse til Arduino som du kan se i diagrammet ovenfor. Du skal bare forbinde 5v og GND til WS2812B-striben og DI til en udgang, du vil have på Arduino. Husk, at hvis du skifter pin, skal du også ændre kildekoden, så programmet fungerer korrekt.

Biblioteket er blevet brugt FAST-LED Master for at gøre tingene nemmere og få enkle funktioner til at drive RGB-lysdioder. For at downloade det og integrere det ordentligt i Arduino IDE skal du bare downloade biblioteket fra det link, derefter pakke ZIP'en ud og omdøbe den udpakkede mappe eller mappe til FastLED og derefter flytte den mappe, hvor Arduino IDE-bibliotekerne er installeret i din installation . Åbn derefter Arduino IDE igen, og den er klar ...

Med hensyn til skitsekode, det kan være ret simpelt som følgende kode. Hvis du ikke vil kopiere og indsætte, kan du finde det blandt de eksempler, der allerede kommer. Så gå til Filer> Eksempler> FastLED> ColorPalette.

Husk at skifte pin 14 fra eksemplet til 5, som er den, jeg brugte i diagrammet. Eller du kan oprette forbindelse til pin 14 og undgå at ændre koden. Som du foretrækker. 
#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.

Vær den første til at kommentere

Efterlad din kommentar

Din e-mailadresse vil ikke blive offentliggjort. Obligatoriske felter er markeret med *

*

*

  1. Ansvarlig for dataene: Miguel Ángel Gatón
  2. Formålet med dataene: Control SPAM, management af kommentarer.
  3. Legitimering: Dit samtykke
  4. Kommunikation af dataene: Dataene vil ikke blive kommunikeret til tredjemand, undtagen ved juridisk forpligtelse.
  5. Datalagring: Database hostet af Occentus Networks (EU)
  6. Rettigheder: Du kan til enhver tid begrænse, gendanne og slette dine oplysninger.