WS2812B: la màgica tira de LEDs RGB

Segurament necessitis donar-li un toc de color als teus projectes DIY. Per a això, molts makers fan servir les famoses tires LED RGB WS2812B, Amb les que aconseguir un control de la color variat i efectes lluminosos força atractius per als teus projectes. Per descomptat són tires totalment compatibles amb les placa Arduino, per la qual cosa no tindràs cap problema a l'intentar integrar-les.

Les pots trobar a longituds d'1 metre, Per exemple, encara que poden variar en funció de l'tipus de densitat de LEDs per cada metre que tenen. Per exemple, n'hi ha des dels 30 LEDs als 144 LEDs. No obstant això, si necessites longituds majors per obtenir una superfície més gran, també tens altres opcions en el mercat com panells RGB de LEDs o sempre pots usar diverses tires ...

Aquestes tires no són més que una sèrie de LEDs RGB acoblats i muntats sobre un suport comú per agrupar-los en tires. Però el seu funcionament és idèntic als LEDs RGB per separat.

Més informació sobre LEDs RGB

Què és WS2812B?

Realment el WS2812B no és la tira en si, sinó cadascuna de les cèl·lules o petites plaques LED RGB que inclouen. Es poden agrupar en forma de tira o de panell, de manera que pots fer diverses configuracions quant al seu nombre i forma. Les tires que conformen són unes tires flexibles, però també pots trobar WS2812B en panells PCB que no ho són.

Si vols, pots trobar els dispositius WS2812B per separat per crear tu mateix les formes que necessitis. Per exemple, unes 100 unitats d'elles sol tenir un cost una mica superior als 10 €.

També has de saber que les tires les pots tallar amb unes tisores per on necessitis, això no implica que deixin de funcionar. Així podràs tenir només els LEDs RGB que necessitis. De fet, té unes marques (tres pads de coure) pels quals pots tallar. Si curtes per mitjà d'aquests pads et quedaran tres pistes a banda i banda de la tira per si vols reutilitzar els altres trossos, en ells pots soldar els pins per a la seva connexió fàcil.

Pinout i datasheet

És una cèl·lula independent WS2812B amb les seves entrades i sortides

Per a més informació sobre la teva tira LED RGB WS2812B pots llegir el datasheet que ofereix cada fabricant, allà podràs consultar tots els detalls de dimensions i característiques tècniques per saber com usar-les de forma adequada, a més de conèixer tots els rangs de funcionament i límits.

Descarregar datasheet de l'WS2812B

Quant al pinout, Tampoc és problema més gran, aquestes tires disposen d'una connexió senzilla que podràs dominar des del principi sense massa coneixements. Només disposa de tres disponibles, tot i que cada cèl·lula WS2812B té en realitat més connexions ...

simplement hauràs Connectar en cada tira el pin Vcc que alimenta la tira als 5V d'Arduino o d'una font d'alimentació diferent, el GND a terra, per descomptat, i finalment el DI que és l'altre que anirà a qualsevol sortida de l'microcontrolador per activar els LEDs RGB de la tira.

Si et fixes en una cèl·lula WS2812B veuràs que té les entrades Data In o DI d'entrada, i les de Vcc i GND d'alimentació. Després tindrà tres de sortida, aquestes aniran connectades a la següent cèl·lula de la tira, i la següent cèl·lula tindrà les seves sortides connectades a l'entrada de la següent i així successivament fins a completar tota la tira ...

És precisament aquesta entrada DI o de dades la qual és interessant per configurar els LEDs RGB, i aquesta mateixa estarà connectada a Data Out o DO que portarà aquesta mateixa informació a la següent baula de la tira. I així es va propagant per tota la tira.

Comprar tires LED RGB WS2812B

les pots comprar a un preu no massa elevat en diverses botigues especialitzades. També en Amazon les tens en diferents formats. Alguns exemples són:

Proves amb Arduino i WS2812B

Com pots imaginar, amb només tres pins és molt fàcil d' connectar a Arduino com pots veure en l'esquema superior. Tan sols has de connectar 5v i GND a la tira WS2812B, i el DI a una sortida que vulguis en Arduino. Recorda que si canvies de pin hauràs modificar també el codi font perquè el programa funcioni adequadament.

S'ha fet servir la biblioteca FAST-LED Màster per facilitar les coses i obtenir funcions simples per gestionar els LEDs RGB. Per descarregar-la i integrar-la adequadament en el Arduino IDE, només descarrega la biblioteca des d'aquest enllaç, després descomprimeix el ZIP i reanomena el directori o carpeta descomprimit com FastLED, i després mou aquesta carpeta a on estiguin instal·lades les biblioteques de Arduino IDE a la teva instal·lació. Després torna a obrir Arduino IDE i estarà a punt ...

Quant al codi de l'esquetx, Pot ser bastant simple com el següent codi. Si no vols copiar i enganxar, pots trobar-lo entre els exemples que vénen ja. Per això, veu a Arxiu> Exemples> FastLED> ColorPalette.

Recorda canviar el pin 14 de l'exemple pel 5 que és el que he fet servir en l'esquema. O pots connectar a el pin 14 i evites modificar el codi. Com prefereixis.

#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.

Hardwarelibre

WS2812B: la màgica tira de LEDs RGB

Què és WS2812B?

Pinout i datasheet

Comprar tires LED RGB WS2812B

Proves amb Arduino i WS2812B

Deixa el teu comentari Cancel lar la resposta