WS2812B: maģiskā RGB LED lente

WS2812B RGB LED lente

Protams, jums jāpievieno krāsu pieskāriens jūsu DIY projektiem. Tam daudzi veidotāji izmanto slaveno WS2812B RGB LED sloksnes, ar kuru panākt daudzveidīgu krāsu kontroli un diezgan pievilcīgus gaismas efektus jūsu projektiem. Protams, tās ir sloksnes, kas pilnībā saderīgas ar Arduino dēļiem, tāpēc, mēģinot tās integrēt, jums nebūs problēmu.

Jūs tos varat atrast garums 1 metrs, piemēram, lai arī tie var atšķirties atkarībā no gaismas diožu blīvuma veida katram skaitītājam, kāds viņiem ir. Piemēram, ir no 30 LED līdz 144 LED. Tomēr, ja jums ir nepieciešams lielāks garums, lai iegūtu lielāku virsmu, tirgū ir arī citas iespējas, piemēram, RGB LED paneļi vai vienmēr varat izmantot vairākas sloksnes ...

Šīs sloksnes ir nekas vairāk kā virkne samontētu RGB gaismas diodes un uzstādīts uz kopēja balsta, lai tos grupētu sloksnēs. Bet tā darbība ir identiska atsevišķām RGB gaismas diodēm.

Kas ir WS2812B?

RGB WS2812B izgaismota LED lente

Faktiski WS2812B nav pati sloksne, bet katra no tām šūnas vai mazas RGB LED plāksnes, kurās ietilpst. Tos var sagrupēt sloksnes vai paneļa formā, lai jūs varētu veikt dažādas konfigurācijas to skaita un formas ziņā. Sloksnes, kas veido, ir elastīgas sloksnes, taču WS2812B var atrast arī uz PCB paneļiem, kas nav.

Ja vēlaties, varat atrast ierīces WS2812B atsevišķi lai pats izveidotu vajadzīgās formas. Piemēram, apmēram 100 vienības no tām parasti maksā nedaudz vairāk par 10 €.

rgb vadīta sloksnes griešana

Jums vajadzētu arī zināt, ka jūs tos iemetat jūs varat tos sagriezt ar šķērēm visur, kur jums nepieciešams, tas nenozīmē, ka tie pārtrauc darbu. Tātad jums var būt tikai nepieciešamās RGB gaismas diodes. Patiesībā tam ir daži marķējumi (trīs vara spilventiņi), kurus jūs varat izgriezt. Ja jūs izgriezīsit šos spilventiņus, vienā sloksnes pusē un otrā pusē būs trīs sliedes, ja vēlaties atkārtoti izmantot pārējos gabalus, tajos varat pielodēt tapas ērtai savienošanai.

Pinout un datu lapa

WS2812B vienkāršā šūnā

Tā ir neatkarīga WS2812B šūna ar ieejām un izejām

Lai iegūtu vairāk informācijas par jūsu RGB LED lente WS2812B Jūs varat lasīt datu lapu ko piedāvā katrs ražotājs, tur jūs varat uzzināt visu informāciju par izmēriem un tehniskajām īpašībām, lai zinātu, kā tos pareizi izmantot, kā arī zināt visus darbības diapazonus un ierobežojumus.

In Cuanto al pinoutTā arī nav liela problēma, šīm sloksnēm ir vienkāršs savienojums, kuru jūs varat apgūt no paša sākuma bez pārāk daudz zināšanu. Ir pieejami tikai trīs, lai gan katrai WS2812B šūnai faktiski ir vairāk savienojumu ...

Jums vienkārši ir savienot uz katras sloksnes Vcc tapa, kas baro sloksni uz 5V no Arduino vai no cita barošanas avota, protams, GND līdz zemei, un visbeidzot DI, kas ir otrs, kas dosies uz jebkuru mikrokontrollera izeju, lai aktivizētu RGB gaismas diodes uz sloksnes.

Ja paskatās šūna WS2812B Jūs redzēsiet, ka tam ir datu ievades vai DI ievade, kā arī Vcc un GND barošanas avots. Tad tam būs trīs citas izejas, tās tiks savienotas ar nākamo sloksnes šūnu, un nākamās šūnas izejas būs savienotas ar nākamās un tā tālāk ieeju, līdz visa josla būs pabeigta ...

Tas ir tieši tas DI vai datu ievade tas, kas ir interesanti konfigurēt RGB gaismas diodes, un tas pats tiks savienots ar Data Out vai DO, kas to pašu informāciju aizvedīs uz nākamo saiti joslā. Un tā tas izplatās visā sloksnē.

Pērciet WS2812B RGB LED sloksnes

RGB LED sloksnes rullis

Jūs varat pērciet par ne pārāk augstu cenu dažādos specializētos veikalos. Jums tie ir arī Amazon dažādos formātos. Daži piemēri ir:

Testēšana ar Arduino un WS2812B

Arduino UNO ar WS2812B shēmu

Kā jūs varat iedomāties, tikai ar trim tapām to ir ļoti viegli izdarīt pieslēdzieties arduino kā redzat iepriekš redzamajā diagrammā. Jums vienkārši jāpieslēdz 5v un GND WS2812B sloksnei, bet DI - vēlamajai izejai Arduino. Atcerieties, ka, mainot tapu, jums ir jāpārveido arī avota kods, lai programma darbotos pareizi.

Bibliotēka ir izmantota FAST-LED meistars lai atvieglotu lietas un iegūtu vienkāršas funkcijas, lai vadītu RGB gaismas diodes. Lai to lejupielādētu un pareizi integrētu Arduino IDE, vienkārši lejupielādējiet bibliotēku no šīs saites, pēc tam izpakojiet ZIP un pārsauciet nesaspiestu direktoriju vai mapi kā FastLED un pēc tam pārvietojiet šo mapi uz vietu, kur instalācijā ir instalētas Arduino IDE bibliotēkas. . Pēc tam atkārtoti atveriet Arduino IDE, un tas būs gatavs ...

In Cuanto al skices kods, tas var būt diezgan vienkāršs, piemēram, šāds kods. Ja nevēlaties kopēt un ielīmēt, to varat atrast starp jau esošajiem piemēriem. Tāpēc dodieties uz File> Piemēri> FastLED> ColorPalette.

Atcerieties nomainīt tapu 14 no piemēra uz 5, kuru izmantoju diagrammā. Vai arī varat izveidot savienojumu ar 14. kontaktu un izvairīties no koda modificēšanas. Kā vēlaties.
#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.



Esi pirmais, kas komentārus

Atstājiet savu komentāru

Jūsu e-pasta adrese netiks publicēta. Obligātie lauki ir atzīmēti ar *

*

*

  1. Atbildīgais par datiem: Migels Ángels Gatóns
  2. Datu mērķis: SPAM kontrole, komentāru pārvaldība.
  3. Legitimācija: jūsu piekrišana
  4. Datu paziņošana: Dati netiks paziņoti trešām personām, izņemot juridiskus pienākumus.
  5. Datu glabāšana: datu bāze, ko mitina Occentus Networks (ES)
  6. Tiesības: jebkurā laikā varat ierobežot, atjaunot un dzēst savu informāciju.