WS2812B: a tira LED RGB mágica

Certamente você precisa adicionar um toque de cor aos seus projetos DIY. Para isso, muitos fabricantes usam o famoso Tiras LED WS2812B RGB, com o qual se consegue um controle de cores variado e efeitos de iluminação bastante atrativos para seus projetos. Claro que são tiras totalmente compatíveis com as placas Arduino, então você não terá nenhum problema ao tentar integrá-las.

Você pode encontrá-los em comprimentos de 1 metro, por exemplo, embora possam variar dependendo do tipo de densidade dos LEDs para cada medidor que eles possuem. Por exemplo, existem de 30 LEDs a 144 LEDs. Porém, se você precisa de comprimentos maiores para obter uma superfície maior, você também tem outras opções no mercado como painéis de LED RGB ou você sempre pode usar várias tiras ...

Essas tiras nada mais são do que uma série de LEDs RGB montados e montado em um suporte comum para agrupá-los em tiras. Mas seu funcionamento é idêntico ao dos LEDs RGB separados.

Mais informações sobre LEDs RGB

O que é WS2812B?

Na verdade o WS2812B não é a tira em si, mas cada um dos as células ou pequenas placas de LED RGB que incluem. Eles podem ser agrupados na forma de uma faixa ou painel, para que você possa fazer várias configurações em termos de número e forma. As tiras que compõem são tiras flexíveis, mas você também pode encontrar WS2812B em painéis de PCB que não são.

Se quiser, você pode encontrar os dispositivos WS2812B separadamente para criar as formas de que você mesmo precisa. Por exemplo, cerca de 100 unidades geralmente custam um pouco mais de € 10.

Você também deve saber que você os joga você pode cortá-los com uma tesoura sempre que precisar, isso não significa que parem de funcionar. Portanto, você pode ter apenas os LEDs RGB de que precisa. Na verdade, ele tem algumas marcas (três almofadas de cobre) que você pode cortar. Se você cortar essas almofadas, terá três trilhas de um lado da tira e do outro, caso queira reutilizar as outras peças, você pode soldar os pinos a elas para facilitar a conexão.

Pinagem e folha de dados

É uma célula WS2812B independente com suas entradas e saídas

Para obter mais informações sobre o seu Fita LED RGB WS2812B Você pode ler a folha de dados oferecidos por cada fabricante, ali você poderá consultar todos os detalhes de dimensões e características técnicas para saber como utilizá-los corretamente, além de conhecer todas as faixas e limites de operação.

Baixar folha de dados do WS2812B

Quanto a pinagemTambém não é um grande problema, essas tiras têm uma conexão simples que você pode dominar desde o início sem muito conhecimento. Existem apenas três disponíveis, embora cada célula WS2812B realmente tenha mais conexões ...

Você simplesmente deve ligar em cada tira o pino Vcc que alimenta a tira para os 5V do Arduino ou de uma fonte de alimentação diferente, o GND para o aterramento, é claro, e finalmente o DI que é o outro que vai para qualquer saída do microcontrolador para ativar o LEDs RGB na faixa.

Se você olhar para uma célula WS2812B Você verá que ele tem a entrada Data In ou DI e a fonte de alimentação Vcc e GND. Em seguida, terá outras três saídas, essas serão conectadas à próxima célula da tira, e a próxima célula terá suas saídas conectadas à entrada da próxima e assim sucessivamente até que toda a tira seja completada ...

É precisamente isso DI ou entrada de dados aquele que é interessante configurar os LEDs RGB, e esse mesmo será conectado a Data Out ou DO que levará essa mesma informação para o próximo link da tira. E assim se espalha pela faixa.

Compre fitas LED WS2812B RGB

Você pode compre por um preço não muito alto em várias lojas especializadas. Você também os tem na Amazon em diferentes formatos. Alguns exemplos são:

Testando com Arduino e WS2812B

Como você pode imaginar, com apenas três pinos é muito fácil conectar ao arduino como você pode ver no diagrama acima. Você só precisa conectar 5v e GND à faixa WS2812B e o DI a uma saída desejada no Arduino. Lembre-se de que se você alterar o pino, também deverá modificar o código-fonte para que o programa funcione corretamente.

A biblioteca foi usada Mestre FAST-LED para tornar as coisas mais fáceis e obter funções simples para acionar LEDs RGB. Para fazer o download e integrá-lo adequadamente ao IDE do Arduino, basta baixar a biblioteca desse link, descompactar o ZIP e renomear o diretório ou pasta descompactado como FastLED e mover essa pasta para onde as bibliotecas do IDE do Arduino estão instaladas em sua instalação . Em seguida, reabra o IDE do Arduino e ele estará pronto ...

Quanto a código de esboço, pode ser bastante simples como o código a seguir. Se você não deseja copiar e colar, pode encontrá-lo entre os exemplos que já vêm. Então vá para Arquivo> Exemplos> FastLED> ColorPalette.

Lembre-se de mudar o pino 14 do exemplo para 5, que é o que usei no diagrama. Ou você pode conectar ao pino 14 e evitar modificar o código. Como preferir.

#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: a faixa de LED RGB mágica

O que é WS2812B?

Pinagem e folha de dados

Compre fitas LED WS2812B RGB

Testando com Arduino e WS2812B

Deixe um comentário Cancelar resposta