WS2812B: ang mahiwagang RGB LED strip

Isaac

9 Minutos

WS2812B RGB LED strip

Tiyak na kailangan mong magdagdag ng isang ugnayan ng kulay sa iyong mga proyekto sa DIY. Para dito, maraming gumagawa ang gumagamit ng sikat WS2812B RGB LED Strips, kung saan makakamtan ang iba't ibang kontrol sa kulay at medyo kaakit-akit na mga ilaw na ilaw para sa iyong mga proyekto. Siyempre ang mga ito ay ganap na katugma sa mga board ng Arduino, kaya't wala kang anumang problema kapag sinusubukang isama ang mga ito.

Maaari mong mahanap ang mga ito sa haba ng 1 metro, halimbawa, bagaman maaari silang mag-iba depende sa uri ng density ng mga LED para sa bawat metro na mayroon sila. Halimbawa, mayroong mula sa 30 LEDs hanggang 144 LEDs. Gayunpaman, kung kailangan mo ng mas mahabang haba upang makakuha ng isang mas malaking ibabaw, mayroon ka ring iba pang mga pagpipilian sa merkado tulad ng RGB LED panels o maaari mong palaging gumamit ng maraming mga piraso ...

Ang mga strip na ito ay hindi hihigit sa isang serye ng mga binuo RGB LEDs at naka-mount sa isang karaniwang suporta upang maipangkat ang mga ito sa mga piraso. Ngunit ang operasyon nito ay magkapareho sa magkakahiwalay na RGB LEDs.

Ano ang WS2812B?

Ang RGB WS2812B ay nag-iilaw ng LED strip

Sa totoo lang ang WS2812B ay hindi ang strip mismo, ngunit ang bawat isa sa ang mga cell o maliit na RGB LED plate na may kasamang. Maaari silang mai-grupo sa anyo ng isang strip o isang panel, kaya maaari kang gumawa ng iba't ibang mga pagsasaayos sa mga tuntunin ng kanilang bilang at hugis. Ang mga piraso na bumubuo ay nababaluktot na mga piraso, ngunit maaari mo ring makita ang WS2812B sa mga PCB panel na hindi.

Kung nais mo, mahahanap mo ang mga aparato Hiwalay na WS2812B upang likhain ang mga hugis na kailangan mo mismo. Halimbawa, tungkol sa 100 mga yunit ng mga ito ay karaniwang nagkakahalaga ng bahagyang higit sa € 10.

rgb humantong strip paggupit

Dapat mo ring malaman na itinapon mo ang mga ito maaari mong i-cut ang mga ito na may gunting saan man kailangan mo, hindi iyon nangangahulugan na tumitigil sila sa pagtatrabaho. Kaya maaari ka lamang magkaroon ng mga RGB LED na kailangan mo. Sa katunayan, mayroon itong ilang mga marka (tatlong tanso pad) na maaari mong gupitin. Kung pinutol mo ang mga pad na ito, magkakaroon ka ng tatlong mga track sa isang gilid ng strip at sa iba pa kung sakaling nais mong magamit muli ang iba pang mga piraso, sa mga ito maaari mong solder ang mga pin para sa madaling koneksyon.

Pinout at datasheet

WS2812B sa isang simpleng cell

Ito ay isang independiyenteng WS2812B cell na may mga input at output

Para sa karagdagang impormasyon tungkol sa iyong RGB LED strip WS2812B Mababasa mo ang datasheet inaalok ng bawat tagagawa, doon maaari kang kumunsulta sa lahat ng mga detalye ng mga sukat at mga teknikal na katangian upang malaman kung paano gamitin ang mga ito nang maayos, bilang karagdagan sa pag-alam sa lahat ng mga saklaw at limitasyon sa pagpapatakbo.

Ukol sa PinoutHindi rin ito isang pangunahing problema, ang mga strip na ito ay may isang simpleng koneksyon na maaari mong makabisado mula sa simula nang walang labis na kaalaman. Mayroong tatlong magagamit lamang, kahit na ang bawat WS2812B cell ay talagang may maraming mga koneksyon ...

Kailangan mo lang kumonekta sa bawat strip ang Vcc pin na nagpapakain ng strip sa 5V mula sa Arduino o mula sa iba't ibang supply ng kuryente, ang GND sa lupa, syempre, at sa wakas ang DI na kung saan ay ang iba pang pupunta sa anumang output ng microcontroller upang buhayin ang Mga RGB LED sa strip.

Kung titingnan mo isang WS2812B cell Makikita mo na mayroon itong input ng Data In o DI, at ang supply ng kuryente ng Vcc at GND. Pagkatapos magkakaroon ito ng tatlong iba pang mga output, ang mga iyon ay konektado sa susunod na cell ng strip, at ang susunod na cell ay magkakaroon ng mga output na konektado sa input ng susunod at iba pa hanggang sa makumpleto ang buong strip ...

Ito ay tiyak na DI o input ng data ang isa na kagiliw-giliw na i-configure ang mga RGB LEDs, at ang magkatulad na iyon ay makakonekta sa Data Out o DO na kukuha ng parehong impormasyon sa susunod na link sa strip. At sa gayon kumalat ito sa buong strip.

Bumili ng WS2812B RGB LED Strips

RGB LED strip roll

Kaya mo bumili sa hindi masyadong mataas na presyo sa iba`t ibang mga dalubhasang tindahan. Mayroon ka ring mga ito sa Amazon sa iba't ibang mga format. Ang ilang mga halimbawa ay:

Pagsubok sa Arduino at WS2812B

Arduino UNO kasama ang WS2812B schema

Tulad ng naiisip mo, sa tatlong mga pin lamang ito napakadaling kumonekta sa arduino tulad ng nakikita mo sa diagram sa itaas. Kailangan mo lamang ikonekta ang 5v at GND sa WS2812B strip, at ang DI sa isang nais mong output sa Arduino. Tandaan na kung binago mo ang iyong pin, dapat mo ring baguhin ang source code upang gumana nang maayos ang programa.

Nagamit na ang silid-aklatan Mabilis na LED Master upang gawing mas madali ang mga bagay at makakuha ng mga simpleng pag-andar upang himukin ang RGB LEDs. Upang mai-download ito at maisama nang maayos sa Arduino IDE, i-download lamang ang library mula sa link na iyon, pagkatapos ay i-unzip ang ZIP at palitan ang pangalan ng hindi naka-zip na direktoryo o folder bilang FastLED, at pagkatapos ay ilipat ang folder na iyon kung saan naka-install ang mga aklatan ng Arduino IDE sa iyong pag-install . Pagkatapos ay buksan muli ang Arduino IDE at magiging handa na ...

Ukol sa sketch code, maaari itong maging simple tulad ng sumusunod na code. Kung hindi mo nais na kopyahin at i-paste, mahahanap mo ito kasama ng mga halimbawang dumating na. Kaya pumunta sa File> Mga Halimbawa> FastLED> ColorPalette.

Tandaan na palitan ang pin 14 mula sa halimbawa hanggang 5 na kung saan ay ang ginamit ko sa diagram. O maaari kang kumonekta sa pin 14 at iwasang baguhin ang code. Tulad ng gusto mo. 
#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.

Maging una sa komento

Iwanan ang iyong puna

Ang iyong email address ay hindi nai-publish. Mga kinakailangang patlang ay minarkahan ng *

*

*

  1. Responsable para sa data: Miguel Ángel Gatón
  2. Layunin ng data: Kontrolin ang SPAM, pamamahala ng komento.
  3. Legitimation: Ang iyong pahintulot
  4. Komunikasyon ng data: Ang data ay hindi maiparating sa mga third party maliban sa ligal na obligasyon.
  5. Imbakan ng data: Ang database na naka-host ng Occentus Networks (EU)
  6. Mga Karapatan: Sa anumang oras maaari mong limitahan, mabawi at tanggalin ang iyong impormasyon.