WS2812B: רצועת ה- LED הקסומה

אין ספק שאתה צריך להוסיף מגע של צבעים לפרויקטים שלך בעיצוב DIY. לשם כך, יצרנים רבים משתמשים במפורסמים רצועות LED RGB WS2812B, בעזרתו ניתן לקבל בקרת צבע מגוונת ואפקטים תאורה אטרקטיביים למדי עבור הפרויקטים שלך. כמובן שהם רצועות התואמות לחלוטין את לוחות הארדואינו, כך שלא תהיה לך שום בעיה כשאתה מנסה לשלב אותם.

אתה יכול למצוא אותם ב אורכים של מטר אחד, למשל, אם כי הם יכולים להשתנות בהתאם לסוג הצפיפות של נוריות LED לכל מטר שיש להם. לדוגמא, ישנם מ 30 נוריות ל 144 נוריות. עם זאת, אם אתה זקוק לאורכים ארוכים יותר כדי להשיג משטח גדול יותר, יש לך גם אפשרויות אחרות בשוק כגון לוחות LED RGB או שתמיד תוכל להשתמש במספר רצועות ...

הרצועות האלה אינן יותר מ סדרת נוריות RGB מורכבות והותקן על תמיכה משותפת כדי לקבץ אותם לרצועות. אך פעולתו זהה לנורות ה- RGB הנפרדות.

• מידע נוסף על נוריות RGB

מהו WS2812B?

למעשה ה- WS2812B אינו הרצועה עצמה, אלא כל אחד מהם התאים או לוחות RGB LED קטנים הכוללים. הם יכולים להיות מקובצים בצורה של רצועה או פאנל, כך שתוכלו לבצע תצורות שונות מבחינת מספרם וצורתם. הרצועות המרכיבות הן רצועות גמישות, אך ניתן למצוא WS2812B גם על לוחות PCB שאינם.

אם תרצה, תוכל למצוא את המכשירים WS2812B בנפרד כדי ליצור את הצורות שאתה צריך בעצמך. לדוגמא, כ 100 יחידות מהן בדרך כלל עולות מעט יותר מ € 10.

אתה צריך גם לדעת שאתה זורק אותם אתה יכול לחתוך אותם עם מספריים בכל מקום שאתה צריך, זה לא מרמז שהם מפסיקים לעבוד. אז אתה יכול לקבל רק את נוריות ה- RGB שאתה צריך. למעשה, יש בו כמה סימונים (שלוש רפידות נחושת) שתוכלו לחתוך דרכם. אם אתה חותך את הרפידות הללו, יהיו לך שלושה רצועות בצד אחד של הרצועה ובצד השני למקרה שתרצה לעשות שימוש חוזר בחלקים האחרים, בהם תוכל להלחין את הפינים לחיבור קל.

Pinout וגליון נתונים

זהו תא WS2812B עצמאי עם הכניסות והפלטים שלו

למידע נוסף אודות שלך רצועת LED RGB WS2812B אתה יכול לקרוא גליון הנתונים המוצעים על ידי כל יצרן, שם תוכלו להתייעץ עם כל פרטי הממדים והמאפיינים הטכניים בכדי לדעת כיצד להשתמש בהם כראוי, בנוסף להכרת כל טווחי ההפעלה והמגבלות.

• הורד את גיליון הנתונים WS2812B

באשר ל pinoutזו גם לא בעיה עיקרית, לרצועות האלה יש חיבור פשוט שתוכלו לשלוט בו מההתחלה בלי יותר מדי ידע. ישנם רק שלושה זמינים, אם כי לכל תא WS2812B למעשה יש יותר חיבורים ...

אתה פשוט חייב להתחבר על כל רצועה סיכת ה- Vcc שמאכילה את הרצועה ל- 5V מארדואינו או מאספקת חשמל אחרת, GND לקרקע, כמובן, ולבסוף ה- DI שהוא השני שיעבור לכל פלט של המיקרו-בקר כדי להפעיל את נוריות RGB ברצועה.

אם אתה מסתכל על תא WS2812B תראה שיש בו את כניסת ה- Data In או DI, ואת ספק הכוח Vcc ו- GND. ואז יהיו לו שלוש יציאות אחרות, אלה יחוברו לתא הבא של הרצועה, ולתא הבא יהיו היציאות שלו מחוברות לקלט של הבא וכן הלאה עד להשלמת הרצועה כולה ...

זה בדיוק זה DI או קלט נתונים זה שמעניין להגדיר את נוריות ה- RGB, ואותו אחד יתחבר ל- Data Out או DO שייקח את אותו מידע לקישור הבא ברצועה. וכך הוא מתפשט בכל הרצועה.

קנה רצועות LED WS2812B RGB

אתה יכול לקנות במחיר לא גבוה מדי בחנויות מתמחות שונות. יש לך אותם גם באמזון בפורמטים שונים. חלק מהדוגמאות הן:

• רצועות LED RGB WS2812B של 60 נוריות / מ '.
• רצועות LED RGB WS2812B של 100 נוריות / מ '.
• רצועות LED RGB WS2812B של 144 נוריות / מ '.
• WS2812B RGB LED רצועות של 5 מטר של 30 נוריות.
• WS2812B RGB LED רצועות של 5 מטר של 60 נוריות.
• לוח WS2812B
• סליל 5 מטר של נוריות RGB.

בדיקות עם Arduino ו- WS2812B

כפי שאתה יכול לדמיין, עם שלושה סיכות בלבד זה קל מאוד להתחבר לארדואינו כפי שניתן לראות בתרשים לעיל. אתה רק צריך לחבר 5v ו- GND לרצועת WS2812B, ואת ה- DI ליציאה שאתה רוצה בארדואינו. זכור שאם אתה משנה את הסיכה שלך, עליך לשנות את קוד המקור כך שהתוכנית תפעל כראוי.

באשר ל קוד סקיצה, זה יכול להיות די פשוט כמו הקוד הבא. אם אינך רוצה להעתיק ולהדביק, תוכל למצוא זאת בין הדוגמאות שמגיעות כבר. אז עבור אל קובץ> דוגמאות> 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.