Zagotovo morate svojim projektom DIY dodati barvo. Za to mnogi proizvajalci uporabljajo slavne WS2812B RGB LED trakovi, s katerimi lahko dosežete raznolik nadzor barv in dokaj privlačne svetlobne učinke za svoje projekte. Seveda gre za trakove, ki so popolnoma združljivi z ploščami Arduino, zato ne boste imeli težav pri njihovi integraciji.
Najdete jih v dolžine 1 meterna primer, čeprav se lahko razlikujejo glede na vrsto gostote LED za vsak meter, ki ga imajo. Na primer, obstaja od 30 LED do 144 LED. Če pa potrebujete daljše dolžine, da dobite večjo površino, imate na trgu tudi druge možnosti, kot so RGB LED plošče ali pa vedno uporabite več trakov ...
Ti trakovi niso nič drugega kot vrsto sestavljenih RGB LED in nameščeni na skupni podpori, da jih združimo v trakove. Toda njegovo delovanje je enako ločenim RGB LED.
Kaj je WS2812B?
WS2812B pravzaprav ni trak sam, ampak vsak od celic ali majhne RGB LED plošče, ki vključujejo. Lahko jih združimo v obliki traku ali plošče, tako da lahko naredite različne konfiguracije glede na njihovo število in obliko. Trakovi, ki jih sestavljajo, so fleksibilni trakovi, WS2812B pa lahko najdete tudi na ploščah PCB, ki niso.
Če želite, lahko najdete naprave WS2812B ločeno da sami ustvarite oblike, ki jih potrebujete. Na primer, približno 100 enot običajno stanejo nekaj več kot 10 EUR.
Vedeti morate tudi, da jih vržete lahko jih režete s škarjami, kjer koli potrebujete, to ne pomeni, da prenehajo delovati. Tako lahko imate samo RGB LED diode, ki jih potrebujete. Pravzaprav ima nekaj oznak (tri bakrene blazinice), ki jih lahko prerežete. Če prerežete te blazinice, boste imeli na eni strani traku tri skladbe, na drugi pa, če želite ponovno uporabiti ostale kose, lahko nanje zataknete nožke za enostavno povezavo.
Izrez in podatkovni list
Je neodvisna celica WS2812B s svojimi vhodi in izhodi
Za več informacij o vašem RGB LED trak WS2812B Lahko berete podatkovni list Ponuja jih vsak proizvajalec, kjer se lahko seznanite z vsemi podrobnostmi o dimenzijah in tehničnih lastnostih, da boste vedeli, kako jih pravilno uporabljati, poleg tega pa tudi poznati vsa delovna območja in omejitve.
Kar se tiče pinoutTudi to ni večja težava, ti trakovi imajo preprosto povezavo, ki jo lahko obvladate od začetka brez preveč znanja. Na voljo so le trije, čeprav ima vsaka celica WS2812B dejansko več povezav ...
Preprosto moraš povežite na vsakem traku Vcc zatič, ki napaja trak na 5 V iz Arduina ali iz drugega napajalnika, GND na maso, seveda in na koncu DI, ki je drugi, ki bo šel na kateri koli izhod mikrokrmilnika, da aktivira RGB LED na traku.
Če pogledate celica WS2812B Videli boste, da ima vhod Data In ali DI ter napajanje Vcc in GND. Potem bo imel tri druge izhode, ti bodo povezani z naslednjo celico traku, naslednja celica pa bo imela izhode povezane z vhodom naslednje in tako naprej, dokler ne bo zaključen celoten trak ...
Prav to je DI ali vnos podatkov tisto, ki je zanimiva za konfiguriranje LED RGB, in ta ista bo priključena na Data Out ali DO, ki bo te iste informacije prenesla na naslednjo povezavo v traku. In tako se širi po celotnem pasu.
Kupite WS2812B RGB LED trakove
Ti lahko kupujte po ne previsoki ceni v različnih specializiranih trgovinah. V Amazonu jih imate tudi v različnih oblikah. Nekaj primerov je:
- RGB LED trakovi WS2812B z 60 LED / m.
- RGB LED trakovi WS2812B z 100 LED / m.
- RGB LED trakovi WS2812B z 144 LED / m.
- RGB LED trakovi WS2812B z 5 metri 30 LED.
- RGB LED trakovi WS2812B z 5 metri 60 LED.
- Plošča WS2812B
- 5-metrska tuljava RGB LED.
Testiranje z Arduino in WS2812B
Kot si lahko predstavljate, je s samo tremi nožicami to zelo enostavno povezati z arduino kot lahko vidite na zgornjem diagramu. Na trak WS5B morate povezati 2812v in GND, DI pa na izhod, ki ga želite na Arduinu. Ne pozabite, da če spremenite PIN, morate spremeniti tudi izvorno kodo, da bo program pravilno deloval.
Kar se tiče skica koda, je lahko povsem preprosto, kot je naslednja koda. Če ne želite kopirati in prilepiti, ga lahko najdete med primeri, ki že prihajajo. Torej pojdite v Datoteka> Primeri> FastLED> ColorPalette.
#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.