Guide pour la bande LED RVB adressable WS2812B avec Arduino

Ce message concerne le DEL WS2812B bande, qui est une bande LED RVB adressable. Les informations contenues dans cet article fonctionnent également avec d’autres bandes LED similaires, telles que les bandes du WS28XX famille, bande Neopixel et autres.

Présentation de la bande LED WS2812B

La bande LED adressable WS2812B est disponible en plusieurs modèles qui diffèrent par la taille, le mastic ou la densité LED. Choisissez celui qui correspond le mieux à vos objectifs.

Où acheter?

Vous pouvez visiter Conseiller fabricant et trouver le Bande LED RVB WS2812B meilleur prix.

Dans la figure suivante, vous pouvez voir ma bande LED WS2812B. Il mesure 5 mètres de long et les LED sont enfermées dans un silicone résistant aux intempéries. Ainsi, ils peuvent être laissés dehors à la pluie et à la poussière sans aucun problème.

À mon avis, c’est le type de bande LED le plus cool. Vous pouvez contrôler le luminosité et le Couleur de chaque LED individuellement, qui vous permet de produire des effets étonnants et complexes de manière simple.

Cette bande LED est composée de LED WS2812B câblées en série. Ces LED ont un IC intégré directement dans la LED. Cela permet une communication via une interface unifilaire. Cela signifie que vous pouvez contrôler beaucoup de LED en utilisant juste une broche numérique de votre Arduino.

Dans la figure suivante, vous pouvez voir la puce à l’intérieur de la LED. La LED est une LED RVB et fonctionne ainsi.

Ce type de bandes est très flexible et peut être coupé à la longueur que vous souhaitez. Comme vous pouvez le voir, la bande est divisée en segments et chaque segment contient une LED RVB.

Vous pouvez ajuster sa taille en coupant la bande avec des ciseaux au bon endroit (les endroits appropriés pour couper la bande sont marqués).

Ces bandes sont livrées avec des connecteurs à chaque extrémité. J’ai décidé de couper les connecteurs et de souder les broches de l’en-tête. C’est plus pratique si vous souhaitez connecter la bande à un Arduino ou à une maquette.

Alimentation de la bande LED WS2812B

La bande LED doit être alimentée à l’aide d’une source d’alimentation 5V. À 5 V, chaque LED consomme environ 50 mA lorsqu’elle est réglée à sa pleine luminosité. Cela signifie que pour 30 LED, la bande peut consommer jusqu’à 1,5 A. Assurez-vous de sélectionner une source d’alimentation qui correspond aux besoins de la bande. Un adaptateur secteur CA vers CC qui fournit 5V et 2A devrait faire le travail :

Si vous utilisez une source d’alimentation externe, n’oubliez pas de connecter la masse de la source d’alimentation à la masse Arduino.

Schémas

Dans cet exemple, la bande LED WS2812B sera alimentée à l’aide de la broche Arduino 5V. Dans mon cas, je contrôle 14 LED. Si vous souhaitez contrôler de nombreuses LED, vous devrez utiliser une source d’alimentation externe.

Utile des astuces:

• Connectez un condensateur avec une capacité comprise entre 100uF et 1000uF de l’alimentation à la terre pour lisser l’alimentation.
• Ajoutez une résistance de 220 ou 470 Ohm entre la broche de sortie numérique Arduino et la broche d’entrée de données de bande pour réduire le bruit sur cette ligne.
• Faites en sorte que vos fils entre l’arduino, l’alimentation et la bande soient aussi courts que possible pour minimiser les pertes de tension.
• Si votre bande est endommagée et ne fonctionne pas, vérifiez si la première LED est cassée. Si c’est le cas, coupez-le, ressoudez les broches de l’en-tête et cela devrait fonctionner à nouveau.

Code

Pour contrôler la bande LED WS2812B, vous devrez télécharger le LED rapide bibliothèque.

Installation de la bibliothèque FastLED

1. Cliquez ici pour télécharger la bibliothèque FastLED. Vous devriez avoir un dossier .zip dans votre dossier Téléchargements
2. Décompressez le dossier .zip et vous devriez obtenir FastLED-mâtdossier r
3. Renommez votre dossier de FastLED-maître à LED rapide
4. Bouge le LED rapide dossier à votre installation Arduino IDE bibliothèques dossier
5. Enfin, rouvrez votre IDE Arduino

Après avoir installé la bibliothèque nécessaire, téléchargez le code suivant sur votre carte Arduino (il s’agit d’un exemple de croquis fourni dans le dossier des exemples de bibliothèque). Aller à Déposer > Exemples > LED rapide > Palette de couleurs ou copiez le code ci-dessous.

#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.

Afficher le code brut

Tu dois changer NUM_LEDS variable au nombre de LED dans votre bande LED. Dans notre exemple, la bande LED a une longueur de 14 LED.

#define NUM_LEDS 14

Si vous souhaitez utiliser une autre broche de l’Arduino pour contrôler la bande LED, vous devez changer le LED_PIN variable:

#define LED_PIN 5

Manifestation

En fin de compte, c’est ce que vous aurez. Des effets étonnants comme celui-ci :

Et celui-là:

Et celui-là:

Et ainsi de suite (…)

Utilisation d’un boîtier de bande LED

Ces bandes LED sont généralement livrées avec un ruban adhésif amovible, afin que vous puissiez les coller où vous le souhaitez. Le problème c’est qu’ils ne collent pas très bien, donc cIl y a de fortes chances que vous trouviez votre bande dans le sol le lendemain.

La solution: J’ai trouvé ce boîtier à bandes qui diffuse bien la lumière et vous pouvez le visser sur une étagère, par exemple, si vous voulez une solution permanente.

Conclusion

Cet article est une introduction à la bande LED RVB adressable avec l’Arduino. Nous venons d’expérimenter avec l’exemple de la bibliothèque. Vous devez modifier l’exemple pour n’afficher que les effets souhaités. Nous espérons que vous avez trouvé ce guide utile.

Si vous aimez ce post, vous aimerez aussi :

Merci d’avoir lu.