WS2812B: die magiese RGB LED-strook

U moet sekerlik 'n tikkie kleur by u DIY-projekte voeg. Hiervoor gebruik baie vervaardigers die beroemdes WS2812B RGB LED-strokies, waarmee u 'n gevarieerde kleurbeheer en baie aantreklike beligtingseffekte vir u projekte kan bewerkstellig. Natuurlik is dit strokies wat volledig versoenbaar is met die Arduino-borde, dus sal u geen probleem hê as u dit wil integreer nie.

U kan dit vind in lengtes van 1 meterbyvoorbeeld, alhoewel hulle kan wissel na gelang van die soort digtheid van LED's vir elke meter wat hulle het. Daar is byvoorbeeld van 30 LED's tot 144 LED's. As u egter langer lengtes benodig om 'n groter oppervlak te verkry, het u ook ander opsies op die mark, soos RGB LED-panele, of u kan altyd verskeie stroke gebruik ...

Hierdie stroke is niks anders as 'n reeks saamgestelde RGB-LED's en op 'n gemeenskaplike steun gemonteer om dit in stroke te groepeer. Maar die werking daarvan is identies aan die afsonderlike RGB-LED's.

Meer inligting oor RGB-LED's

Index

1 Wat is WS2812B?
- 1.1 Pinout en datablad
- 1.2 Koop WS2812B RGB LED-strokies
2 Toets met Arduino en WS2812B

Wat is WS2812B?

Eintlik is die WS2812B nie die strook self nie, maar elkeen daarvan die selle of klein RGB LED-plate wat insluit. Hulle kan gegroepeer word in die vorm van 'n strook of 'n paneel, sodat u verskillende konfigurasies kan maak wat hul aantal en vorm betref. Die stroke waaruit bestaan, is buigsame stroke, maar u kan WS2812B ook op PCB-panele vind wat nie is nie.

As u wil, kan u die toestelle vind WS2812B afsonderlik om self die vorms te skep wat u nodig het. Ongeveer 100 eenhede daarvan kos byvoorbeeld gewoonlik iets meer as € 10.

U moet ook weet dat u dit gooi jy kan dit sny met 'n skêr waar u ook al benodig, dit beteken nie dat hulle ophou werk nie. U kan dus net die RGB-LED's hê wat u benodig. In werklikheid het dit 'n paar merke (drie koperblokkies) wat u kan sny. As u hierdie kussings sny, het u drie spore aan die een kant van die strook en aan die ander kant, as u die ander stukke wil hergebruik, kan u die penne soldeer om dit maklik te verbind.

Pinout en datablad

Dit is 'n onafhanklike WS2812B-sel met sy in- en uitsette

Vir meer inligting oor u RGB LED-strook WS2812B U kan lees die datablad aangebied deur elke vervaardiger, kan u daar alle besonderhede van afmetings en tegniese eienskappe raadpleeg om te weet hoe u dit behoorlik kan gebruik, behalwe dat u al die werkbereike en -limiete ken.

Laai WS2812B datablad af

Soos vir die pen uitDit is ook nie 'n groot probleem nie, hierdie stroke het 'n eenvoudige verbinding wat u van meet af aan sonder veel kennis kan baasraak. Daar is net drie beskikbaar, hoewel elke WS2812B-sel eintlik meer verbindings het ...

U moet eenvoudig verbind op elke strook die Vcc-pen wat die strook voer na die 5V vanaf Arduino of van 'n ander kragbron, die GND na die aarde, natuurlik, en uiteindelik die DI, wat die ander is wat na enige uitset van die mikrobeheerder sal gaan om die RGB-LED's op die strook.

As jy kyk na 'n WS2812B-sel U sal sien dat dit die Data In- of DI-invoer en die Vcc- en GND-kragbron het. Dan sal daar drie ander uitsette hê, diegene sal aan die volgende sel van die strook gekoppel word, en die volgende sel se uitsette sal gekoppel wees aan die invoer van die volgende ensovoorts totdat die hele strook voltooi is ...

Dit is presies dit DI of data invoer die een wat interessant is om die RGB-LED's op te stel, en dieselfde een sal gekoppel word aan Data Out of DO wat dieselfde inligting na die volgende skakel in die strook sal neem. En so versprei dit deur die strook.

Koop WS2812B RGB LED-strokies

Jy kan koop teen 'n nie te hoë prys nie in verskillende gespesialiseerde winkels. U het dit ook in Amazon in verskillende formate. Enkele voorbeelde is:

Toets met Arduino en WS2812B

Soos u kan dink, is dit met net drie penne baie maklik om dit te doen verbind met arduino soos u in die diagram hierbo kan sien. U hoef net 5v en GND aan te sluit op die WS2812B-strook, en die DI op 'n uitgang wat u op Arduino wil hê. Onthou dat as u u PIN verander, u ook die bronkode moet wysig sodat die program behoorlik werk.

Die biblioteek is gebruik FAST-LED Meester om dinge makliker te maak en eenvoudige funksies te kry om RGB-LED's aan te dryf. Om dit af te laai en behoorlik in die Arduino IDE te integreer, laai net die biblioteek van die skakel af, pak die zip uit en herbenoem die uitgepakte gids of map as FastLED, en skuif die map na waar die Arduino IDE-biblioteke in u installasie geïnstalleer is . Maak dan die Arduino IDE weer oop en dit sal gereed wees ...

Soos vir die skets kode, dit kan heel eenvoudig wees soos die volgende kode. As u nie wil kopieer en plak nie, kan u dit onder die voorbeelde wat reeds verskyn, vind. Gaan dus na File> Voorbeelde> FastLED> ColorPalette.

Onthou om pen 14 van die voorbeeld in 5 te verander, wat ek in die diagram gebruik het. Of u kan aan pin 14 koppel en die kode nie verander nie. Soos u verkies.

#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.

hardewarepond

WS2812B: die magiese RGB LED-strook

Wat is WS2812B?

Pinout en datablad

Koop WS2812B RGB LED-strokies

Toets met Arduino en WS2812B

Wees die eerste om te kommentaar lewer

Laat u kommentaar Kanselleer antwoord