1. Der Betrieb von Leuchtdioden
1.1 Eine Led auf dem MEGA-Board blinken lassen
Verwendetes Material:
1x Arduino MEGA Platine
Dazu auf der Elegoo-CD bzw. im PDF die Seite "Lektion 2 Blinken" finden.
Hier wird auf einfachster Weise die interne gelbe/grüne/rote Led auf dem MEGA-Board durch
einen simplen Programmcode zum Blinken gebracht.
Einfach den Programmschritten laut Anleitung folgen.
Wichtig: Laut Anleitung das MEGA-Board auswählen am richtigen COM-Port!
Der Programmcode:
void setup() {
// Es wird ein digitaler pin mit Namen "LED_BUILTIN" als output generiert
// es ist die interne Led auf dem MEGA-Board
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
digitalWrite(LED_BUILTIN, HIGH); //schaltet die LED on
delay(1000); // wartet 1000ms
digitalWrite(LED_BUILTIN, LOW); // schaltet die LED off
delay(1000); // wartet 1000ms
}
Durch Laden Programms auf das MEGA-Board sollte nun eine grüne Led im 2-Sekundentakt blinken.
Die Led schneller oder langsamer blinken lassen
Durch Variation des xxx Wertes beim Delay(xxx); wird die Zeit geändert.
z.B. 50ms on, 950ms off ergibt einen kurzen Stroboskop-Blitzer.
1.2 Eine Led auf dem Bread-Board blinken lassen
Verwendetes Material:
1x Arduino MEGA Platine
1x Breadboard
1x Led5mm rot oder andere Farbe
1x Widerstand 220-470 Ohm
1x langer schwarzer Draht (GND)
1x langer Draht
Auf dem Foto unten wird eine rote Led mit Vorwiderstand 330Ohm aus dem Kit verwendet. der Vorwiderstand wird mit der Anode der Led verbunden und auf PIN 7 des MEGAs gehängt. Die Kathode der Led auf GND.
Mit folgendem Code sollte die Led blinken:
Der Programmcode:
#define LED 7 // Eine Variable Led an Pin 7
void setup() {
// initialisiere digital pin LED als output.
pinMode(LED , OUTPUT);
}
void loop() {
digitalWrite(LED , HIGH);//Led ON
delay(500); // 500ms warten
digitalWrite(LED , LOW);// LED Off
delay(500); // 500ms warten
}
Durch Laden Programms auf das MEGA-Board sollte nun die rote Led auf dem Bread-Board im Sekundentakt blinken.
1.3 Leds immer ohne delay() betreiben
->"Blink without delay"
Ein großes Problem beim Verwenden des Befehls delay() ist die Wartezeit. Das Programm wartet tatsächlich z.B. 1000ms bis es in die nächste Programmzeile springt.
Damit werden Programme langsam und es wäre so nie eine schnelle Kommunikation z.B. mit einem Modul oder Display möglich.
Mit dem Programm "Blink without delay" werden diese lästigen Wartezeiten vernichtet.
Ich verwende als Quelle:
https://www.arduino.cc/en/Tutorial/BuiltInExamples/BlinkWithoutDelay
Die Schaltung bleibt die gleiche!
Hier der Programmcode:
const int ledPin = 7; // wieder Pin 7 als Led
int ledState = LOW; // ledState für das Setzen der LED
unsigned long previousMillis = 0; // setzt die Variable previousMillis auf 0 zum starten
const long Interval = 100; // Blinkzeit
void setup() {
pinMode(ledPin, OUTPUT); //Setzt Ledpin als Output
}
void loop() {
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= Interval) {
previousMillis = currentMillis;
if (ledState == LOW) {
ledState = HIGH;
} else {
ledState = LOW; //Led geht aus und An
}
digitalWrite(ledPin, ledState);
// Mit digitalWrite wird der Ledstatus auf den Pin 7
// rausgeschrieben. damit geht Pin 7 an und aus
}
}
Damit sollte die Led wieder blinken, aber ohne delay(). Durch Variieren der Zahl "Interval" wird die Led schneller oder langsamer blinken.
1.31 Die pulsierende Led
Mittels eines kurzen Codes kann man eine Led pulsieren lassen - z.B. für Statusanzeigen.
Es bleibt der Aufbau mit einer Led auf Pin 7.
Hier der Programmcode:
const int LED = 7;
float Interval = 0.0005; // Blinkzeit
void setup()
{
}
void loop()
{
float in, out;
for (in = 0; in < 6.283; in = in + Interval)
{
out = sin(in) * 127.5 + 127.5;
analogWrite(LED,out);
}
}
Mit diesem Code sollte nun die Led blinken wie im Bild unten (Farbe kann beliebig geändert werden!
1.4 Ein RGB-Farbenspiel mit 3 fix programmierten Farben
Verwendetes Material:
1x Arduino MEGA Platine
1x Breadboard
1x Led5mm RGB COMMON CATHODE
3x Widerstand 220-470 Ohm
1x langer schwarzer Draht
3x kurzer Draht
Bitte im PDF Lektion 4 RGB Led finden.
Mit der im Kit enthaltenen RGB Led mit COMMON GND lässt sich eine RGB-Led realisieren. Mit dem folgenden Programmcode wird ein Farbwechsel erzeugt.
Wichtig: Am Foto ist ein rotes, grünes und blaues Kabel angeschlossen.
Das rote Kabel an Pin 7, das grüne an Pin 8 und das blaue an Pin 9.
Durch richtiges Einstecken der Led wird jede Farbe richtig angesteuert.
Die abgeflachte Seite der Led zeigt zum roten Kabel.
Mit dem folgenden Code startet das Farbenspiel.
Hier der Programmcode - als Beispiel mit 3 verschiedenen Farben:
const int PIN_RED = 7;
const int PIN_GREEN = 8;
const int PIN_BLUE = 9;
void setup() {
pinMode(PIN_RED, OUTPUT);
pinMode(PIN_GREEN, OUTPUT);
pinMode(PIN_BLUE, OUTPUT);
}
void loop() {
// color code #00C9CC (R = 0, G = 201, B = 204)
analogWrite(PIN_RED, 120);
analogWrite(PIN_GREEN, 100);
analogWrite(PIN_BLUE, 0); //Gelb
delay(1000); // Farbe bleibt 1 Sekunde
// color code #F7788A (R = 247, G = 120, B = 138)
analogWrite(PIN_RED, 50);
analogWrite(PIN_GREEN, 150);
analogWrite(PIN_BLUE, 80); //Türkis
delay(1000); // Farbe bleibt 1 Sekunde
// color code #34A853 (R = 52, G = 168, B = 83)
analogWrite(PIN_RED, 100);
analogWrite(PIN_GREEN, 0);
analogWrite(PIN_BLUE, 100); //Pink
delay(1000); // Farbe bleibt 1 Sekunde
}
1x pro Sekunde wird nun zwischen 3 Farben gewechselt.
Im Foto unten sieht man den Aufbau und die 3 Farben.
1.5 Ein RGB-Farbenspiel mit endlosem automatischen
Farbwechsel
Mit dem folgenden Programmcode programmiert man einen endlosen automatischen Farbwechsel.
Hier der Programmcode :
//Konstanten
const int rotPin = 7; // Rote LED an Pin 10 angeschlossen
const int gruenPin = 8; // Gruene LED an Pin 9 angeschlossen
const int blauPin = 9; // Blaue LED an Pin 11 angeschlossen
//Variablen
byte r = 0; // Variable Rot für die Farbmischung
byte g = 0; // Variable Grün für die Farbmischung
byte b = 0; // Variable Blau für die Farbmischung
char farbe = 'b'; // Buchstabe für die aktuelle Farbe (Blau)
int fadePause = 8; // Zeit für die Fadeschritte. Kleiner = schnell, größer = langsam
int halteZeit = 500; // Zeit die zwischen den Farben pausiert wird
unsigned long fadeZeit = 0; // Variable für das Speichern der aktuellen millis()
boolean ersterLauf = true; // Wird benötigt um den ersten Durchlauf des Programms zu erkennen
void setup()
{
pinMode(rotPin, OUTPUT); // Setzt LEDPin als Ausgang
pinMode(gruenPin, OUTPUT); // Setzt LEDPin als Ausgang
pinMode(blauPin, OUTPUT); // Setzt LEDPin als Ausgang
}
void loop()
{
// Blaue LED beim ersten Durchlauf einblenden
if (ersterLauf == true && millis()- fadeZeit > fadePause)
{
// Wenn b kleiner als 255 ist...
if (b < 255)
{
b++; // Zählt b um 1 hoch
analogWrite(blauPin, b); // Ausgabe von b am LED Pin
fadeZeit = millis(); // Aktuelle Zeit speichern
}
// Wenn b bei 255 angekommen UND die halteZeit vergangen ist...
if (b == 255 && (millis()- fadeZeit) > (fadePause + halteZeit))
{
ersterLauf = false; // Erster Lauf ist abgeschlossen
}
}
// Wenn ersterLauf abgeschlossen ist UND fadePause vergangen ist...
if (ersterLauf == false && millis()- fadeZeit > fadePause)
{
// Wechsel von Blau zu Lila
if (farbe == 'b')
{
// Wenn r kleiner als 255 ist...
if (r < 255)
{
r++; // Zählt r um 1 hoch
analogWrite(rotPin, r); // Ausgabe von r am LED Pin
fadeZeit = millis(); // Aktuelle Zeit speichern
}
// Wenn r bei 255 angekommen UND die halteZeit vergangen ist...
if (r == 255 && millis()- fadeZeit > fadePause + halteZeit)
{
farbe = 'l'; // Ändere Farbe auf "l" (Lila)
}
}
// Wechsel von Lila zu Rot
if (farbe == 'l')
{
// Wenn b größer als 0 ist...
if (b > 0)
{
b--; // Zählt b um 1 runter
analogWrite(blauPin, b); // Ausgabe von b am LED Pin
fadeZeit = millis(); // Aktuelle Zeit speichern
}
// Wenn b bei 0 angekommen UND die halteZeit vergangen ist...
if (b == 0 && millis()- fadeZeit > fadePause + halteZeit)
{
farbe = 'r'; // Ändere Frabe auf "r" (Rot)
}
}
// Wechsel von Rot zu Gelb
if (farbe == 'r')
{
// Wenn g kleiner als 255 ist...
if (g < 255)
{
g++; // Zählt g um 1 hoch
analogWrite(gruenPin, g); // Ausgabe von g am LED Pin
fadeZeit = millis(); // Aktuelle Zeit speichern
}
// Wenn g bei 255 angekommen UND die halteZeit vergangen ist...
if (g == 255 && millis()- fadeZeit > fadePause + halteZeit)
{
farbe = 'y'; // Ändere Farbe auf "y" (Gelb)
}
}
// Wechsel von Gelb zu Gruen
if (farbe == 'y')
{
// Wenn r größer als 0 ist...
if (r > 0)
{
r--; // Zählt r um 1 runter
analogWrite(rotPin, r); // Ausgabe von r am LED Pin
fadeZeit = millis(); // Aktuelle Zeit speichern
}
// Wenn r bei 0 angekommen UND die halteZeit vergangen ist...
if (r == 0 && millis()- fadeZeit > fadePause + halteZeit)
{
farbe = 'g'; // Ändere Farbe auf "g" (Grün)
}
}
// Wechsel von Gruen zu Petrol
if (farbe == 'g')
{
// Wenn b kleiner als 255 ist...
if (b < 255)
{
b++; // Zählt b um 1 hoch
analogWrite(blauPin, b); // Ausgabe von b am LED Pin
fadeZeit = millis(); // Aktuelle Zeit speichern
}
// Wenn b bei 255 angekommen UND die halteZeit vergangen ist...
if (b == 255 && millis()- fadeZeit > fadePause + halteZeit)
{
farbe = 'p'; // Ändere Farbe auf "p" (Petrol)
}
}
// Wechsel von Petrol zu Blau
if (farbe == 'p')
{
// Wenn g größer als 0 ist...
if (g > 0)
{
g--; // Zählt g um 1 runter
analogWrite(gruenPin, g); // Ausgabe von g am LED Pin
fadeZeit = millis(); // Aktuelle Zeit speichern
}
// Wenn g bei 0 angekommen UND die halteZeit vergangen ist...
if (g == 0 && millis()- fadeZeit > fadePause + halteZeit)
{
farbe = 'b'; // Ändere Farbe auf "b" (Blau)
}
}
}
}
Mit diesem Code sollte nun unendlich lang die Farbe wechseln.
1.6 Ansteuerung von WS2812 RGB-Ledstreifen
Verwendetes Material:
1x Arduino MEGA Platine
1x Breadboard
1x WS2812 RGB Ledstrip (hier 20 Leds ins Serie)
1x Doppel-Tastermodul
1x langer roter Draht (+5V)
1x kurzer roter Draht (+5V)
3x kurzer schwarzer Draht (GND)
3x kurzer Draht
WS2812-RGB Ledstreifen gibt es z.B. bei Amazon mit 1-10m Länge. Die verwendeten RGB-Leds haben einen internen Chip eingebaut. Über ein serielles Signal (Schieberegister) kann man jeder Led einzeln Farbe und Helligkeit zuspielen. So kann z.B. eine Bar-Beleuchtung oder einfach eine Signalanzeige realisiert werden.
Mit folgendem Programmcode kann mittels des 2-Tasten-Moduls aus dem Elegoo-Kit ein RGB-Ledstreifen angesteuert werden.
Mit Taste 1 kann man verschiedene Farben durchschalten.
Mit Taste 2 wird der RGB-Farbverlauf gestartet.
!!Achtung: Library "Adafruit_NeoPixel.h" muss über die Arduino-IDE->Tools->Manage Libraries... gesucht und installiert werden.
Hier der Programmcode:
#include <Adafruit_NeoPixel.h>
#define BUTTON_FIXFARBE 8 // Taste zum Schalten der Fixfarbe
#define BUTTON_FARBWECHSEL 9 // Taste zum Schalten des Farbwechses
#define PIXEL_PIN 7 // Digital Pin
int numPixels = 20; // Anzahl der verwendeten LEds
int Helligkeit = 150; //Helligkeit des Strips
int wait = 10; //Verzögerung des Farbwechels
Adafruit_NeoPixel strip = Adafruit_NeoPixel(numPixels, PIXEL_PIN, NEO_GRB + NEO_KHZ800);
bool oldStateFIX = HIGH;
int showTypeFIX = 0;
bool oldStateRGB = HIGH;
int showTypeRGB = 0;
void setup() {
pinMode(BUTTON_FIXFARBE, INPUT_PULLUP);
pinMode(BUTTON_FARBWECHSEL, INPUT_PULLUP);
strip.begin();
strip.show(); // Initialisierung aller pixels 'off'
}
void loop() {
// Tasterabfrage
bool newStateFIX = digitalRead(BUTTON_FIXFARBE);
bool newStateRGB = digitalRead(BUTTON_FARBWECHSEL);
// Statusabfrage
if (newStateFIX == LOW && oldStateFIX == HIGH) {
// kurze Verzögerung gegen Tastenprellung.
delay(20);
newStateFIX = digitalRead(BUTTON_FIXFARBE);
if (newStateFIX == LOW) {
showTypeFIX++;
if (showTypeFIX > 6)
showTypeFIX = 0;
startShowFIX(showTypeFIX);
}
}
oldStateFIX = newStateFIX;
if (newStateRGB == LOW && oldStateRGB == HIGH) {
delay(20);
newStateRGB = digitalRead(BUTTON_FARBWECHSEL);
if (newStateRGB == LOW) {
showTypeRGB++;
if (showTypeRGB > 1) //Nur zwischen 0 und 1 umschalten
//für weitere Anzeigemodi hier hochgehen
showTypeRGB = 0;
startShowRGB(showTypeRGB);
}
}
oldStateRGB = newStateRGB;
}
void startShowFIX(int i) {
switch (i) {
case 0: colorWipe(strip.Color(255, 127, 16), 10); //gelb
break;
case 1: colorWipe(strip.Color(255, 0, 0), 10); // Rot
break;
case 2: colorWipe(strip.Color(0, 255, 0), 10); // Gruen
break;
case 3: colorWipe(strip.Color(0, 0, 255), 10); // Blau
break;
case 4: colorWipe(strip.Color(32, 253, 24), 10); // Hellgruen
break;
case 5: colorWipe(strip.Color(213, 0, 255), 10); // Lila
break;
case 6: colorWipe(strip.Color(255, 255, 255), 10); // Weiß
break;
}
}
void startShowRGB(int y) {
switch (y) {
case 1: rainbow(20); //Farbverlauf
break;
case 0: rainbow(20); //Farbverlauf
break;
}
}
// Farbschleife
void colorWipe(uint32_t c, uint8_t wait) {
for (uint16_t x = 0; x < strip.numPixels(); x++) {
strip.setPixelColor(x, c);
strip.show();
delay(wait);
}
}
void rainbow(uint8_t wait) {
uint16_t x, j;
for(j=0; j<256; j++) {
for(x=0; x<strip.numPixels(); x++) {
strip.setPixelColor(x, Wheel((x+j) & 255));
}
strip.show();
delay(wait);
}
}
// Die Farben werden zwischen 0 und 256 geändert.
uint32_t Wheel(byte WheelPos) {
WheelPos = 255 - WheelPos;
if (WheelPos < 85) {
return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
}
if (WheelPos < 170) {
WheelPos -= 85;
return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
}
WheelPos -= 170;
return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}
Nach dem Programmieren sollte der RGB-Streifen leuchten und über die 2 Tasten steuerbar sein.
1.7 Endloser Farbwechsel alle Leds WS2812 RGB-Ledstreifen
Verwendetes Material:
1x Arduino MEGA Platine
1x WS2812 RGB Ledstrip (hier 20 Leds ins Serie)
1x Doppel-Tastermodul
1x langer roter Draht (+5V)
1x kurzer schwarzer Draht (GND)
1x kurzer Draht
Mit dem nachfolgenden Code wird auf einfachste Weise der RGB-Ledstreifen
mit endlosem-Farbwechsel aller Leds angesteuert.
Hier der Programmcode:
#include <Adafruit_NeoPixel.h>
#define PIXEL_PIN 7 // Digital IO pin connected to the NeoPixels.
int numPixels = 20; // number of neopixel (change this accordingly)
int Helligkeit = 150; //Helligkeit des Strips
int wait = 20; //Verzögerung des Farbwechels
Adafruit_NeoPixel strip = Adafruit_NeoPixel(numPixels, PIXEL_PIN, NEO_GRB + NEO_KHZ800);
void setup() {
strip.begin();
strip.show(); // Initialize all pixels to 'off'
}
void loop() {
uint16_t x, j;
for(j=0; j<256; j++) {
for(x=0; x<strip.numPixels(); x++) {
strip.setPixelColor(x, Wheel((x+j) & 255));
}
strip.show();
delay(wait);
}
}
// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos) {
WheelPos = 255 - WheelPos;
if (WheelPos < 85) {
return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
}
if (WheelPos < 170) {
WheelPos -= 85;
return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
}
WheelPos -= 170;
return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}
1.8 Endless Rainbow Farbdurchlauf WS2812 RGB-Ledstreifen
Mit dem nachfolgenden Code wird auf einfachste Weise der RGB-Ledstreifen
mit endlosem-Farbdurchlauf -quasi ein Regenbogen- aller Leds angesteuert.
Hier der Programmcode:
#include <FastLED.h>
#define LED_PIN 7 //Led Pin
#define NUM_LEDS 20//hier die Anzahl der Leds im Streifen einstellen
#define BRIGHTNESS 64 //maximale Helligkeit zum Stromsparen (500mA ARduino USB +5V)
#define LED_TYPE WS2812
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];
#define UPDATES_PER_SECOND 50 //hier kann die Geschwingigkeit des Farbdurchlaufs eingestellt werden
CRGBPalette16 currentPalette;
TBlendType currentBlending;
extern CRGBPalette16 myRedWhiteBluePalette;
extern const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM;
void setup() {
delay( 500 ); // 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()
{
currentPalette = RainbowColors_p;
currentBlending = LINEARBLEND;
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;
}
}
1.9 Knight Rider Light WS2812 RGB-Ledstreifen
Mit dem nachfolgenden Code wird auf einfachste Weise der RGB-Ledstreifen
mit dem Knight-Rider Light Abfolge angesteuert.
Als Variante 1: von links nach rechts & retour
Hier der Programmcode Variante 1:
#include <Adafruit_NeoPixel.h>
int PIN = 7;
int count = 0;
int timer = 14; //Verzögerung
int Ledanzahl = 20;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(Ledanzahl, PIN, NEO_GRB + NEO_KHZ800); //defines the strips properties
void setColor(int Pixel, int R2, int G2, int B2) {
uint32_t color = strip.Color(R2, G2, B2); // make a color
strip.setPixelColor(Pixel, color); //set a single pixel color
strip.show(); //update the colors
}
void setup() {
strip.begin(); // initialize the WS2812b strip
strip.show(); // just make sure everything is off
}
void loop() {
for (count = 0; count < Ledanzahl; count++) { setColor(count, 255, 0, 0); delay(timer); setColor(count + 1, 255, 0, 0); delay(timer); setColor(count, 0, 0, 0); delay(timer * 2); } for (count = Ledanzahl; count > 0; count--) {
setColor(count, 255, 0, 0);
delay(timer);
setColor(count - 1, 255, 0, 0);
delay(timer);
setColor(count, 0, 0, 0);
delay(timer * 2);
}
}
Als Variante 2: von links und rechts symmetrisch in die Mitte und retour
Hier der Programmcode Variante 2 mit 18 Leds pro Streifen:
#include <Adafruit_NeoPixel.h>
int PIN = 7;
int count = 0;
int timer = 30; //Verzögerung
int Ledanzahl = 18;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(Ledanzahl, PIN, NEO_GRB + NEO_KHZ800); //defines the strips properties
void setColor(int Pixel, int R2, int G2, int B2) {
uint32_t color = strip.Color(R2, G2, B2); // make a color
strip.setPixelColor(Pixel, color); //set a single pixel color
strip.show(); //update the colors
}
void setup() {
strip.begin(); // initialize the WS2812b strip
strip.show(); // just make sure everything is off
}
void loop() {
setColor(0, 255, 0, 0); //Start
setColor(17, 255, 0, 0);
delay(timer);
setColor(1, 255, 0, 0);
setColor(16, 255, 0, 0);
delay(timer);
setColor(2, 255, 0, 0);
setColor(15, 255, 0, 0);
delay(timer);
setColor(3, 255, 0, 0);
setColor(14, 255, 0, 0);
setColor(0, 0, 0, 0);
setColor(17, 0, 0, 0);
delay(timer);
setColor(4, 255, 0, 0);
setColor(13, 255, 0, 0);
setColor(1, 0, 0, 0);
setColor(16, 0, 0, 0);
delay(timer);
setColor(5, 255, 0, 0);
setColor(12, 255, 0, 0);
setColor(2, 0, 0, 0);
setColor(15, 0, 0, 0);
delay(timer);
setColor(6, 255, 0, 0);
setColor(11, 255, 0, 0);
setColor(3, 0, 0, 0);
setColor(14, 0, 0, 0);
delay(timer);
setColor(7, 255, 0, 0);
setColor(10, 255, 0, 0);
setColor(4, 0, 0, 0);
setColor(13, 0, 0, 0);
delay(timer);
setColor(8, 255, 0, 0); //Mitte
setColor(9, 255, 0, 0);
setColor(5, 0, 0, 0);
setColor(12, 0, 0, 0);
delay(timer);
setColor(6, 0, 0, 0);
setColor(11, 0, 0, 0);
delay(timer);
setColor(7, 0, 0, 0);
setColor(10, 0, 0, 0);
delay(timer);
setColor(8, 0, 0, 0);
setColor(9, 0, 0, 0);
delay(timer*10); //alle Leds dunkel timer*10 bedeutet kurze Pause bei dunkel
setColor(8, 255, 0, 0);
setColor(9, 255, 0, 0);
delay(timer);
setColor(7, 255, 0, 0);
setColor(10, 255, 0, 0);
delay(timer);
setColor(6, 255, 0, 0);
setColor(11, 255, 0, 0);
delay(timer);
setColor(5, 255, 0, 0);
setColor(12, 255, 0, 0);
setColor(8, 0, 0, 0);
setColor(9, 0, 0, 0);
delay(timer);
setColor(4, 255, 0, 0);
setColor(13, 255, 0, 0);
setColor(7, 0, 0, 0);
setColor(10, 0, 0, 0);
delay(timer);
setColor(3, 255, 0, 0);
setColor(14, 255, 0, 0);
setColor(6, 0, 0, 0);
setColor(11, 0, 0, 0);
delay(timer);
setColor(2, 255, 0, 0);
setColor(15, 255, 0, 0);
setColor(5, 0, 0, 0);
setColor(12, 0, 0, 0);
delay(timer);
setColor(1, 255, 0, 0);
setColor(16, 255, 0, 0);
setColor(4, 0, 0, 0);
setColor(13, 0, 0, 0);
delay(timer);
setColor(0, 255, 0, 0);
setColor(17, 255, 0, 0);
setColor(3, 0, 0, 0);
setColor(14, 0, 0, 0);
delay(timer);
setColor(2, 0, 0, 0);
setColor(15, 0, 0, 0);
delay(timer);
setColor(1, 0, 0, 0);
setColor(16, 0, 0, 0);
delay(timer);
setColor(0, 0, 0, 0);
setColor(17, 0, 0, 0);
delay(timer);
}
Hier der Programmcode Variante 2 mit 20 Leds pro Streifen:
#include <Adafruit_NeoPixel.h>
int PIN = 7;
int count = 0;
int timer = 30; //Verzögerung
int Ledanzahl = 20;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(Ledanzahl, PIN, NEO_GRB + NEO_KHZ800); //defines the strips properties
void setColor(int Pixel, int R2, int G2, int B2) {
uint32_t color = strip.Color(R2, G2, B2); // make a color
strip.setPixelColor(Pixel, color); //set a single pixel color
strip.show(); //update the colors
}
void setup() {
strip.begin(); // initialize the WS2812b strip
strip.show(); // just make sure everything is off
}
void loop() {
setColor(0, 255, 0, 0); //Start
setColor(19, 255, 0, 0);
delay(timer);
setColor(1, 255, 0, 0);
setColor(18, 255, 0, 0);
delay(timer);
setColor(2, 255, 0, 0);
setColor(17, 255, 0, 0);
delay(timer);
setColor(3, 255, 0, 0);
setColor(16, 255, 0, 0);
setColor(0, 0, 0, 0);
setColor(19, 0, 0, 0);
delay(timer);
setColor(4, 255, 0, 0);
setColor(15, 255, 0, 0);
setColor(1, 0, 0, 0);
setColor(18, 0, 0, 0);
delay(timer);
setColor(5, 255, 0, 0);
setColor(14, 255, 0, 0);
setColor(2, 0, 0, 0);
setColor(17, 0, 0, 0);
delay(timer);
setColor(6, 255, 0, 0);
setColor(13, 255, 0, 0);
setColor(3, 0, 0, 0);
setColor(16, 0, 0, 0);
delay(timer);
setColor(7, 255, 0, 0);
setColor(12, 255, 0, 0);
setColor(4, 0, 0, 0);
setColor(15, 0, 0, 0);
delay(timer);
setColor(8, 255, 0, 0);
setColor(11, 255, 0, 0);
setColor(5, 0, 0, 0);
setColor(14, 0, 0, 0);
delay(timer);
setColor(9, 255, 0, 0); //Mitte erreicht je Seite 3 Leds treffen sich in der Mitte
setColor(10, 255, 0, 0);
setColor(6, 0, 0, 0);
setColor(13, 0, 0, 0);
delay(timer);
//ab hier werden Leds ausgeschaltet
setColor(7, 0, 0, 0);
setColor(12, 0, 0, 0);
delay(timer);
setColor(8, 0, 0, 0);
setColor(11, 0, 0, 0);
delay(timer);
setColor(9, 0, 0, 0);
setColor(10, 0, 0, 0);
delay(timer*10); //alle Leds dunkel timer*10 bedeutet kurze Pause bei dunkel
setColor(9, 255, 0, 0);
setColor(10, 255, 0, 0);
delay(timer);
setColor(8, 255, 0, 0);
setColor(11, 255, 0, 0);
delay(timer);
setColor(7, 255, 0, 0);
setColor(12, 255, 0, 0);
delay(timer);
setColor(6, 255, 0, 0);
setColor(13, 255, 0, 0);
setColor(9, 0, 0, 0);
setColor(10, 0, 0, 0);
delay(timer);
setColor(5, 255, 0, 0);
setColor(14, 255, 0, 0);
setColor(8, 0, 0, 0);
setColor(11, 0, 0, 0);
delay(timer);
setColor(4, 255, 0, 0);
setColor(15, 255, 0, 0);
setColor(7, 0, 0, 0);
setColor(12, 0, 0, 0);
delay(timer);
setColor(3, 255, 0, 0);
setColor(16, 255, 0, 0);
setColor(6, 0, 0, 0);
setColor(13, 0, 0, 0);
delay(timer);
setColor(2, 255, 0, 0);
setColor(17, 255, 0, 0);
setColor(5, 0, 0, 0);
setColor(14, 0, 0, 0);
delay(timer);
setColor(1, 255, 0, 0);
setColor(18, 255, 0, 0);
setColor(4, 0, 0, 0);
setColor(15, 0, 0, 0);
delay(timer);
setColor(0, 255, 0, 0);
setColor(19, 255, 0, 0);
setColor(3, 0, 0, 0);
setColor(16, 0, 0, 0);
delay(timer);
setColor(2, 0, 0, 0);
setColor(17, 0, 0, 0);
delay(timer);
setColor(1, 0, 0, 0);
setColor(18, 0, 0, 0);
delay(timer);
setColor(0, 0, 0, 0);
setColor(19, 0, 0, 0);
delay(timer);
}
