Auswahl zweier Arduino Sketches

[Schlonz K. (schlonz-klug)]

Hi

kurze erklärung: Ich habe einen Arduino an eine WS2812 LED strippe / 
Matrix angeschlossen und dieser soll das Ganze steuern. Ich möchte dabei 
mittels einem Schalter bei dem ich einen IO pin high oder low lege 
entweder das eine Sketch starten, bei dem der standart neopixel einfach 
random was generiert, oder das ganze mittels seriel über den pc 
ansteuern (Siehe angefügte Sketche)...

ich versuche bisher das zu kombinieren aber ich kriegs einfach nicht 
hin...

danke im Voraus für eure Hilfe

mfg
Leon

[Alex R. (itaxel)]

Was hast du bisher gemacht und wie?
Poste mal dein versuch.

[Schlonz K. (schlonz-klug)]

Hier hab ich den Versuch was ich bisher unternommen habe... Ich hab 
zuerst versucht einfach den kompletten Code der beiden in eine if 
Schleife zu setzen die am Anfang den Pin abfragt... Dann hab ich mal 
versucht alle setups zusammenzulegen weil er da immer rum geheult 
hat.... Jetzt hab ich das Problem dass er sich wegen einer 
nichtdeklarierten Variable beschwert, bei dem WS2812 Skript, wobei ich 
den Code fast 1:1 übernommen habe...

mit freundlichen Grüßen
Leon

[Karl H. (kbuchegg)]

Schlonz Klug schrieb:
> Hier hab ich den Versuch was ich bisher unternommen habe... Ich hab
> zuerst versucht einfach den kompletten Code der beiden in eine if
> Schleife

Es gibt keine if-'Schleifen'.

Das Wesen einer Schleife besteht darin, dass Code wiederholt wird. Darum 
heisst es Schleife, wie bei einem Tonband bei dem m an Anfang und Ende 
zusammenklebt und das daher immer wieder erneut abgespielt wird. Eben in 
einer Schleife.
In einem if wird nichts wiederholt. Ein if führt einen von 2 möglichen 
Codezweigen aus, abhängig von einer Bedingung.


> versucht alle setups zusammenzulegen weil er da immer rum geheult
> hat.... Jetzt hab ich das Problem

Dein Problemm fängt viel früher an. Dein eigentliches Problem ist, dass 
dir wer eingeredet hat, das man programmieren könnte, ohne es zuvor zu 
lernen.

> nichtdeklarierten Variable beschwert, bei dem WS2812 Skript, wobei ich
> den Code fast 1:1 übernommen habe...

übernehmen ohne zu verstehen geht praktisch immer schief.
Deinen Code, so ehrlich muss man sein, kann man so nur in die Tonne 
treten und neu machen. Was nicht heisst, dass man nicht zb den ganzen 
WS2812 Teil in seinen Grundzügen weiterverwenden kann. Aber den hast du 
ja nicht selbst geschrieben. Aber den Teil, den du geschrieben hast, der 
ist so weit von einem Programm entfernt, wie ich von einer erfolgreichen 
Herzoperation.

[Schlonz K. (schlonz-klug)]

Danke... Dass der Code nicht so funktioniert und dass ich au Grund von 
schlecht ausgebildeten Informatiklehrern nur Grundkenntnisse habe weiß 
ich auch... Dass mit der ifschleife war schlecht ausgedrückt aber deine 
Antwort hilft mir leider überhaupt nicht weiter.... Ich bräuchte eine 
Lösung bzw. Lösungsansatz an dem ich weitermachen kann und keinen der 
mir sagt was ich ohnehin Schon weiß...

Trotzdem Danke

[Karl H. (kbuchegg)]

Schlonz Klug schrieb:
> Danke... Dass der Code nicht so funktioniert und dass ich au Grund von
> schlecht ausgebildeten Informatiklehrern

Sorry. Aber dein Machwerk hat auch nichts mit schlecht ausgebildeten 
Informatiklehrern zu tun.

> nur Grundkenntnisse

Und noch mal sorry. Aber das sind noch nicht mal Grundkennntnisse.

Ich sag das ja nicht um dich zu frustrieren. Aber ich halte hier auch 
nichts davon, die Dinge zu beschönigen. Das gibt dann erst recht nur 
Frust. Wenn in dem Code auch nur Ansätze erkennbar wären, dass es Sinn 
machen würde, dich da durchzusprechen. Aber in dem Machwerk fehlt es 
einfach überall an allem.

[Karl H. (kbuchegg)]

PS:
Der schlimmere deiner beiden Ausgangssketsches ist der WS2812_Glediator.

Denn mit der Adafruit_NeoPixel Klasse hast du bereits eine Klasse, die 
mit WS2812 LED umgehen kann. D.h. der ganze Ansteuerungsteil aus dem 
Glediator ist komplett 'für die Wurst'. Den braucht kein Mensch, wenn 
man die Adafruit_NeoPixel Klasse zur Verfügung hat.

Anstatt aus diesem Code da zu versuchen etwas zusammenzukopieren, 
solltest du lieber lernen, mit der Adafruit_NeoPixel Library umzugehen 
und dann damit dein eigenes Programm schreiben. Die Klasse macht dir das 
sowieso recht einfach.

Ausserem sehe ich wirklich nicht, was du aus diesem Glediator Programm 
mitnehmen willst. Bytes von der UART auf die LEDs zu übertragen ist im 
Arduino System, mit einer fix fertigen Seriellen Klasse und eben dieser 
Adafruit_NeoPixel Klasse trivial. Das kriegen sogar Künstler hin, die in 
ihrem Leben noch nie einen Informatiklehrer gesehen haben.

[Schlonz K. (schlonz-klug)]

Ok und wie genau schleife ich die Glediator Daten dann mittels neopixel 
Library zu den LEDs durch?

Wenn mir da jemand nen Beispiel nennen könnte wär ich schon zufrieden...

[Karl H. (kbuchegg)]

Schlonz Klug schrieb:
> Ok und wie genau schleife ich die Glediator Daten

Du hast nicht begriffen, dass es beim Glediator darum geht, Bytes von 
der Seriellen Schnittstelle auf die LEDs auszugeben. D.h. die Frage muss 
lauten: wie kann ich eigentlich von der Seriellen Schnittstelle Daten 
holen bzw. zur Weiterverarbeitung speichern?

> dann mittels neopixel
> Library zu den LEDs durch?

Du hast doch ein Beispiel, wie man die Klasse benutzt (den anderen 
Sketch). Versuch halt mal einfach zu verstehen, wie das funktioniert, 
bzw. wie man die Klasse verwendet. So schwer ist das nicht. Da gibt es 
Doku dazu und du hast auch einen Beispielsketch, der das alles in Aktion 
zeigt.

Und für die Serielle Schnittstelle und wie man die in der Arduino 
Umgebung anspricht, gibt es haufenweise Tutorien.

[Jürgen S. (jurs)]

Schlonz Klug schrieb:
> ich versuche bisher das zu kombinieren aber ich kriegs einfach nicht
> hin...

Lernste was, dann kannste was,
kannste was, dann biste was,
biste was, dann haste was,
Neopixel-Farbenspass!

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

> Und für die Serielle Schnittstelle und wie man die in der Arduino
> Umgebung anspricht, gibt es haufenweise Tutorien.


OK. Den Teil nehm ich zurück.
Mit

 UBRR0H = 0;
  UBRR0L = 1; //Baud Rate 1 MBit (at F_CPU = 16MHz)

einer Baudrate von 1MBit wird das nichts mit der Arduino-Seriellen 
Klasse. Den UART Teil muss man tatsächlich vom Glediator übernehmen.

#define NUMBER_OF_PIXELS 60

unsigned char display_buffer[NUMBER_OF_PIXELS * 3];
static unsigned char *ptr;
static unsigned int pos = 0;

volatile unsigned char go = 0;

Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMBER_OF_PIXELS, PIN, NEO_GRB + NEO_KHZ800);

void setup()
{
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'

  // Initialize UART
  UCSR0A |= (1<<U2X0);                                
  UCSR0B |= (1<<RXEN0)  | (1<<TXEN0) | (1<<RXCIE0);   
  UCSR0C |= (1<<UCSZ01) | (1<<UCSZ00)             ; 
  UBRR0H = 0;
  UBRR0L = 1; //Baud Rate 1 MBit (at F_CPU = 16MHz)
}

ISR(USART_RX_vect) 
{
  unsigned char b;
  b = UDR0;
  
  if (b == 1)  {pos=0; ptr=display_buffer; return;}    
  if (pos == (NUMBER_OF_PIXELS*3)) {} else {*ptr=b; ptr++; pos++;}  
  if (pos == ((NUMBER_OF_PIXELS*3)-1)) {go=1;}
}

void loop()
{
   ....
}

[Schlonz K. (schlonz-klug)]

Glediator unterstützt mehrere Geschwindigkeiten... Vielleicht ist es 
möglich hier ein wenig Geschwindigkeit heraus zu nehmen um dann dies zu 
kombinieren... Ich habe nur 25 LEDs angeschlossen da ließe sich auf 
jeden Fall Tempo raus nehme (denke ich)...

Probier das aus und melde mich nochmal

[Jürgen S. (jurs)]

Schlonz Klug schrieb:
> Glediator unterstützt mehrere Geschwindigkeiten... Vielleicht ist es
> möglich hier ein wenig Geschwindigkeit heraus zu nehmen um dann dies zu
> kombinieren... Ich habe nur 25 LEDs angeschlossen da ließe sich auf
> jeden Fall Tempo raus nehme (denke ich)...
>
> Probier das aus und melde mich nochmal

Bis zu maximal 500000 Baud kannst Du mit "Serial" und der Arduino-Core 
Library nutzen.

Im Endeffekt brauchst Du doch in Deinem "strandtest" Sketch nur das 
"Serial" Objekt mit 500000 Baud (oder weniger) initialisieren und 
abhängig von der Schalterstellung dann entweder die dort vorhandenen 
Funktionen laufen lassen oder in einer Schleife so lange drei Bytes 
empfangen und als Farbe per strip.setPixelColor() an Deinen LED-Streifen 
zuweisen, bis Daten für alle LEDs empfangen wurden, und diese dann 
anzeigen.

Sogar den manuellen Umschalter kannst Du Dir dabei eigentlich sparen, 
wenn Du auf der Serial-Schnittstelle mit Timeout empfängst, etwa nach 
der Logik:
1. Wenn innerhalb 2x der Zeit, in der eigentlich Daten ankommen müßten, 
keine seriellen Daten ankommen, schalte auf das automatische 
Testprogramm.
2. Wenn nach Ablauf des Testprogramms serielle Daten vorhanden sind: 
Schalte auf das Glediator-Widergabeprogramm

Dann brauchst Du im Endeffekt nur das Kabel abstöpseln oder das 
Glediatorprogramm auf dem PC beenden, und der Streifen schaltet 
automatisch auf sein eigenes Programm um. Und wenn wieder Daten kommen, 
schaltet der Arduino wieder automatisch auf Glediator-Wiedergabe. Also 
automatische Umschaltung statt manuelle Umschaltung.

[Schlonz K. (schlonz-klug)]

Hallo nochmal,

hab jetzt mal versucht ne alternative zu schreiben. Allerdings habe ich 
ein paar probleme: Manchmal ließt das programm mehr ein als es sollte, 
hab zuerst versucht mit Serial.parseInt() statt mit Serial.read() zu 
arbeiten, habe aber nichts mehr raus bekommen...

das zweite problem das ich habe ist, dass die neopixel library 
zahlenwerte haben will und ich es nicht hinbekommen meine hex werte 
darin um zu wandeln.

Hab auch mit den Datenklassen rumexpiremtiert, bisher noch kein Erfolg

#include <Adafruit_NeoPixel.h>
Adafruit_NeoPixel strip = Adafruit_NeoPixel(25, 6, NEO_GRB + NEO_KHZ800);
const unsigned char numLED = 6;
unsigned char x = 0;
int red = 0;
int green = 0;
unsigned char blue = 0;


void setup(){
  Serial.begin(115200);
  strip.begin();
  Serial.setTimeout(100);
}


void loop(){
  if (Serial.find("") == true){
    Serial.print("OK");
    while(x==0 || x < numLED){
      x++;
      red = Serial.read();
      green = Serial.read();
      blue = Serial.read();
      strip.setPixelColor(x, red, green, blue);
      Serial.print(red, HEX);
      Serial.print(",");
      Serial.print(green,HEX);
      Serial.print(",");
      Serial.print(blue,HEX);
      Serial.print("\n");
    }
    x = 0; 
    
    
    
  }
  else {
    Serial.print("not\n");
    delay(100);
  }
  strip.show();
}

Sie serial.print habe ich rein gemacht um zu sehen was das programm 
bekommt, fliegen nachher natürlich raus...

danke im Voraus
Leon

[Jürgen S. (jurs)]

Schlonz Klug schrieb:
> hab jetzt mal versucht ne alternative zu schreiben. Allerdings habe ich
> ein paar probleme

OK, Du scheinst also damit anzufangen, die Glediator-Empfangsroutine auf 
die Neopixel-Library umzuschreiben. Das erscheint mir auch sinnvoll.

Aber kannst Du vielleicht erstmal erklären, was Du da eigentlich hast. 
In Deinem Code sehe ich diese beiden Zeilen, die so keinen Sinn ergeben:

  // Deklariere einen LED-Streifen mit 25 LEDs an Pin-6
  Adafruit_NeoPixel strip = Adafruit_NeoPixel(25, 6, NEO_GRB + NEO_KHZ800);

  // Deklariere eine Anzahl von 6 LEDs
  const unsigned char numLED = 6;

Was denn nun: 25 LEDs an Pin-6? Oder 6 LEDs an welchem Pin?

Außerdem sieht mir Dein umgeschriebener Code so aus, als wenn Du die 
Synchronisierung nicht verstanden hast.

Ggf. kann ich ja mal versuchen, den Code umzuschreiben.

Aber am Ende funktionieren kann das natürlich nur, wenn Du genau weißt, 
wie viele LEDs an welchem Pin angeschlossen sind, und Du im selben Code 
nicht an einer Stelle 25 LEDs deklarierst und dann an anderer Stelle 
Daten für 6 LEDs einlesen möchtest, und das auch noch ohne jede 
Synchronisation zwischen Senden und Empfangen.

[Schlonz K. (schlonz-klug)]

Ok Danke das ist mir aus versehen nicht aufgefallen... Zum ende hin 
sollen 25 LEDs angesteuert werden, habe aber für den test 6 
verwendet.... habe jetzt einfach die numLED variable auch in die 
NeoPixel definition mit rein genommen...

Geldiator sendet die Daten in einem Strucktur. Jerder neue Datenstrang 
fängt mit dem Hexwert 01 an, dieser wird durch Seriell.find detektiert 
(ich hab einfach das zeichen reinkopiert aus meinem Hexeditor, man kann 
es nicht sehen aber es ist da und dieser part funktioniert auch 
zuverlässig) nach diesem 01 folgt ein wert zwischen 00 und FF, der die 
Intensität der ersten Farbe der ersten LED angibt, diese speichere ich 
dann in red ab.

Dankach folgt 2. Farbe der 1. LED und 3. Farbe der 1. LED.... diese 
werden dann der ersten led mittels adresse, die durch diel while 
schleife hochgezählt wird dieser zugeschreiben. Die rutine sollte dann 
die 1. Fareb der 2. LEd detektieren und dann so weiter, solange bis alle 
leds fertig sind, dann sollte alles ausgegeben werden mittles 
strip.show()

Wenn innerhalb 100 Millisekunden kein HEXwer 01 detektiert wird 
(doppelte zeit wie es sein sollte) dann wird else ausgeführt, da kommt 
dann irgendeine animation rein wenn das erstmal mit glediator 
funktioniert

[Jürgen S. (jurs)]

OK, hier mal mein Versuch, die Glediator-Empfangsroutine auf die 
Adafruit-Neopixel-Library umzuschreiben.

#include <Adafruit_NeoPixel.h>
#define NUMLEDS 25
#define LEDPIN 6
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMLEDS, LEDPIN, NEO_GRB + NEO_KHZ800);

void setup()
{
  Serial.begin(115200);
  strip.begin();
}


byte rgb[3];       // RGB-Werte 
int activeLED=0;   // Die LED, deren Daten empfangen werden
int activeColor=0; // Der nächste zu empfangende Farbwert (0=rot, 1=grün, 2=blau)

void loop()
{
  if (!Serial.available()) return;
  while (Serial.available())
  {
    byte b=Serial.read();
    if (b==1) // Reset/Synchronisation
    {
      activeLED=0;
      activeColor=0;
      return;
    }
    rgb[activeColor]=b;
    activeColor++;
    if (activeColor>=3)
    {
      strip.setPixelColor(activeLED, rgb[0], rgb[1], rgb[2]);
      activeLED++;
      activeColor=0;
    }
    if (activeLED>=NUMLEDS)
    {
      activeLED=0;
      activeColor=0;
      strip.show();
    }
  }
}

Zeigen Deine LEDs damit was an (Baudrate 115200 oder wie Du es im Sketch 
und in der Glediator-Software einstellst)?

[Schlonz K. (schlonz-klug)]

Hallo, hab deinen Code ausprobiert und er funktioniert... VIELEN DANK

das einzige problem das ich jetzt noch habe ist, dass ich irgendwie 
feststellen muss ob überhaupt ein serielles signal anliegt, denn wenn 
nicht würde ich gerne einen alternativcode ausführen. Habe schon 
probiert das in die if(Serial.available rein zu packen, aber das spinnt 
dann rum wenn Daten ankommen, da da so ca 30ms Pause zwischen den Daten 
Strängen sind.

[Jürgen S. (jurs)]

Schlonz Klug schrieb:
> das einzige problem das ich jetzt noch habe ist, dass ich irgendwie
> feststellen muss ob überhaupt ein serielles signal anliegt, denn wenn
> nicht würde ich gerne einen alternativcode ausführen. Habe schon
> probiert das in die if(Serial.available rein zu packen, aber das spinnt
> dann rum wenn Daten ankommen, da da so ca 30ms Pause zwischen den Daten
> Strängen sind.

Im Prinzip mußt Du Dir ein Timeout legen, das größer ist als die 
normalen Sendepausen zwischen den Datensendungen. Und dann nach einer 
Timeout-Logik entweder die eine oder die andere Effektschleife aufrufen 
oder das Timeout setzen. Etwa nach der Logik

- Serial.available() ==> Glediator-Loop starten und Timeout löschen
- wenn ein Timeout vorliegt ==> Default-Loop starten
- wenn beides nicht zutrifft ==> prüfen, ob das Timeout erreicht ist

Mit den einfach reinkopierten Testroutinen komme ich dann auf folgendes 
Programm:

#include <Adafruit_NeoPixel.h>
#define NUMLEDS 25
#define LEDPIN 6
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMLEDS, LEDPIN, NEO_GRB + NEO_KHZ800);

void setup()
{
  Serial.begin(115200);
  strip.begin();
}


/************************************************************
Glediator-Routinen
************************************************************/
byte rgb[3];       // RGB-Werte 
int activeLED=0;   // Die LED, deren Daten empfangen werden
int activeColor=0; // Der nächste zu empfangende Farbwert (0=rot, 1=grün, 2=blau)

void glediatorLoop()
{
  while (Serial.available())
  {
    byte b=Serial.read();
    if (b==1) // Reset/Synchronisation
    {
      activeLED=0;
      activeColor=0;
      return;
    }
    rgb[activeColor]=b;
    activeColor++;
    if (activeColor>=3)
    {
      strip.setPixelColor(activeLED, rgb[0], rgb[1], rgb[2]);
      activeLED++;
      activeColor=0;
    }
    if (activeLED>=NUMLEDS)
    {
      activeLED=0;
      activeColor=0;
      strip.show();
    }
  }
}

/************************************************************
Default-Routinen
************************************************************/
void defaultLoop()
{
  // Some example procedures showing how to display to the pixels:
  colorWipe(strip.Color(255, 0, 0), 50); // Red
  colorWipe(strip.Color(0, 255, 0), 50); // Green
  colorWipe(strip.Color(0, 0, 255), 50); // Blue
  // Send a theater pixel chase in...
  theaterChase(strip.Color(127, 127, 127), 50); // White
  theaterChase(strip.Color(127,   0,   0), 50); // Red
  theaterChase(strip.Color(  0,   0, 127), 50); // Blue

  rainbow(20);
  rainbowCycle(20);
  theaterChaseRainbow(50);  
}

/************************************************************
Unterfunktionen für verschiedene Effekte der defaultLoop
************************************************************/
// Fill the dots one after the other with a color
void colorWipe(uint32_t c, uint8_t wait) {
  for(uint16_t i=0; i<strip.numPixels(); i++) {
      strip.setPixelColor(i, c);
      strip.show();
      delay(wait);
  }
}

void rainbow(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256; j++) {
    for(i=0; i<strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel((i+j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

// Slightly different, this makes the rainbow equally distributed throughout
void rainbowCycle(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
    for(i=0; i< strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

//Theatre-style crawling lights.
void theaterChase(uint32_t c, uint8_t wait) {
  for (int j=0; j<10; j++) {  //do 10 cycles of chasing
    for (int q=0; q < 3; q++) {
      for (int i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, c);    //turn every third pixel on
      }
      strip.show();
     
      delay(wait);
     
      for (int i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, 0);        //turn every third pixel off
      }
    }
  }
}

//Theatre-style crawling lights with rainbow effect
void theaterChaseRainbow(uint8_t wait) {
  for (int j=0; j < 256; j++) {     // cycle all 256 colors in the wheel
    for (int q=0; q < 3; q++) {
        for (int i=0; i < strip.numPixels(); i=i+3) {
          strip.setPixelColor(i+q, Wheel( (i+j) % 255));    //turn every third pixel on
        }
        strip.show();
       
        delay(wait);
       
        for (int i=0; i < strip.numPixels(); i=i+3) {
          strip.setPixelColor(i+q, 0);        //turn every third pixel off
        }
    }
  }
}

// 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);
  } else if(WheelPos < 170) {
    WheelPos -= 85;
   return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  } else {
   WheelPos -= 170;
   return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
  }
}



/************************************************************
Arduino loop mit Serial Timeout
************************************************************/

#define TIMEOUT 1000  // in Millisekunden
boolean timeout;
unsigned long lastSerial;

void loop()
{
  if (Serial.available())
  {
    glediatorLoop();
    timeout=false;
    lastSerial=millis();
  }
  else if (timeout)
  {
    defaultLoop();
  }
  else if (millis()-lastSerial>=TIMEOUT)
  {
    timeout=true;
  }
}

Nachteilig dran ist nur, wie die Effekte realisiert sind: Mit delay.

Das führt natürlich dazu, dass nach einem Timeout die recht lange 
laufende defaultLoop() immer erst zuende abgearbeitet werden muss, bevor 
wieder auf anliegende Serial-Daten reagiert und auf die glediatorLoop() 
umgeschaltet werden kann.

Wenn der Arduino nur ein Lichtprogramm steuern soll und das lahme 
reagieren auf anliegende Serial-Daten kein Problem ist, kann man seine 
Effekte natürlich auch mit delay() Aufrufen programmieren und den 
Programmablauf ständig blockieren.

Falls das Programm zwischendurch aber noch auf andere Dinge blitzschnell 
reagieren soll, z.B. angeschlossene Schalter, müssen die Effekte 
natürlich frei von jeglichem delay ganz anders programmiert werden.

[Schlonz K. (schlonz-klug)]

Hallo,

wollte mich nochmal kurz melden, hab jetzt das Projekt fertig, hab einen 
leicht abgewandelten Code verwendet, so kann ich jetzt über ein 
Funkmodul Glediatordaten einspeißen, wenn diese nicht vorhanden sind 
kann man mittels drei Potis die Farbe so einstellen:

#include <Adafruit_NeoPixel.h>
#define NUMLEDS 25
#define LEDPIN 6
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMLEDS, LEDPIN, NEO_GRB + NEO_KHZ800);

void setup()
{
  Serial.begin(115200);
  strip.begin();
  pinMode(A0, INPUT);
  pinMode(A1, INPUT);
  pinMode(A2, INPUT);
}


/************************************************************
Glediator-Routinen
************************************************************/
byte rgb[3];
int activeLED=0;
int activeColor=0;

void glediatorLoop()
{
  while (Serial.available())
  {
    byte b=Serial.read();
    if (b==1)
    {
      activeLED=0;
      activeColor=0;
      return;
    }
    rgb[activeColor]=b;
    activeColor++;
    if (activeColor>=3)
    {
      strip.setPixelColor(activeLED, rgb[0], rgb[1], rgb[2]);
      activeLED++;
      activeColor=0;
    }
    if (activeLED>=NUMLEDS)
    {
      activeLED=0;
      activeColor=0;
      strip.show();
    }
  }
}

/************************************************************
Default-Routinen
************************************************************/
void defaultLoop(){
  int rot = analogRead(A0);
  rot = map(rot, 0, 1023, 255, 0);
  int green = analogRead(A1);
  green = map(green, 0, 1023, 255, 0);
  int blau = analogRead(A2);
  blau = map(blau, 0, 1023, 255, 0);
  
  activeLED=0;
  
  while(activeLED < NUMLEDS){
    strip.setPixelColor(activeLED, rot, green, blau);
    activeLED++;
  }
  
  strip.show();
  activeLED = 0;
  delay(100);
    
}



/************************************************************
Arduino loop mit Serial Timeout
************************************************************/

#define TIMEOUT 1000
boolean timeout;
unsigned long lastSerial;

void loop()
{
  if (Serial.available())
  {
    glediatorLoop();
    timeout=false;
    lastSerial=millis();
  }
  else if (timeout)
  {
    defaultLoop();
  }
  else if (millis()-lastSerial>=TIMEOUT)
  {
    timeout=true;
  }
}

zum Schluss noch ein Danke, sonst hätte ich glaub ich ein wenig viel 
länger gebraucht...

mit freundlichen Grüßen
Leon