WS2812B: maaginen RGB-LED-nauha

Isaac

9 minuuttia

WS2812B RGB LED-nauha

Sinun täytyy varmasti lisätä ripaus väriä DIY-projekteihisi. Tätä varten monet valmistajat käyttävät kuuluisaa WS2812B RGB-LED-nauhat, jolla saavutetaan monipuolinen värisäätö ja melko houkuttelevat valotehosteet projekteihisi. Tietysti ne ovat täysin yhteensopivia Arduino-levyjen kanssa, joten sinulla ei ole mitään ongelmia yrittäessäsi integroida niitä.

Voit löytää ne pituus 1 metriEsimerkiksi, vaikka ne voivat vaihdella LEDien tiheyden tyypin mukaan jokaisella mittarilla, joka heillä on. Esimerkiksi LED-valoja on 30 - 144. Jos tarvitset kuitenkin pitempiä pintoja suuremman pinnan saamiseksi, sinulla on markkinoilla myös muita vaihtoehtoja, kuten RGB-LED-paneelit tai voit aina käyttää useita nauhoja ...

Nämä nauhat eivät ole muuta kuin sarja koottuja RGB-LEDejä ja asennettu yhteiseen tukeen niiden ryhmittelemiseksi nauhoiksi. Mutta sen toiminta on identtinen erillisten RGB-LEDien kanssa.

Mikä on WS2812B?

RGB WS2812B valaistu LED-nauha

Itse asiassa WS2812B ei ole itse nauha, vaan jokainen solut tai pienet RGB-LED-levyt, jotka sisältävät. Ne voidaan ryhmitellä nauhojen tai paneelien muodossa, joten voit tehdä erilaisia ​​kokoonpanoja niiden lukumäärän ja muodon suhteen. Muodostuvat nauhat ovat joustavia nauhoja, mutta WS2812B löytyy myös piirilevyistä, jotka eivät ole.

Jos haluat, löydät laitteet WS2812B erikseen luoda tarvitsemasi muodot itse. Esimerkiksi noin 100 yksikköä niistä maksaa yleensä hieman yli 10 euroa.

RGB led-nauhan leikkaus

Sinun tulisi myös tietää, että heität heidät voit leikata ne saksilla missä tarvitset, se ei tarkoita, että ne lakkaavat toimimasta. Joten sinulla voi olla vain tarvitsemasi RGB-LEDit. Itse asiassa siinä on joitain merkintöjä (kolme kuparityynyä), jotka voit leikata läpi. Jos leikkaat näiden tyynyjen läpi, sinulla on kolme raitaa nauhan toisella puolella ja toisella puolella, jos haluat käyttää muita kappaleita uudelleen, niissä voit juottaa tapit helppoon liittämiseen.

Pinout ja tietolomake

WS2812B yksinkertaisessa solussa

Se on riippumaton WS2812B-solu tuloineen ja lähdöineen

Lisätietoja RGB-LED-nauha WS2812B Osaat lukea lomakkeeseen jokaisen valmistajan tarjoamasta, siellä voit tutustua kaikkiin mittojen ja teknisten ominaisuuksien yksityiskohtiin, jotta tiedät, kuinka niitä käytetään oikein, sekä kaikkien käyttöalueiden ja rajojen tuntemisen.

Mitä Sokka irtiSe ei myöskään ole suuri ongelma, näillä nauhoilla on yksinkertainen yhteys, jonka voit hallita alusta alkaen ilman liikaa tietoa. Saatavilla on vain kolme, vaikka jokaisella WS2812B-solulla on todellakin enemmän yhteyksiä ...

Sinun täytyy vain kytkeä jokaisessa nauhassa Vcc-nasta, joka syöttää nauhan 5 V: n jännitteelle Arduinosta tai toisesta virtalähteestä, tietysti GND maahan, ja lopuksi DI, joka on toinen, joka menee mihin tahansa mikro-ohjaimen lähtöön aktivoimaan RGB-LEDit nauhassa.

Jos katsot WS2812B-solu Näet, että siinä on Data In- tai DI-tulo sekä Vcc- ja GND-virtalähde. Sitten sillä on kolme muuta lähtöä, nämä liitetään nauhan seuraavaan soluun, ja seuraavaan soluun lähdöt kytketään seuraavan ja niin edelleen, kunnes koko nauha on valmis ...

Juuri niin DI tai tietojen syöttö se, joka on mielenkiintoista konfiguroida RGB-ledit, ja sama kytketään Data Out- tai DO-laitteisiin, jotka vievät samat tiedot nauhan seuraavaan linkkiin. Ja niin se leviää koko nauhalle.

Osta WS2812B RGB LED-nauhat

RGB-LED-nauharulla

Sinä pystyt osta ei liian korkealla hinnalla useissa erikoisliikkeissä. Sinulla on myös niitä Amazonissa eri muodoissa. Joitakin esimerkkejä ovat:

Testaus Arduinolla ja WS2812B: llä

Arduino UNO WS2812B-skeeman kanssa

Kuten voitte kuvitella, vain kolmella tapilla se on erittäin helppo muodosta yhteys arduinoon kuten näet yllä olevasta kaaviosta. Sinun tarvitsee vain liittää 5v ja GND WS2812B-nauhaan ja DI vain haluamaasi lähtöön Arduinossa. Muista, että jos vaihdat PIN-koodia, sinun on myös muokattava lähdekoodia, jotta ohjelma toimii oikein.

Kirjastoa on käytetty FAST-LED-isäntä helpottaa asioita ja saada yksinkertaisia ​​toimintoja ajaa RGB-ledejä. Jos haluat ladata sen ja integroida sen oikein Arduino IDE -ohjelmaan, lataa kirjasto tältä linkiltä, ​​pura sitten ZIP-tiedosto ja nimeä purettu hakemisto tai kansio uudelleen FastLED-muotoon ja siirrä sitten kansio mihin Arduino IDE-kirjastot on asennettu asennukseen . Avaa sitten Arduino IDE uudelleen ja se on valmis ...

Mitä luonnos koodi, se voi olla melko yksinkertainen kuten seuraava koodi. Jos et halua kopioida ja liittää, löydät sen jo tulevista esimerkeistä. Joten siirry kohtaan Tiedosto> Esimerkit> FastLED> ColorPalette.

Muista vaihtaa tappi 14 esimerkistä 5: ksi, jota käytin kaaviossa. Tai voit muodostaa yhteyden nastaan ​​14 ja välttää koodin muokkaamista. Kuten haluat. 
#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.

Ole ensimmäinen kommentti

Jätä kommentti

Sähköpostiosoitettasi ei julkaista. Pakolliset kentät on merkitty *

*

*

  1. Vastuussa tiedoista: Miguel Ángel Gatón
  2. Tietojen tarkoitus: Roskapostin hallinta, kommenttien hallinta.
  3. Laillistaminen: Suostumuksesi
  4. Tietojen välittäminen: Tietoja ei luovuteta kolmansille osapuolille muutoin kuin lain nojalla.
  5. Tietojen varastointi: Occentus Networks (EU) isännöi tietokantaa
  6. Oikeudet: Voit milloin tahansa rajoittaa, palauttaa ja poistaa tietojasi.