WS2812B: strip LED RGB ajaib

Tentunya Anda perlu menambahkan sentuhan warna pada proyek DIY Anda. Untuk ini, banyak pembuat menggunakan yang terkenal Strip LED RGB WS2812B, yang dapat digunakan untuk mendapatkan kontrol warna yang bervariasi dan efek pencahayaan yang cukup menarik untuk proyek Anda. Tentu saja mereka adalah strip yang sepenuhnya kompatibel dengan papan Arduino, jadi Anda tidak akan mengalami masalah saat mencoba mengintegrasikannya.

Anda dapat menemukan mereka di panjang 1 meter, misalnya, meskipun dapat bervariasi bergantung pada jenis kerapatan LED untuk setiap meter yang dimilikinya. Misalnya, ada dari 30 LED hingga 144 LED. Namun, jika Anda membutuhkan panjang yang lebih panjang untuk mendapatkan permukaan yang lebih besar, Anda juga memiliki opsi lain di pasaran seperti panel LED RGB atau Anda selalu dapat menggunakan beberapa strip ...

Strip ini tidak lebih dari serangkaian LED RGB yang dirakit dan dipasang pada penyangga umum untuk mengelompokkannya menjadi strip. Tetapi operasinya identik dengan LED RGB terpisah.

Informasi lebih lanjut tentang LED RGB

Apa itu WS2812B?

Sebenarnya WS2812B bukanlah strip itu sendiri, tapi masing-masing sel atau pelat LED RGB kecil yang disertakan. Mereka dapat dikelompokkan dalam bentuk strip atau panel, sehingga Anda dapat membuat berbagai konfigurasi dalam hal jumlah dan bentuknya. Strip yang membentuk adalah strip fleksibel, tetapi Anda juga dapat menemukan WS2812B pada panel PCB yang tidak.

Jika mau, Anda dapat menemukan perangkatnya WS2812B secara terpisah untuk membuat bentuk yang Anda butuhkan sendiri. Misalnya, sekitar 100 unit biasanya harganya sedikit lebih dari € 10.

Anda juga harus tahu bahwa Anda membuangnya Anda bisa memotongnya dengan gunting di mana pun Anda membutuhkannya, itu tidak berarti gunting itu berhenti bekerja. Jadi Anda hanya dapat memiliki LED RGB yang Anda butuhkan. Bahkan, ada beberapa tanda (tiga bantalan tembaga) yang bisa Anda potong. Jika Anda memotong bantalan ini, Anda akan memiliki tiga trek di satu sisi strip dan di sisi lain jika Anda ingin menggunakan kembali bagian lainnya, di dalamnya Anda dapat menyolder pin untuk memudahkan koneksi.

Pinout dan lembar data

Ini adalah sel WS2812B independen dengan input dan outputnya

Untuk informasi lebih lanjut tentang Anda Strip LED RGB WS2812B Kamu bisa membaca lembar data ditawarkan oleh masing-masing pabrikan, di sana Anda dapat melihat semua detail dimensi dan karakteristik teknis untuk mengetahui cara menggunakannya dengan benar, selain mengetahui semua rentang dan batasan pengoperasian.

Unduh lembar data WS2812B

Mengenai pinoutIni juga bukan masalah besar, strip ini memiliki koneksi sederhana yang dapat Anda kuasai dari awal tanpa terlalu banyak pengetahuan. Hanya ada tiga yang tersedia, meskipun setiap sel WS2812B sebenarnya memiliki lebih banyak koneksi ...

Anda harus melakukannya terhubung pada setiap strip pin Vcc yang memberi makan strip ke 5V dari Arduino atau dari catu daya yang berbeda, GND ke ground, tentu saja, dan akhirnya DI yang lain yang akan pergi ke output apapun dari mikrokontroler untuk mengaktifkan LED RGB di strip.

Jika Anda melihat sel WS2812B Anda akan melihat bahwa ia memiliki input Data In atau DI, dan catu daya Vcc dan GND. Kemudian akan memiliki tiga keluaran lainnya, ini akan dihubungkan ke sel strip berikutnya, dan sel berikutnya akan memiliki keluaran yang terhubung ke masukan berikutnya dan seterusnya sampai seluruh strip selesai ...

Justru itu DI atau input data salah satu yang menarik untuk mengkonfigurasi LED RGB, dan yang sama akan dihubungkan ke Data Out atau DO yang akan membawa informasi yang sama ke tautan berikutnya di strip. Dan menyebar ke seluruh strip.

Beli Strip LED RGB WS2812B

Kamu bisa beli dengan harga yang tidak terlalu tinggi di berbagai toko khusus. Anda juga memilikinya di Amazon dalam format berbeda. Beberapa contohnya adalah:

Pengujian dengan Arduino dan WS2812B

Seperti yang bisa Anda bayangkan, hanya dengan tiga pin, ini sangat mudah terhubung ke Arduino seperti yang Anda lihat pada diagram di atas. Anda hanya perlu menghubungkan 5v dan GND ke strip WS2812B, dan DI ke output yang Anda inginkan di Arduino. Ingatlah bahwa jika Anda mengubah pin, Anda juga harus mengubah kode sumber agar program berfungsi dengan baik.

Perpustakaan telah digunakan Master LED CEPAT untuk mempermudah dan mendapatkan fungsi sederhana untuk menggerakkan LED RGB. Untuk mengunduh dan mengintegrasikannya dengan benar ke dalam Arduino IDE, cukup unduh pustaka dari tautan itu, lalu unzip ZIP dan ganti nama direktori atau folder yang tidak di-zip sebagai FastLED, dan kemudian pindahkan folder itu ke tempat pustaka Arduino IDE dipasang di instalasi Anda. Kemudian buka kembali Arduino IDE dan itu akan siap ...

Mengenai kode sketsa, ini bisa sangat sederhana seperti kode berikut. Jika Anda tidak ingin menyalin dan menempel, Anda dapat menemukannya di antara contoh-contoh yang sudah ada. Jadi buka File> Contoh> FastLED> ColorPalette.

Ingatlah untuk mengubah pin 14 dari contoh menjadi 5 yang saya gunakan dalam diagram. Atau Anda dapat menghubungkan ke pin 14 dan menghindari modifikasi kode. Terserah Anda.

#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: strip LED RGB ajaib

Apa itu WS2812B?

Pinout dan lembar data

Beli Strip LED RGB WS2812B

Pengujian dengan Arduino dan WS2812B

tinggalkan Komentar Anda Batalkan balasan