LED Schmetterlinge

Die Schmetterlinge bestehen aus fünf Bauteilen. Zwei Bauteile aus Holzpappe, vier LEDs, einem Arduino Nano und einer Front aus dem Stiftplotter. Außerdem werden drei unterschiedlich farbige Litzen, ein Lötgerät + Lötzinn, Holzleim und eine Heißklebepistole benötigt. Alles findest du auch bei uns im Maker Space vorrätig.

Material	Menge	Quelle	Bild
Oberteil	1 Stk	Lasercutter
Unterteil	1 Stk	Lasercutter
WS2812	4 Stk
Arduino Nano	1 Stk
Litze	3 Farben
Front		Geplottetes Papier, ausgeschnitten (Siehe Stiftplotter)

Grundwissen zu den Bauteilen

Die Bauteile aus Holzpappe sind mit einem Laser Cutter geschnitten. Das Material lässt sich einfach verarbeiten und super mit Holzleim verkleben. Allerdings ist es auch sehr anfällig für Feuchtigkeit und geht beim Kontakt mit Wasser sehr schnell kaputt.

Die Front ist mit Hilfe des Stiftplotters hergestellt. Mit diesem Gerät können Vektorgrafiken mit beliebigen Stiften gezeichnet werden.

Bei den LEDs handelt es sich um addressierbare WS2812 LEDs. Das bedeutet, dass alle LEDs über ein Datensignal eine Farbe geschickt bekommen können und dann in dieser Farbe leuchten. Das Signal besteht dabei aus einer langen Kette von Zahlen zwischen 0 und 255. Die erste LED nimmt sich dann die ersten drei dieser Zahlen aus der Kette und schickt den Rest an die nächste LED weiter. Die drei Zahlen stehen dabei für den Helligkeitswert der Farbe Rot, Grün und Blau.

Ein Arduino Nano ist ein günstiger Microcontroller. Details dazu findest du hier

Zusammenbauen

Zuerst müssen das Ober- und das Unterteil verklebt werden. Beide Teile sollten deckungsgleich aufeinander passen. Als Kleber eignet sich hier Holzleim hervorragend. Am Besten ist, ihr verteilt den Leim auf die dünnen Träger des Unterteils und setzt dann das Oberteil drauf..

• 

• 

Als nächstes können die vier LEDs in die vorgesehenen Aussparungen auf der Rückseite eingesetzt werden. Dabei sollten die Pfeile auf den LEDs sichtbar sein und von links nach rechts zeigen. Wenn die LEDs noch zusammen hängen, können sie vorsichtig auseinander gebrochen werden.

Jetzt können wir die LEDs mit einem Tropfen Heißkleber an ihrer Position fixieren. Dabei sollte der Heißkleber nur an der Seite und nicht auf die LED selbst kommen.

Danach werden die Pads auf den LEDs verzinnt. Dazu nehmen wir einen Lötkolben und erhitzen das Lötpad vorsichtig, bis das Zinn auf dem Pad schmilzt. Das Zinn sollte möglichst gleichmäßig verlaufen und einen leichten Hügel bilden.

Als nächstes wird der Anfang der roten Litze abisoliert und verzinnt. Wenn das verzinnte Ende zu lang ist, einfach mit einem Seitenschneider abknipsen.

Das verzinnte Ende wird auf das oberste Pad der ersten LED gehalten und kurz mit dem Lötkolben erhitzt bis das Zinn schmilzt. Danach wird der Lötkolben wieder entfernt und das Zinn kann abkühlen. Die Litze ist jetzt an dem Pad angelötet.

Die Litze kann jetzt auf die passende Länge abgeschnitten, abisoliert und verzinnt werden. Danach wird sie an das obere linke Pad der LED gelötet. Genauso wie diese Litze zwischen die ersten beiden LEDs gelötet wurde, werden nun zwei weitere Litzen zwischen die anderen LEDs gelötet. Zum Schluss sollten alle 5V-Pads miteinander verbunden sein.

Genau wie die 5V Pads, müssen jetzt die gnd-Pads verbunden werden.

Die mittleren Pads sind die Daten-Pins. Hier ist es wichtig, dass sie in der richtigen Reihenfolge von links nach rechts verbunden werden.

Wenn alle Pads zwischen den LEDs verbunden sind, muss an die erste LED noch die Litze für den Microcontroller angelötet werden. Dafür verwenden wir ein ca 30cm langes Stück.

Am Microcontroller muss 5V an den Pin Vin/VCC – hier liegt die Spannungsversorgung des USB-Netzteils an. Außerdem muss das gnd-Pad der LED mit dem gnd-Pad des Microcontrollers verbunden werden.

Die Litze des Daten-Pins muss an den Digitalpin 5 angeschlossen werden. Es kann auch jeder andere Digitalpin verwendet werden, allerdings muss der Pin dann auch im Code geändert werden.

Den Microcontroller programmieren

Als nächstes müssen wir den MicroController programmieren. Wir haben bereits einen Beitrag, wie du den Einstieg findest und bei dir auf dem Rechner alles installieren und einrichten kannst. Diesen Beitrag solltest du dir nun durchlesen und alles einrichten.

Zum Beitrag über Microcontrollerprogrammierung

Projekt anlegen

Als erstes müssen wir uns ein neues Projekt in PlatformIO anlegen. Dazu können wir in Visual Studio Code unten auf das “Haus” Icon von PlatformIO klicken und dort ein neues Projekt erstellen. Sobald alles erstellt ist haben wir links im File

Für unseren Schmetterling verwenden wir eine Bibliothek mit dem Name FastLED. Diese Bibliothek müssen wir in unser Projekt installieren. Dazu gehen wir in der PlatformIO Home Ansicht links auf Libraries und geben dort in die Suche “FastLED” ein.

Nachdem wir auf den Eintrag in der Liste geklickt haben, können wir oben den Punkt “Zum Projekt hinzufügen” auswählen und damit die Bibliothek installieren.

Der Code für den Schmetterling ist eine angepasste Version des FastLED Demo Code verwedet. Der Code kann von hier komplett herunter geladen und verwendet werden. Details zum Progammieren findet ihr in dem oben verlinkten Artikel über Arduino und PlatformIO.

#include <Arduino.h>

#include <FastLED.h>

#define LED_PIN     5
#define NUM_LEDS    8
#define BRIGHTNESS  255
#define LED_TYPE    WS2811
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

#define UPDATES_PER_SECOND 20

// 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 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;
    }
}




// 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
};



// Additional 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.


// 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; }
    }
}

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);
}