WS2812B: a varázslatos RGB LED szalag

Isaac

9 perc

WS2812B RGB LED szalag

Biztosan hozzá kell adnia egy kis színt a barkácsolási projektjeihez. Ehhez sok készítő használja a híres WS2812B RGB LED csíkok, amellyel változatos színszabályozást és meglehetősen vonzó fényhatásokat érhet el projektjeihez. Természetesen ezek az Arduino táblákkal teljesen kompatibilis szalagok, így nem lesz semmi gond, amikor megpróbálja integrálni őket.

Megtalálhatod őket a hossza 1 méterpéldául, bár változhatnak a LED-ek sűrűségének típusától függően minden egyes mérőnknél. Például 30 LED és 144 LED között van. Ha azonban nagyobb hosszúságra van szüksége a nagyobb felület eléréséhez, akkor más lehetőségei is vannak a piacon, például RGB LED panelek, vagy mindig több szalagot is használhat ...

Ezek a csíkok nem mások, mint összeszerelt RGB LED-ek sora és egy közös tartóra erősítve csíkokra csoportosítják őket. De működése megegyezik a különálló RGB LED-ekkel.

Mi az a WS2812B?

RGB WS2812B világító LED szalag

Valójában a WS2812B nem maga a szalag, hanem mindegyik a sejtek vagy kis RGB LED lemezek, amelyek tartalmazzák. Csoportosíthatók csíkok vagy panelek formájában, így számuk és alakjuk szempontjából különféle konfigurációkat készíthet. Az alkotó csíkok rugalmas szalagok, de a WS2812B-t is megtalálhatja olyan NYÁK-paneleken, amelyek nem.

Ha akarja, megtalálja az eszközöket WS2812B külön hogy magad alkossd meg a szükséges alakokat. Például körülbelül 100 egység belőlük általában valamivel több, mint 10 euró.

rgb led szalagvágás

Azt is tudnia kell, hogy dobja őket felvághatja őket ollóval, ahol csak szüksége van rá, ez nem jelenti azt, hogy abbahagynák a munkát. Tehát csak a szükséges RGB LED-ekkel rendelkezhet. Valójában van néhány jel (három réz betét), amelyeket átvághat. Ha átvágja ezeket a betéteket, akkor három sáv lesz a szalag egyik oldalán, a másikon pedig abban az esetben, ha a többi darabot újra fel akarja használni, bennük forraszthatja a csapokat az egyszerű csatlakoztatás érdekében.

Pinout és adatlap

WS2812B egy egyszerű cellában

Ez egy független WS2812B cella a be- és kimenetekkel

További információ a RGB LED szalag WS2812B Te tudsz olvasni az adatlapot az egyes gyártók által kínált termékeken keresztül megtekintheti a méretek és a műszaki jellemzők minden részletét, hogy megismerje azok megfelelő használatát, valamint az összes működési tartományt és határt.

Tekintettel kitűzEz sem jelent nagyobb problémát, ezeknek a szalagoknak egyszerű kapcsolata van, amelyet már a kezdetektől elsajátíthat túl sok tudás nélkül. Csak három áll rendelkezésre, bár mindegyik WS2812B cellának több kapcsolata van ...

Egyszerűen muszáj kapcsolódni minden csíkon az a Vcc-tű, amely a szalagot táplálja az 5 V-ra Arduinótól vagy egy másik tápegységtől, természetesen a GND a földhöz, és végül a DI, amely a másik, amely a mikrovezérlő bármely kimenetéhez megy az RGB aktiválásához LED-ek a szalagon.

Ha megnézed egy WS2812B cellát Látni fogja, hogy rendelkezik a Data In vagy DI bemenettel, valamint a Vcc és a GND tápegységgel. Ezután még három kimenete lesz, ezek a szalag következő cellájához lesznek kapcsolva, és a következő cellának a kimenetei a következő bemenetéhez csatlakoznak, és így tovább, amíg az egész szalag elkészül

Pontosan ez az DI vagy adatbevitel az, amely érdekes konfigurálni az RGB LED-eket, és ugyanez csatlakozik a Data Out vagy a DO-hoz, amely ugyanazt az információt a szalag következő linkjéhez viszi. És így terjed a csíkon.

Vásároljon WS2812B RGB LED-szalagokat

RGB LED szalagtekercs

tudsz vásárolni nem túl magas áron különféle szaküzletekben. Az Amazon-on is vannak, különböző formátumokban. Néhány példa:

Tesztelés Arduino-val és WS2812B-vel

Arduino UNO WS2812B sémával

Ahogy el lehet képzelni, csak három csap segítségével nagyon könnyű csatlakozzon az arduino-hoz amint a fenti ábrán láthatja. Csak csatlakoztatnia kell az 5v-t és a GND-t a WS2812B szalaghoz, a DI-t pedig az Arduino kívánt kimenetéhez. Ne feledje, hogy ha megváltoztatja a PIN-kódot, akkor módosítania kell a forráskódot is, hogy a program megfelelően működjön.

A könyvtárat használták FAST-LED mester hogy megkönnyítse a dolgokat és egyszerű funkciókat kapjon az RGB LED-ek vezérléséhez. Töltse le és megfelelően integrálja az Arduino IDE-be, csak töltse le a könyvtárat erről a hivatkozásról, majd csomagolja ki a ZIP-t, és nevezze át a kicsomagolt könyvtárat vagy mappát FastLED-nek, majd helyezze át azt a mappát, ahová az Arduino IDE könyvtárak telepítve vannak a telepítésben . Ezután nyissa meg újra az Arduino IDE-t, és készen áll ...

Tekintettel vázlatkód, meglehetősen egyszerű lehet, mint a következő kód. Ha nem akar másolni és beilleszteni, megtalálja a már érkező példák között. Tehát lépjen a Fájl> Példák> FastLED> ColorPalette menüpontba.

Ne felejtse el megváltoztatni a 14. tűt a példáról 5-re, amelyet a diagramban használtam. Vagy csatlakozhat a 14. tűhöz, és elkerülheti a kód módosítását. Ahogy szeretnéd. 
#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.

Legyen Ön az első hozzászóló

Hagyja megjegyzését

E-mail címed nem kerül nyilvánosságra. Kötelező mezők vannak jelölve *

*

*

  1. Az adatokért felelős: Miguel Ángel Gatón
  2. Az adatok célja: A SPAM ellenőrzése, a megjegyzések kezelése.
  3. Legitimáció: Az Ön beleegyezése
  4. Az adatok közlése: Az adatokat csak jogi kötelezettség alapján továbbítjuk harmadik felekkel.
  5. Adattárolás: Az Occentus Networks (EU) által üzemeltetett adatbázis
  6. Jogok: Bármikor korlátozhatja, helyreállíthatja és törölheti adatait.