WS2812B: la bande LED RVB magique

Bande LED RVB WS2812B

Vous devez sûrement ajouter une touche de couleur à vos projets de bricolage. Pour cela, de nombreux fabricants utilisent le célèbre Bandes LED RVB WS2812B, pour obtenir un contrôle des couleurs varié et des effets d'éclairage assez attrayants pour vos projets. Bien sûr, ce sont des bandes entièrement compatibles avec les cartes Arduino, vous n'aurez donc aucun problème en essayant de les intégrer.

Vous pouvez les trouver dans longueurs de 1 mètre, par exemple, bien qu'ils puissent varier en fonction du type de densité de LED pour chaque compteur dont ils disposent. Par exemple, il y a de 30 LED à 144 LED. Cependant, si vous avez besoin de plus grandes longueurs pour obtenir une plus grande surface, vous avez également d'autres options sur le marché comme des panneaux LED RVB ou vous pouvez toujours utiliser plusieurs bandes ...

Ces bandes ne sont rien de plus que une série de LED RVB assemblées et montés sur un support commun pour les regrouper en bandes. Mais son fonctionnement est identique à celui des LED RVB séparées.

Qu'est-ce que WS2812B?

Bande LED éclairée RGB WS2812B

En fait, le WS2812B n'est pas la bande elle-même, mais chacun des les cellules ou de petites plaques LED RVB qui comprennent. Ils peuvent être regroupés sous la forme d'une bande ou d'un panneau, vous pouvez donc effectuer différentes configurations en fonction de leur nombre et de leur forme. Les bandes qui composent sont des bandes flexibles, mais vous pouvez également trouver WS2812B sur des panneaux PCB qui ne le sont pas.

Si vous le souhaitez, vous pouvez trouver les appareils WS2812B séparément pour créer vous-même les formes dont vous avez besoin. Par exemple, environ 100 unités coûtent généralement un peu plus de 10 €.

coupe de bande led rgb

Vous devez également savoir que vous les lancez tu peux les couper avec des ciseaux partout où vous en avez besoin, cela n'implique pas qu'ils cessent de fonctionner. Vous ne pouvez donc avoir que les LED RVB dont vous avez besoin. En fait, il a quelques marques (trois pastilles de cuivre) que vous pouvez couper. Si vous coupez ces pastilles, vous aurez trois pistes d'un côté de la bande et de l'autre au cas où vous voudriez réutiliser les autres pièces, vous pourrez y souder les broches pour une connexion facile.

Brochage et fiche technique

WS2812B dans une cellule simple

C'est une cellule WS2812B indépendante avec ses entrées et sorties

Pour plus d'informations sur votre Bande LED RVB WS2812B tu peux lire la fiche technique proposés par chaque constructeur, vous pouvez y consulter tous les détails de dimensions et caractéristiques techniques pour savoir comment les utiliser correctement, en plus de connaître toutes les plages et limites de fonctionnement.

Quant à brochageCe n'est pas non plus un problème majeur, ces bandes ont une connexion simple que vous pouvez maîtriser dès le départ sans trop de connaissances. Il n'y en a que trois disponibles, bien que chaque cellule WS2812B ait en fait plus de connexions ...

Vous devez simplement conectar sur chaque bande la broche Vcc qui alimente la bande au 5V d'Arduino ou d'une alimentation différente, le GND à la terre, bien sûr, et enfin la DI qui est l'autre qui ira à n'importe quelle sortie du microcontrôleur pour activer le LED RVB sur la bande.

Si vous regardez une cellule WS2812B Vous verrez qu'il dispose de l'entrée Data In ou DI et de l'alimentation Vcc et GND. Ensuite, il aura trois autres sorties, celles-ci seront connectées à la cellule suivante de la bande, et la cellule suivante aura ses sorties connectées à l'entrée de la suivante et ainsi de suite jusqu'à ce que la bande entière soit terminée ...

C'est justement ça DI ou entrée de données celui qui est intéressant pour configurer les LED RVB, et ce même sera connecté à Data Out ou DO qui portera ces mêmes informations au lien suivant dans la bande. Et ainsi il se répand dans toute la bande.

Acheter des bandes LED RVB WS2812B

Rouleau de bande LED RVB

Vous pouvez acheter à un prix pas trop élevé dans divers magasins spécialisés. Vous les avez également sur Amazon dans différents formats. Quelques exemples sont:

Test avec Arduino et WS2812B

Arduino UNO avec schéma WS2812B

Comme vous pouvez l'imaginer, avec seulement trois broches, il est très facile de se connecter à arduino comme vous pouvez le voir dans le diagramme ci-dessus. Il vous suffit de connecter 5v et GND à la bande WS2812B et la DI à une sortie que vous voulez sur Arduino. N'oubliez pas que si vous modifiez votre code PIN, vous devez également modifier le code source pour que le programme fonctionne correctement.

La bibliothèque a été utilisée Maître FAST-LED pour faciliter les choses et obtenir des fonctions simples pour piloter les LED RVB. Pour le télécharger et l'intégrer correctement dans l'IDE Arduino, téléchargez simplement la bibliothèque à partir de ce lien, puis décompressez le ZIP et renommez le répertoire ou dossier décompressé en FastLED, puis déplacez ce dossier vers l'emplacement où les bibliothèques IDE Arduino sont installées dans votre installation . Ensuite, rouvrez l'IDE Arduino et il sera prêt ...

Quant à code d'esquisse, cela peut être assez simple comme le code suivant. Si vous ne souhaitez pas copier et coller, vous pouvez le trouver parmi les exemples déjà fournis. Allez donc dans Fichier> Exemples> FastLED> ColorPalette.

N'oubliez pas de changer la broche 14 de l'exemple en 5 qui est celle que j'ai utilisée dans le diagramme. Ou vous pouvez vous connecter à la broche 14 et éviter de modifier le code. Comme vous préférez.
#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.



Soyez le premier à commenter

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont marqués avec *

*

*

  1. Responsable des données: Miguel Ángel Gatón
  2. Finalité des données: Contrôle du SPAM, gestion des commentaires.
  3. Légitimation: votre consentement
  4. Communication des données: Les données ne seront pas communiquées à des tiers sauf obligation légale.
  5. Stockage des données: base de données hébergée par Occentus Networks (EU)
  6. Droits: à tout moment, vous pouvez limiter, récupérer et supprimer vos informations.