WS2812B: den magiske RGB LED-stripen

Isaac

9 minutter

WS2812B RGB LED-stripe

Du må helt sikkert legge til et snev av farger i DIY-prosjektene dine. For dette bruker mange produsenter den berømte WS2812B RGB LED-striper, for å oppnå en variert fargekontroll og ganske attraktive lyseffekter for prosjektene dine. Selvfølgelig er de strimler som er fullt kompatible med Arduino-kort, så du vil ikke ha noe problem når du prøver å integrere dem.

Du kan finne dem i lengder på 1 meter, for eksempel, selv om de kan variere avhengig av type tetthet av lysdioder for hver meter de har. For eksempel er det fra 30 lysdioder til 144 lysdioder. Men hvis du trenger lengre lengder for å oppnå en større overflate, har du også andre alternativer på markedet, for eksempel RGB LED-paneler, eller du kan alltid bruke flere striper ...

Disse stripene er ikke mer enn en serie med monterte RGB-lysdioder og montert på en felles støtte for å gruppere dem i strimler. Men driften er identisk med de separate RGB-lysdiodene.

Hva er WS2812B?

RGB WS2812B belyst LED-stripe

Egentlig er WS2812B ikke selve stripen, men hver av dem cellene eller små RGB LED-plater som inkluderer. De kan grupperes i form av en stripe eller et panel, slik at du kan lage forskjellige konfigurasjoner når det gjelder antall og form. Stripene som utgjør er fleksible striper, men du kan også finne WS2812B på PCB-paneler som ikke er det.

Hvis du vil, kan du finne enhetene WS2812B separat å lage formene du trenger selv. For eksempel koster omtrent 100 enheter vanligvis litt mer enn € 10.

rgb ledet stripe skjæring

Du bør også vite at du kaster dem du kan klippe dem med en saks hvor du trenger, det betyr ikke at de slutter å jobbe. Så du kan bare ha de RGB-lysdiodene du trenger. Faktisk har den noen markeringer (tre kobberputer) som du kan skjære gjennom. Hvis du kutter gjennom disse putene, vil du ha tre spor på den ene siden av stripen og på den andre i tilfelle du vil bruke de andre delene på nytt, i dem kan du lodde pinnene for enkel tilkobling.

Pinout og datablad

WS2812B i en enkel celle

Det er en uavhengig WS2812B-celle med sine innganger og utganger

For mer informasjon om din RGB LED-stripe WS2812B Du kan lese databladet tilbys av hver produsent, der kan du konsultere alle detaljer om dimensjoner og tekniske egenskaper for å vite hvordan du bruker dem riktig, i tillegg til å kjenne til alle driftsområder og begrensninger.

Som til pinoutDet er heller ikke noe stort problem, disse stripene har en enkel forbindelse som du kan mestre fra begynnelsen uten for mye kunnskap. Det er bare tre tilgjengelige, selv om hver WS2812B-celle faktisk har flere tilkoblinger ...

Du må rett og slett koble på hver stripe Vcc-pinnen som mater stripen til 5V fra Arduino eller fra en annen strømforsyning, GND til jord, selvfølgelig, og til slutt DI som er den andre som vil gå til hvilken som helst utgang fra mikrokontrolleren for å aktivere RGB-lysdioder på stripen.

Hvis du ser på en WS2812B-celle Du vil se at den har Data In- eller DI-inngangen, og Vcc- og GND-strømforsyningen. Deretter vil den ha tre andre utganger, de vil bli koblet til neste celle på stripen, og neste celle vil ha sine utganger koblet til inngangen til den neste og så videre til hele stripen er ferdig ...

Det er nettopp det DI eller datainngang den som er interessant å konfigurere RGB-lysdiodene, og den samme vil være koblet til Data Out eller DO som tar den samme informasjonen til neste lenke i stripen. Og så sprer det seg over hele stripen.

Kjøp WS2812B RGB LED Strips

RGB LED stripe rull

Du kan kjøp til en ikke for høy pris i forskjellige spesialforretninger. Du har dem også i Amazon i forskjellige formater. Noen eksempler er:

Testing med Arduino og WS2812B

Arduino UNO med WS2812B-skjema

Som du kan forestille deg, med bare tre pinner er det veldig enkelt å gjøre det koble til arduino som du kan se i diagrammet over. Du må bare koble 5v og GND til WS2812B-stripen, og DI til en utgang du vil ha på Arduino. Husk at hvis du bytter pin, må du også endre kildekoden slik at programmet fungerer som det skal.

Biblioteket er brukt FAST-LED Master for å gjøre ting enklere og få enkle funksjoner for å kjøre RGB-lysdioder. For å laste den ned og integrere den ordentlig i Arduino IDE, laster du bare ned biblioteket fra den lenken, pakker deretter ut ZIP og omdøper den utpakkede katalogen eller mappen som FastLED, og ​​deretter flytter du mappen der Arduino IDE-bibliotekene er installert i installasjonen din. . Åpne deretter Arduino IDE igjen, og den vil være klar ...

Som til skisse kode, det kan være ganske enkelt som følgende kode. Hvis du ikke vil kopiere og lime inn, kan du finne det blant eksemplene som allerede kommer. Så gå til Fil> Eksempler> FastLED> ColorPalette.

Husk å bytte pinne 14 fra eksemplet til 5 som er den jeg brukte i diagrammet. Eller du kan koble til pinne 14 og unngå å endre koden. Som du foretrekker. 
#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.

Bli den første til å kommentere

Legg igjen kommentaren

Din e-postadresse vil ikke bli publisert. Obligatoriske felt er merket med *

*

*

  1. Ansvarlig for dataene: Miguel Ángel Gatón
  2. Formålet med dataene: Kontroller SPAM, kommentaradministrasjon.
  3. Legitimering: Ditt samtykke
  4. Kommunikasjon av dataene: Dataene vil ikke bli kommunisert til tredjeparter bortsett fra ved juridisk forpliktelse.
  5. Datalagring: Database vert for Occentus Networks (EU)
  6. Rettigheter: Når som helst kan du begrense, gjenopprette og slette informasjonen din.