WS2812B: stebuklinga RGB LED juosta

Savo „pasidaryk pats“ projektams tikrai reikia pridėti šiek tiek spalvų. Tam daugelis kūrėjų naudoja garsiuosius WS2812B RGB LED juostelės, kuriais galite pasiekti įvairų spalvų valdymą ir gana patrauklius apšvietimo efektus savo projektams. Žinoma, jie yra visiškai suderinami su „Arduino“ plokštėmis, todėl neturėsite jokių problemų bandydami juos integruoti.

Jūs galite juos rasti 1 metro ilgio, pavyzdžiui, nors jie gali skirtis priklausomai nuo kiekvieno turimo skaitiklio šviesos diodų tankio tipo. Pavyzdžiui, yra nuo 30 iki 144 šviesos diodų. Tačiau jei jums reikia didesnio ilgio, kad gautumėte didesnį paviršių, rinkoje taip pat turite kitų galimybių, tokių kaip RGB LED plokštės arba visada galite naudoti kelias juostas ...

Šios juostelės yra ne kas kita kaip surinktų RGB šviesos diodų serija ir sumontuoti ant bendros atramos grupuojant juos į juosteles. Bet jo veikimas yra identiškas atskiriems RGB šviesos diodams.

Daugiau informacijos apie RGB šviesos diodus

Kas yra WS2812B?

Tiesą sakant, WS2812B yra ne pati juosta, o kiekviena iš jų ląstelės arba mažos RGB LED plokštės, kuriose yra. Jie gali būti sugrupuoti juostelės ar skydelio pavidalu, todėl galite atlikti įvairias konfigūracijas pagal jų skaičių ir formą. Juostos, sudarančios lanksčias juostas, tačiau WS2812B taip pat galite rasti ant plokščių plokščių, kurios nėra.

Jei norite, galite rasti įrenginius WS2812B atskirai norėdami patys susikurti jums reikalingas formas. Pavyzdžiui, maždaug 100 vienetų jų paprastai kainuoja šiek tiek daugiau nei 10 eurų.

Taip pat turėtumėte žinoti, kad juos mėtote galite juos supjaustyti žirklėmis, kur jums reikia, tai nereiškia, kad jie nustoja veikti. Taigi galite turėti tik jums reikalingus RGB šviesos diodus. Tiesą sakant, jis turi keletą žymių (tris varinius įklotus), kuriuos galite iškirpti. Jei išpjausite šias trinkeles, vienoje juostos pusėje turėsite tris takelius, o kitoje - jei norite pakartotinai panaudoti kitus gabalus, galite prie jų sulituoti kaiščius, kad būtų lengviau juos sujungti.

Pinout ir duomenų lapas

Tai nepriklausoma WS2812B ląstelė su įėjimais ir išėjimais

Norėdami gauti daugiau informacijos apie jūsų RGB LED juosta WS2812B Galite skaityti duomenų lapą siūlo kiekvienas gamintojas, be to, jūs galite sužinoti visas matmenų ir techninių charakteristikų detales, kad žinotumėte, kaip tinkamai jas naudoti, taip pat žinoti visus veikimo diapazonus ir ribas.

Atsisiųskite WS2812B duomenų lapą

Dėl pinoutTai taip pat nėra pagrindinė problema, šios juostelės turi paprastą jungtį, kurią galite įvaldyti nuo pat pradžių neturėdami per daug žinių. Yra tik trys, nors kiekviena WS2812B ląstelė iš tikrųjų turi daugiau jungčių ...

Jūs tiesiog privalote prisijungti ant kiekvienos juostelės Vcc kaištis, kuris maitina juostą 5 V iš Arduino arba iš kito maitinimo šaltinio, žinoma, GND į žemę, ir galiausiai DI, kuris yra kitas, kuris eis į bet kurią mikrovaldiklio išvestį, kad įjungtų RGB šviesos diodai ant juostos.

Jei pažvelgsi WS2812B ląstelė Pamatysite, kad jame yra duomenų įvesties arba DI įvestis ir Vcc ir GND maitinimo šaltinis. Tada jis turės tris kitus išėjimus, kurie bus prijungti prie kitos juostos ląstelės, o kitos ląstelės išėjimai bus prijungti prie kitos ir tt įvesties, kol bus baigta visa juosta ...

Tai yra būtent tai DI arba duomenų įvedimas tas, kuris įdomu konfigūruoti RGB šviesos diodus, ir tas pats bus prijungtas prie „Data Out“ arba „DO“, kuris tą pačią informaciją nukreips į kitą juostos saitą. Taigi jis pasklido po visą juostą.

Pirkite WS2812B RGB LED juostas

Tu gali pirkti ne per didele kaina įvairiose specializuotose parduotuvėse. Jūs taip pat turite juos „Amazon“ skirtingais formatais. Keletas pavyzdžių:

Testavimas naudojant „Arduino“ ir WS2812B

Kaip jūs galite įsivaizduoti, tik su trim kaiščiais tai labai lengva prisijungti prie arduino kaip matote aukščiau pateiktoje diagramoje. Jūs tiesiog turite prijungti 5v ir GND prie WS2812B juostos, o DI - prie norimos išvesties „Arduino“. Atminkite, kad pakeitus PIN kodą, taip pat turite modifikuoti šaltinio kodą, kad programa veiktų tinkamai.

Biblioteka buvo naudojama „FAST-LED Master“ palengvinti reikalus ir gauti paprastas funkcijas valdant RGB šviesos diodus. Norėdami tinkamai atsisiųsti ir integruoti ją į „Arduino IDE“, tiesiog atsisiųskite biblioteką iš tos nuorodos, tada išpakuokite ZIP ir pervadinkite išpakuotą katalogą ar aplanką kaip „FastLED“, tada perkelkite tą aplanką į vietą, kur jūsų diegime yra įdiegtos „Arduino IDE“ bibliotekos. Tada vėl atidarykite „Arduino IDE“ ir jis bus paruoštas ...

Dėl eskizo kodas, tai gali būti gana paprasta, kaip šis kodas. Jei nenorite kopijuoti ir įklijuoti, galite tai rasti tarp jau pateiktų pavyzdžių. Taigi eikite į Failas> Pavyzdžiai> FastLED> ColorPalette.

Nepamirškite pakeisti kaiščio 14 iš pavyzdžio į 5, kurį naudojau diagramoje. Arba galite prisijungti prie 14 kaiščio ir išvengti modifikavimo. Kaip jums labiau patinka.

#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: stebuklinga RGB LED juosta

Kas yra WS2812B?

Pinout ir duomenų lapas

Pirkite WS2812B RGB LED juostas

Testavimas naudojant „Arduino“ ir WS2812B

Palikite komentarą Atšaukti atsakymą