---
# System prepended metadata

title: "\U0001F331\U0001F430☀️"

---

# 🌱🐰☀️
Hallo👋, eigentlich geht es ja um die Socken, aber ich hörte dass du auch gerne bastelst. Im Paket ist daher noch eine Weiterbasteloption dabei; ein Blinkedings (das Ding in bubble wrap):

- Blinkt
- Anschluss wie ein Handy-Ladekabel (5V USB-Anschluss bzw Handyladegeräte)

Es handelt sich um sehr niedrige Ströme (5V, <1A, also eigentlich zu niedrig für Funken oder sowas) generell natürlich die Empfehlung sowas nicht tagelang unbeaufsichtigt laufen zu lassen (Stromverbrauch). 

Das Programm ist ein leicht angepasstes Demo-Programm der Fastled-library (Details s.u.). Bin selbst absoluter Coding-Anfänger, ich mag einfach blinkende Lichter, daher nicht über die vielen Kommentare im Code wundern. 

Ich hoffe du hast Freude damit, zumindest mit hoffentlich passenden Socken, und ein sonniges Vostern!

## Bastelideen

- **ohne coding** 
  - in Butterbrot-Tüte, dünnes Papier oä einpacken um das Licht etwas zu dämpfen 
  - zur LED-Matrix ausbauen, Anleitung zB im "GreatScott"-Kanal (braucht etwas Karton und eine matte Acrylglasscheibe oder z.B. Pergamentpapier): https://www.youtube.com/watch?v=D_QBlFIQk-o
  - nach [Tetrapix-Anleitung](https://tetrapix.de/nachmachen/) (mit Tetrapacks und Papier)
 
- **inkl coding**
  - in der fastled library-Dokumentation herausfinden wie man einzelne Pixel ansteuert (hab ich schon wieder vergessen, aber geht) http://fastled.io/ 
  - man kann zB [einen ESP32 anschließen](https://www.youtube.com/watch?v=_0a9JZLGu4M) und mit der Blynk-App oä die LEDs fernsteuern
  - von GreatScott gibt es auch eine schöne [Anleitung zu eigenen Animationen und Pixel art](https://www.youtube.com/watch?v=o6_UYb6I4x4)
   - weitere WS2811-Strips bestellen und das Ganze erweitern? 

# LED-Matrix
Das Ding läuft mit einem Arduino, um das Dings auf ein anderes Pattern anders zu programmieren braucht man 

- ein Mini-USB-Kabel Typ B für den Arduino Nano, so wie [dieses hier](https://www.amazon.de/-/en/gp/product/B07PVWTRFX?pf_rd_r=NRF56V5Q25ZYYY31EEN7) 
- Einen Treiber, denn es ist kein echter Arduino sondern einer der CH340G-Nachbauten
  - [Mac-Treiber](https://kig.re/2014/12/31/how-to-use-arduino-nano-mini-pro-with-CH340G-on-mac-osx-yosemite.html
  - Windows und Linux-Treiber habe ich nicht selbst ausprobiert, [diese](https://www.makershop.de/ch340-341-usb-installieren/) sollten aber funktionieren
- aktuelle Version der [Arduino IDE](https://www.arduino.cc/en/software)
- die [https://github.com/FastLED/FastLED](https://) (lässt sich auch direkt aus dem Arduino-Programm herunterladen) - es empfiehlt sich, vorher erstmal ein paar Arduino-Basics auszuprobieren. Falls du das Demo-Programm ausprobierst, die LEDs sind über Data Pin 10 angeschlossen (das grüne Kabel)
- das unten stehende Programm (im grauen Kasten)

## Code
- Helligkeit anpassen mit dem Wert bei: ```#define BRIGHTNESS         200```
- weitere Anpassungen: Werte ändern bei
  - Fade_Speed
  - Variance_A
  - ggf andere Werte (ich habe nur den Fastled-Democode gefrankensteint)


```csharp=
#include "FastLED.h"
// FastLED library from
// https://github.com/FastLED/FastLED
FASTLED_USING_NAMESPACE

// Based on FastLED "100-lines-of-code" demo reel from Mark Kriegsmann
// https://github.com/FastLED/FastLED/tree/master/examples/DemoReel100

#if defined(FASTLED_VERSION) && (FASTLED_VERSION < 3001000)
#warning "Requires FastLED 3.1 or later; check github for latest code."
#endif

// define data pins here
#define DATA_PIN    10
// define number of LEDs
#define NUM_LEDS    16
#define LED_TYPE    WS2811
#define COLOR_ORDER GRB

CRGB leds[NUM_LEDS];

#define BRIGHTNESS         200
// #define FRAMES_PER_SECOND
int FRAMES_PER_SECOND = 7; // 1-255 = Geschwindigkeit wie die punkte erscheinen

// confetti-effect
int FADE_SPEED = 35; // 255: Punkte blinken nur kurz auf / 1 : punkte bleiben lange
int VARIANCE_A = 25 ; // Varianz (0-255) - default: 64


// hier werden die Einstellungen gelesen, wenn der Arduino startet
void setup() {

  delay(1000); // 3 second delay for recovery
  
  // tell FastLED about the LED strip configuration
  FastLED.addLeds<LED_TYPE,DATA_PIN,COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);
  
  // set master brightness control
  FastLED.setBrightness(BRIGHTNESS);
}


// List of patterns to cycle through.  Each is defined as a separate function below.
typedef void (*SimplePatternList[])();

// define patterns here, e.g. (full list):
// SimplePatternList gPatterns = { rainbow, rainbowWithGlitter, confetti, sinelon, juggle, bpm };
SimplePatternList gPatterns = {confetti};

uint8_t gCurrentPatternNumber = 0; // Index number of which pattern is current
uint8_t gHue = 0; // rotating "base color" used by many of the patterns


// hier ist die main loop des Programms, dieser Code läuft immer wieder von vorne
void loop()
{ 
  // Call the current pattern function once, updating the 'leds' array
  gPatterns[gCurrentPatternNumber]();

  // send the 'leds' array out to the actual LED strip
  FastLED.show();  
  // insert a delay to keep the framerate modest
  FastLED.delay(1000/FRAMES_PER_SECOND); 

  // do some periodic updates
  EVERY_N_MILLISECONDS( 20 ) { gHue++; } // slowly cycle the "base color" through the rainbow

  // check if button pressed
  if (digitalRead(3) == LOW) {
    // if button pressed, switch pattern
    nextPattern();
    }
  
  //EVERY_N_SECONDS( 10 ) { nextPattern(); } // change patterns periodically
}

#define ARRAY_SIZE(A) (sizeof(A) / sizeof((A)[0]))

void nextPattern()
{
  // add one to the current pattern number, and wrap around at the end
  gCurrentPatternNumber = (gCurrentPatternNumber + 1) % ARRAY_SIZE( gPatterns);
}




// der Confetti-Effekt (das Blinken) wird hier definiert
void confetti() 
{
  // random colored speckles that blink in and fade smoothly
  fadeToBlackBy( leds, NUM_LEDS, FADE_SPEED); 
  int pos = random16(NUM_LEDS);
  leds[pos] += CHSV( gHue + random8(VARIANCE_A), 200, 255); // (Varianz), ?, ?
}

// weitere Effekte werden hier gesetzt
// diese müssen aber in der SimplePatternList definiert sein
void rainbow() 
{
  // FastLED's built-in rainbow generator
  fill_rainbow( leds, NUM_LEDS, gHue, 7);
}

void rainbowWithGlitter() 
{
  // built-in FastLED rainbow, plus some random sparkly glitter
  rainbow();
  addGlitter(80);
}

void addGlitter( fract8 chanceOfGlitter) 
{
  if( random8() < chanceOfGlitter) {
    leds[ random16(NUM_LEDS) ] += CRGB::White;
  }
}

void sinelon()
{
  // a colored dot sweeping back and forth, with fading trails
  fadeToBlackBy( leds, NUM_LEDS, 20);
  int pos = beatsin16(13,0,NUM_LEDS);
  leds[pos] += CHSV( gHue, 255, 192);
}

void bpm()
{
  // colored stripes pulsing at a defined Beats-Per-Minute (BPM)
  uint8_t BeatsPerMinute = 62;
  CRGBPalette16 palette = PartyColors_p;
  uint8_t beat = beatsin8( BeatsPerMinute, 64, 255);
  for( int i = 0; i < NUM_LEDS; i++) { //9948
    leds[i] = ColorFromPalette(palette, gHue+(i*2), beat-gHue+(i*10));
  }
}

void juggle() {
  // eight colored dots, weaving in and out of sync with each other
  fadeToBlackBy( leds, NUM_LEDS, 20);
  byte dothue = 0;
  for( int i = 0; i < 8; i++) {
    leds[beatsin16(i+7,0,NUM_LEDS)] |= CHSV(dothue, 200, 255);
    dothue += 32;
  }
 }
 ```