WS2812B: den magiska RGB LED-remsan

Du måste säkert lägga till en touch av färg till dina DIY-projekt. För detta använder många tillverkare den berömda WS2812B RGB LED-remsor, för att uppnå en varierad färgkontroll och ganska attraktiva ljuseffekter för dina projekt. Naturligtvis är de remsor som är helt kompatibla med Arduino-kort, så du har inga problem när du försöker integrera dem.

Du kan hitta dem i längder på 1 meter, till exempel, även om de kan variera beroende på typen av lysdiodernas densitet för varje mätare de har. Det finns till exempel från 30 lysdioder till 144 lysdioder. Men om du behöver längre längder för att få en större yta har du också andra alternativ på marknaden som RGB LED-paneler eller så kan du alltid använda flera remsor ...

Dessa remsor är inget annat än en serie monterade RGB-lysdioder och monteras på ett gemensamt stöd för att gruppera dem i remsor. Men dess funktion är identisk med de separata RGB-lysdioderna.

Mer information om RGB-lysdioder

Vad är WS2812B?

Egentligen är WS2812B inte själva remsan, utan var och en av dem cellerna eller små RGB LED-plattor som inkluderar. De kan grupperas i form av en remsa eller en panel så att du kan göra olika konfigurationer när det gäller antal och form. Remsorna som utgör är flexibla remsor, men du kan också hitta WS2812B på PCB-paneler som inte är det.

Om du vill kan du hitta enheterna WS2812B separat för att skapa de former du behöver själv. Till exempel kostar ungefär 100 enheter vanligtvis något mer än 10 €.

Du borde också veta att du kastar dem du kan klippa dem med en sax var du än behöver, det betyder inte att de slutar arbeta. Så du kan bara ha de RGB-lysdioder du behöver. Faktum är att den har några markeringar (tre kopparplattor) som du kan skära igenom. Om du skär igenom dessa dynor kommer du att ha tre spår på ena sidan av remsan och på den andra om du vill återanvända de andra delarna kan du löda stiften till dem för enkel anslutning.

Pinout och datablad

Det är en oberoende WS2812B-cell med sina in- och utgångar

För mer information om din RGB LED-strip WS2812B Du kan läsa databladet erbjuds av varje tillverkare, där kan du konsultera alla detaljer om mått och tekniska egenskaper för att veta hur man använder dem på rätt sätt, förutom att känna till alla arbetsområden och gränser.

Ladda ner WS2812B datablad

Beträffande pinoutDet är inte heller ett stort problem, dessa remsor har en enkel anslutning som du kan behärska från början utan för mycket kunskap. Det finns bara tre tillgängliga, även om varje WS2812B-cell faktiskt har fler anslutningar ...

Du måste helt enkelt ansluta på varje remsa Vcc-stiftet som matar remsan till 5V från Arduino eller från en annan strömförsörjning, GND till jord, naturligtvis, och slutligen DI som är den andra som går till någon utgång från mikrokontrollern för att aktivera RGB-lysdioder på remsan.

Om du tittar på en WS2812B-cell Du kommer att se att den har Data In- eller DI-ingången och Vcc- och GND-strömförsörjningen. Då kommer den att ha tre andra utgångar, de kommer att anslutas till nästa cell på remsan, och nästa cell kommer att ha sina utgångar anslutna till nästa ingång och så vidare tills hela remsan är klar ...

Det är just det DI eller dataingång den som är intressant att konfigurera RGB-lysdioderna, och samma kommer att anslutas till Data Out eller DO som tar samma information till nästa länk i remsan. Och så sprids den genom hela remsan.

Köp WS2812B RGB LED Strips

Du kan köp till ett inte för högt pris i olika specialbutiker. Du har dem också i Amazon i olika format. Några exempel är:

Testar med Arduino och WS2812B

Som ni kan föreställa er det med bara tre stift mycket lätt att göra anslut till arduino som du kan se i diagrammet ovan. Du måste bara ansluta 5v och GND till WS2812B-remsan och DI till en utgång du vill ha på Arduino. Kom ihåg att om du byter stift måste du också ändra källkoden så att programmet fungerar korrekt.

Biblioteket har använts FAST-LED Master för att göra saker enklare och få enkla funktioner för att driva RGB-lysdioder. För att ladda ner den och integrera den ordentligt i Arduino IDE, ladda ner bara biblioteket från den länken, packa sedan upp ZIP och byta namn på den uppackade katalogen eller mappen som FastLED och flytta sedan den mappen till där Arduino IDE-biblioteken är installerade i din installation . Öppna sedan Arduino IDE igen så är det klart ...

Beträffande skisskod, det kan vara ganska enkelt som följande kod. Om du inte vill kopiera och klistra in kan du hitta det bland de exempel som redan finns. Så gå till Arkiv> Exempel> FastLED> ColorPalette.

Kom ihåg att byta stift 14 från exemplet till 5 som är den jag använde i diagrammet. Eller så kan du ansluta till stift 14 och undvika att ändra koden. Som du föredrar.

#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: den magiska RGB LED-remsan

Vad är WS2812B?

Pinout och datablad

Köp WS2812B RGB LED Strips

Testar med Arduino och WS2812B

Lämna din kommentar Avbryt svar