WS2812B: de magische RGB LED-strip

Je moet zeker een vleugje kleur toevoegen aan je doe-het-zelfprojecten. Hiervoor gebruiken veel makers de beroemde WS2812B RGB ledstrips, waarmee u gevarieerde kleurcontrole en vrij aantrekkelijke lichteffecten voor uw projecten kunt bereiken. Het zijn natuurlijk strips die volledig compatibel zijn met de Arduino-boards, dus je zult geen problemen hebben wanneer je ze probeert te integreren.

Je kunt ze vinden in lengtes van 1 meterBijvoorbeeld, hoewel ze kunnen variëren afhankelijk van het type dichtheid van LED's voor elke meter die ze hebben. Zo zijn er van 30 leds tot 144 leds. Mocht je echter langere lengtes nodig hebben om een groter oppervlak te krijgen, dan heb je ook andere opties op de markt zoals RGB LED panelen of kan je altijd meerdere strips gebruiken ...

Deze strips zijn niets meer dan een reeks geassembleerde RGB-leds en gemonteerd op een gemeenschappelijke steun om ze in stroken te groeperen. Maar de werking is identiek aan de afzonderlijke RGB-leds.

Meer informatie over RGB-leds

Wat is WS2812B?

Eigenlijk is de WS2812B niet de strip zelf, maar elk van de cellen of kleine RGB LED-platen die bevatten. Ze kunnen worden gegroepeerd in de vorm van een strook of een paneel, zodat u verschillende configuraties kunt maken qua aantal en vorm. De strips waaruit het bestaat zijn flexibele strips, maar je vindt WS2812B ook op PCB-panelen die dat niet zijn.

Als je wilt, kun je de apparaten vinden WS2812B afzonderlijk om zelf de vormen te maken die je nodig hebt. Ongeveer 100 stuks ervan kosten bijvoorbeeld meestal iets meer dan € 10.

Je moet ook weten dat je ze gooit je kunt ze knippen met een schaar waar je maar wilt, dat wil niet zeggen dat ze stoppen met werken. U kunt dus alleen de RGB-leds hebben die u nodig heeft. Het heeft zelfs enkele markeringen (drie koperen pads) waar je doorheen kunt snijden. Als je deze pads doorsnijdt, heb je drie sporen aan de ene kant van de strip en aan de andere kant, voor het geval je de andere stukken wilt hergebruiken, kun je de pinnen erop solderen voor een gemakkelijke verbinding.

Pinout en gegevensblad

Het is een onafhankelijke WS2812B-cel met zijn in- en uitgangen

Voor meer informatie over uw RGB ledstrip WS2812B Jij kunt lezen het gegevensblad aangeboden door elke fabrikant, daar kunt u alle details van afmetingen en technische kenmerken raadplegen om te weten hoe u ze op de juiste manier kunt gebruiken, naast het kennen van alle werkingsbereiken en limieten.

Download WS2812B datasheet

Wat betreft pinoutOok is het geen groot probleem, deze strips hebben een simpele verbinding die je zonder al te veel kennis vanaf het begin onder de knie kunt krijgen. Er zijn er maar drie beschikbaar, hoewel elke WS2812B-cel eigenlijk meer aansluitingen heeft ...

Je moet gewoon aansluiten op elke strip de Vcc-pin die de strip naar de 5V van Arduino of een andere voeding voedt, de GND naar aarde natuurlijk, en tenslotte de DI die de andere is die naar een willekeurige uitgang van de microcontroller gaat om de RGB-leds op de strip.

Als je kijkt naar een WS2812B-cel U zult zien dat het de Data In- of DI-ingang heeft en de Vcc- en GND-voeding. Dan heeft het drie andere uitgangen, die worden verbonden met de volgende cel van de strip, en de uitgangen van de volgende cel worden verbonden met de ingang van de volgende enzovoort totdat de hele strip is voltooid ...

Het is precies dat DI of gegevensinvoer degene die interessant is om de RGB-leds te configureren, en diezelfde zal worden verbonden met Data Out of DO die dezelfde informatie naar de volgende link in de strip zal brengen. En zo verspreidt het zich over de strip.

Koop WS2812B RGB LED Strips

Jij kan koop tegen een niet al te hoge prijs in verschillende gespecialiseerde winkels. Je hebt ze ook in Amazon in verschillende formaten. Enkele voorbeelden zijn:

Testen met Arduino en WS2812B

Zoals u zich kunt voorstellen, is het met slechts drie pinnen heel gemakkelijk maak verbinding met arduino zoals je kunt zien in het bovenstaande diagram. Je hoeft alleen maar 5v en GND aan te sluiten op de WS2812B-strip en de DI op een gewenste uitgang op Arduino. Onthoud dat als u de pin verandert, u ook de broncode moet wijzigen zodat het programma correct werkt.

De bibliotheek is gebruikt SNELLE LED-master om dingen gemakkelijker te maken en eenvoudige functies te krijgen om RGB-leds aan te sturen. Om het te downloaden en correct te integreren in de Arduino IDE, download je gewoon de bibliotheek via die link, pak je de ZIP uit en hernoem je de uitgepakte map of map als FastLED, en verplaats je die map naar waar de Arduino IDE-bibliotheken in je installatie zijn geïnstalleerd . Open vervolgens de Arduino IDE opnieuw en hij is klaar ...

Wat betreft schetscode, kan het vrij eenvoudig zijn, zoals de volgende code. Als u niet wilt kopiëren en plakken, kunt u het vinden tussen de voorbeelden die al beschikbaar zijn. Ga dus naar Bestand> Voorbeelden> FastLED> ColorPalette.

Vergeet niet om pin 14 van het voorbeeld te veranderen in 5, die ik in het diagram heb gebruikt. Of u kunt verbinding maken met pin 14 en de code niet wijzigen. Zoals je wilt.

#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: de magische RGB ledstrip

Wat is WS2812B?

Pinout en gegevensblad

Koop WS2812B RGB LED Strips

Testen met Arduino en WS2812B

Laat je reactie achter Antwoord annuleren