WS2812B: banda magică LED RGB

Cu siguranță, trebuie să adăugați o notă de culoare proiectelor dvs. DIY. Pentru aceasta, mulți producători folosesc faimosul Benzi LED WS2812B RGB, cu care să obțineți un control variat al culorilor și efecte de iluminare destul de atractive pentru proiectele dvs. Desigur, sunt benzi pe deplin compatibile cu plăcile Arduino, deci nu veți avea nicio problemă atunci când încercați să le integrați.

Le puteți găsi în lungimi de 1 metru, de exemplu, deși pot varia în funcție de tipul de densitate al LED-urilor pentru fiecare contor pe care îl au. De exemplu, există de la 30 de LED-uri la 144 de LED-uri. Cu toate acestea, dacă aveți nevoie de lungimi mai mari pentru a obține o suprafață mai mare, aveți și alte opțiuni pe piață, cum ar fi panourile LED RGB sau puteți folosi oricând mai multe benzi ...

Aceste benzi nu sunt altceva decât o serie de LED-uri RGB asamblate și montat pe un suport comun pentru a le grupa în benzi. Dar funcționarea sa este identică cu LED-urile RGB separate.

Mai multe informații despre LED-urile RGB

Ce este WS2812B?

De fapt, WS2812B nu este banda în sine, ci fiecare dintre celulele sau mici plăci LED RGB care includ. Ele pot fi grupate sub forma unei benzi sau a unui panou, astfel încât să puteți face diverse configurații în ceea ce privește numărul și forma lor. Benzile care alcătuiesc sunt benzi flexibile, dar puteți găsi și WS2812B pe panourile PCB care nu sunt.

Dacă doriți, puteți găsi dispozitivele WS2812B separat pentru a crea tu insuti formele de care ai nevoie. De exemplu, aproximativ 100 de unități dintre ele costă de obicei puțin mai mult de 10 EUR.

De asemenea, ar trebui să știți că le aruncați le poți tăia cu o foarfeca oriunde ai nevoie, asta nu înseamnă că nu mai funcționează. Deci, puteți avea doar LED-urile RGB de care aveți nevoie. De fapt, are câteva marcaje (trei tampoane de cupru) pe care le puteți tăia. Dacă tăiați aceste plăcuțe, veți avea trei piste pe o parte a benzii și pe cealaltă în cazul în care doriți să refolosiți celelalte piese, în ele puteți lipi pinii pentru o conexiune ușoară.

Pinout și foaie de date

Este o celulă WS2812B independentă, cu intrările și ieșirile sale

Pentru mai multe informații despre Banda LED RGB WS2812B Poți citi fisa tehnica oferit de fiecare producător, acolo puteți consulta toate detaliile dimensiunilor și caracteristicilor tehnice pentru a ști cum să le utilizați corect, pe lângă cunoașterea tuturor domeniilor și limitelor de funcționare.

Descărcați foaia de date WS2812B

Ca pin outNici nu este o problemă majoră, aceste benzi au o conexiune simplă pe care o poți stăpâni de la început fără prea multe cunoștințe. Există doar trei disponibile, deși fiecare celulă WS2812B are de fapt mai multe conexiuni ...

Pur și simplu trebuie lega pe fiecare bandă pinul Vcc care alimentează banda către 5V de la Arduino sau de la o sursă de alimentare diferită, GND la masă, desigur, și în cele din urmă DI, care este celălalt care va merge la orice ieșire a microcontrolerului pentru a activa LED-uri RGB pe bandă.

Dacă te uiți la o celulă WS2812B Veți vedea că are intrarea Data In sau DI și sursa de alimentare Vcc și GND. Apoi va avea alte trei ieșiri, acestea vor fi conectate la următoarea celulă a benzii, iar următoarea celulă va avea ieșirile conectate la intrarea următoarei și așa mai departe până când se termină întreaga bandă ...

Tocmai asta DI sau introducere de date cel care este interesant pentru a configura LED-urile RGB și același va fi conectat la Data Out sau DO care va duce aceleași informații la următorul link din bandă. Și așa se răspândește pe toată banda.

Cumpărați benzi LED WS2812B RGB

Poti cumpărați la un preț nu prea mare în diverse magazine specializate. Le aveți și în Amazon în diferite formate. Câteva exemple sunt:

Testarea cu Arduino și WS2812B

După cum vă puteți imagina, este foarte ușor să folosiți doar trei pini conectează-te la arduino după cum puteți vedea în diagrama de mai sus. Trebuie doar să conectați 5v și GND la banda WS2812B și DI la o ieșire pe care o doriți pe Arduino. Amintiți-vă că, dacă vă schimbați pinul, trebuie să modificați și codul sursă, astfel încât programul să funcționeze corect.

Biblioteca a fost folosită FAST-LED Master pentru a ușura lucrurile și pentru a obține funcții simple pentru a conduce LED-uri RGB. Pentru a-l descărca și a-l integra corect în IDE-ul Arduino, trebuie doar să descărcați biblioteca din acel link, apoi dezarhivați codul ZIP și redenumiți directorul sau folderul dezarhivat ca FastLED, apoi mutați acel dosar în locul în care sunt instalate bibliotecile IDE Arduino în instalarea dvs. . Apoi redeschideți ID-ul Arduino și va fi gata ...

Ca cod schiță, poate fi destul de simplu ca următorul cod. Dacă nu doriți să copiați și să lipiți, îl puteți găsi printre exemplele care vin deja. Deci, accesați Fișier> Exemple> FastLED> ColorPalette.

Nu uitați să schimbați pinul 14 din exemplu în 5, care este cel pe care l-am folosit în diagramă. Sau vă puteți conecta la pinul 14 și evitați modificarea codului. După cum preferați.

#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: banda LED RGB magică

Ce este WS2812B?

Pinout și foaie de date

Cumpărați benzi LED WS2812B RGB

Testarea cu Arduino și WS2812B

Lasă comentariul tău Anulați răspunsul