Led effekte C

[LEDS (Gast)]

Hallo,

ich bin auf der Suche für meinen WS2812B Strip nach Effekten geschrieben 
in C. Gibt es dort eine gute Quelle, wo einiges bereits zusammengetragen 
worden ist?

Interessant vorallem irgendwelche Komentenschweife etc.

[gernot (Gast)]

LEDS schrieb:
> ich bin auf der Suche für meinen WS2812B Strip nach Effekten geschrieben
> in C. Gibt es dort eine gute Quelle, wo einiges bereits zusammengetragen
> worden ist?

Suche ich auch. Würdest du es bitte hier schreiben, wenn du was gefunden 
hast.

[Philipp H. (hansimglueck2)]

Abo

[Bernhard (Gast)]

In dem Beispiel für den PSoC sind einige Effekte drin:

http://www.cypress.com/forum/psoc-community-components/neopixel-ws281112-component

[LEDS (Gast)]

Hallo,

ich habe mir gerade mal die FastLED Lib angeschaut. Da gibt es in 
DemoReel100 ein paar schöne Effekte. Vorallem der Komentenschweif 
(sinelon()). Kann mir einer sagen, wie man den ohne FastLed schreibt?

[Bernd G. (bege)]

Schaut mal hier so ab Zeile 600:

https://github.com/charlie-x/psoc4-esp8266-ws1812/blob/master/code/PSOC%20Firmware/Bootloadable%20XMAS.cydsn/main.c

Ist zwar auch für PSOC4 von Cyress, läßt sich aber einfach portieren, da 
im Prinzip nur ein Speicherarray beschrieben wird. Die Ausgabe zum 
WS2812-Stripe ist in Hardware gelöst. (Der PSOC hat etwas 'frei' 
programmierbare Logik on Chip.)

[LEDS (Gast)]

Danke für den Link,

ich muss mal schauen, ob sich etwas interessantes ableiten lässt.

Hab mich mal mit dem Kometenschweif auseinander gesetzt. Das klappt so 
ein bisschen schon.

width : gibt die länge des Schweifes an
*pos  : aktuelle Position der ersten Led
value : Max. Helligkeit

void sinelon_new(struct colorRGB *leds, uint8_t numLeds, uint8_t width, int16_t *pos, uint8_t value)
{
  /*
  * pos - 7    value / 7 * 0 >>>> setzt letzte Led auf 0
  * pos - 6    value / 7 * 1
  * pos - 5    value / 7 * 2
  * pos - 4    value / 7 * 3
  * pos - 3    value / 7 * 4
  * pos - 2    value / 7 * 5
  * pos - 1    value / 7 * 6
  * pos - 0    value / 7 * 7
  */

  uint8_t val;
  for(uint8_t led = 0; led < width; led++)
  {
    val = (value / (width-1)) * ((width-1)-led);
    leds[*pos - led].r = correction[val]; // gamma-correction
  }
  if(++(*pos) >= numLeds+width) *pos = 0;
}

Könnte mir jemand hierbei helfen, das ganze etwas besser aufzubauen? Ich 
habe hier die Befürchtung, dass es zu unerlaubten überläufen kommt, wenn 
in ein nicht vorhandenes Register geschrieben wird.

Es soll ein struct mit numLeds-Elementen beschrieben werden.
1. Runde/Start: Die erste Led kommt in der vollen Helligkeit.
2. Runde: Die erste Led wandert um +1 nach rechts. Die Nachfolgende Led 
soll mit value/7*8   (value/(width-1)) * ((width-1)-led) leuchten. usw.
Wenn die schwächste Led (in diesem Beispiel pos-7 am Ende von numLeds 
angekommen ist, soll nichts mehr zu sehen sein, ehe durch einen 
Tastendruck die erste Led wieder an der ersten Pos ankommt.

Hoffe, dass mir wer da etwas helfen kann.

[LEDS (Gast)]

So, den ungewollten Überlauf schaff ich :((

void sinelon_new(struct colorRGB *leds, uint8_t numLeds, uint8_t width, int16_t *pos, uint8_t c, uint8_t value)
{
  /*
  * pos - 7    value / 7 * 0 >>>> setzt letzte Led auf 0
  * pos - 6    value / 7 * 1
  * pos - 5    value / 7 * 2
  * pos - 4    value / 7 * 3
  * pos - 3    value / 7 * 4
  * pos - 2    value / 7 * 5
  * pos - 1    value / 7 * 6
  * pos - 0    value / 7 * 7
  */

  for(uint8_t led = 0; led < width; led++)
  {
    uint8_t val = (value / (width-1)) * ((width-1)-led);
    
    if(*pos - led >= 0 && *pos - led < numLeds)
    {
      switch(c)
      {
        case 0: leds[*pos - led].r = correction[val]; break;
        case 1: leds[*pos - led].g = correction[val]; break;
        case 2: leds[*pos - led].b = correction[val]; break;
      }
    }
  }
  if(++(*pos) >= numLeds+width) *pos = 0;
}

Sobald der Effekt das 3x durchläuft blinken alle Leds nur noch doof!

Eingebunden ist das ganze wie folgt

#define NUM_LEDS    18
struct cRGB leds[NUM_LEDS];

//...

    while(nextStep > 0)
    {
      static int16_t pos_r = 0;
      static int16_t pos_g = 6;
      static int16_t pos_b = 12;

    //  sinelon_new(leds, NUM_LEDS0, 8, &pos_r,0, value);
    //  sinelon_new(leds, NUM_LEDS0, 8, &pos_g, 1,value);
      sinelon_new(leds, NUM_LEDS, 8, &pos_b, 2,value);
      ws2812_setleds(leds, NUM_LEDS);
      

      nextStep--;
    }

//..

[Markus M. (adrock)]

Hi,

also ich würde da etwas anders rangehen.

Ich habe mir für sowas verschiedene kleine Routinen geschrieben, die 
jeweils nur eine einfache Operation auf die LEDs machen. Diese kann man 
dann ggf. kombinieren.

Für Deinen "Kometenschweif" würde ich es so machen:

- Funktion scroll_right()

Schiebt den Inhalt des LED-Feldes eine Position nach rechts.

void scroll_right(ctruct colorRGB *leds, int numleds) {
   int i;

   for(i = numleds-1; i > 0; i--) {
      leds[i] = leds[i-1];
   }
}

- Funktion schweif_next()

void schweif_next(struct colorRGB *leds, int numleds, uint8_t *brightness, uint8_t step) {
   scroll_right(leds, numleds);
   leds[0].r = correction(*brightness);
   if(*brightness >= step) {
      (*brightness) -= step;
   }
   else {
      *brightness = 0;
   }
}

- Hauptprogramm:

#define MAXBRIGHT 100
#define BRIGHTSTEP 10
#define NUMLEDS 20

uint8_t brightness = MAXBRIGHT;
struct colorRGB leds[NUMLEDS];

while(1) {
   schweif_next(leds, NUMLEDS, &brightness, BRIGHTSTEP);
   ws2812_ausgaberoutine(leds, NUMLEDS);
   verzoegerung();
   if(check_taster()) {
      brightness = MAXBRIGHT;
   }
}

Es werden also immer die LEDs nach rechts weiter "gescrollt", und der 
wert für die jeweils erste LED ganz links beginnend von der max. 
Helligkeit immer weiter reduziert.

Das ganze kommt sogar ohne Multiplikation / Division aus und läuft 
dadurch sehr schnell.

[Stefan S. (sschultewolter)]

Hallo Markus,

deine Idee für den Fade finde ich Klasse. Habe mich mal rangesetzt, und 
den Code etwas angepasst, soweit da nichts gegen spricht. ;)

Vielleicht kann es dem TE und anderen helfen.

//..

#define RED    0
#define  GREEN  1
#define BLUE  2

/* Funktion    :  leds_comettail_finished()
* Beschreibung  :  Prueft, ob colorRGB wieder geleert ist
*/
uint8_t leds_comettail_finished (struct colorRGB *leds, uint16_t numLeds, uint8_t color)
{
  for (uint16_t i = 0; i < numLeds; i++)
  {
    if (color == RED)        { if(leds[i].r > 0) return 0; }
    else if (color == GREEN)    { if(leds[i].g > 0) return 0; }
    else /*(color == BLUE)*/    { if(leds[i].b > 0) return 0; }
  }
  return 1;
}

/* Funktion    :  scroll_left()
* Beschreibung  :  Schiebt den Inhalt eines Structs nach links
*/
void scroll_left (struct colorRGB *leds, uint16_t numLeds, uint8_t color)
{
  /*
  * i = 0 -> leds[0] = leds[1]
  *  i = 1 -> leds[1] = leds[2]
  *  i = 2 -> leds[2] = leds[3]
  *  i = n -> leds[n] = leds[n+1]
  */
  for (uint16_t i = 0; i < numLeds-1; i++)
  {
    if (color == RED)      leds[i].r = leds[i+1].r;
    else if (color == GREEN)  leds[i].g = leds[i+1].g;
    else /*if (color == BLUE)*/  leds[i].b = leds[i+1].b;
  }
}

/* Funktion    :  scroll_right()
* Beschreibung :  Schiebt den Inhalt eines Structs nach rechts
*/
void scroll_right (struct colorRGB *leds, uint16_t numLeds, uint8_t color)
{
  /*
  * i = n -> leds[n] = leds[n-1]
  * i = 3 -> leds[3] = leds[2]
  * i = 2 -> leds[2] = leds[1]
  * i = 1 -> leds[1] = leds[0]
  */
  for(uint16_t i = numLeds-1; i > 0; i--)
  {
    if(color == RED)      leds[i].r = leds[i-1].r;
    else if(color == GREEN)    leds[i].g = leds[i-1].g;
    else /*if (color == BLUE)*/  leds[i].b = leds[i-1].b;
  }
}

/* Funktion    :  leds_comettail_left()
* Beschreibung :  Kometenschweif von links nach rechts
*/
void leds_comettail_left (struct colorRGB *leds, uint16_t numLeds, uint8_t color, uint8_t *value, uint8_t step)
{
  scroll_left (leds, numLeds, color);
  if (color == RED)      leds[numLeds-1].r = correction[*value];
  else if (color == GREEN)  leds[numLeds-1].g = correction[*value];
  else /*if (color == BLUE)*/  leds[numLeds-1].b = correction[*value];
  
  if (*value >= step)      (*value) -= step;
  else            *value = 0;
}

/* Funktion    :  leds_comettail_right()
* Beschreibung :  Kometenschweif von rechts nach links
*/
void leds_comettail_right(struct colorRGB *leds, uint16_t numLeds, uint8_t color, uint8_t *value, uint8_t step)
{
  scroll_right (leds, numLeds, color);
  if (color == RED)      leds[0].r = correction[*value];
  else if (color == GREEN)  leds[0].g = correction[*value];
  else /*if (color == BLUE)*/  leds[0].b = correction[*value];
  
  if (*value >= step)      (*value) -= step;
  else            *value = 0;
}
//..

//..
  while(1)
  {
    static uint8_t value = 255;
    static uint16_t lastTicks = 0;    
    if(ticks - lastTicks >= 5) // ticks * 10ms
    {
      lastTicks = ticks;
      static uint8_t val_r = 255;
      static uint8_t state_r = 0;
      if(state_r) leds_comettail_left(leds, NUM_LEDS, RED, &val_r, 5);
      else leds_comettail_right(leds, NUM_LEDS, RED, &val_b, 25);
      if(leds_comettail_finished(leds, NUM_LEDS, RED)) { val_r = value; state_r ^= 1; }

      static uint8_t val_g = 255;
      static uint8_t state_g = 1;
      if(state_g) leds_comettail_left(leds, NUM_LEDS, GREEN, &val_g, 15);
      else leds_comettail_right(leds, NUM_LEDS, GREEN, &val_g, 15);
      if(leds_comettail_finished(leds, NUM_LEDS, GREEN)) { val_g = value; state_g ^= 1; }
      
      static uint8_t val_b = 0;
      static uint8_t state_b = 0;
      if(state_b) leds_comettail_left(leds, NUM_LEDS, BLUE, &val_b, 25);
      else leds_comettail_right(leds, NUM_LEDS, BLUE, &val_b, 5);
      if(leds_comettail_finished(leds, NUM_LEDS, BLUE)) { val_b = value; state_b ^= 1; }
      
      ws2812_setleds(leds, NUM_LEDS);
    }
  }
//..

[Markus M. (adrock)]

Ja, danke, sehr schön :)

Der Charme der einzelnen Funktionen ist es eben, dass man sie auch für 
andere Effekte benutzen/kombinieren kann.

Ich hatte das ganze bei einer LED-Matrix mal so weit getrieben, dass ich 
am Ende den gesamten Ablauf über Tabellen bzw. Strukturen steuern 
konnte.

Man konnte "Szenen" definieren, die aus einer Generatorfunktion und 
beliebeig vielen nachgeschalteten Effektfunktionen bestanden, die dann 
die Ausgabe der Generatorfunktion noch weiter verändert haben.

So konnte man durch geschickte Kombination interessante Effekte 
generieren. Z.B. ein Muster nur in 1/4 der Matrix generieren lassen und 
dann in die drei anderen Quadranten spiegeln, faden etc.

[Stefan S. (sschultewolter)]

Ja,

das sehe ich auch so Markus. Ich nutze selber hauptsächlich eine 
angepasste Version der LIGHT WS2812B Lib. Vorteil ist, hier ist so gut 
wie nichts bereits vorhanden. Es beschränkt sich auf die eigentliche 
Ansteuerung.

Kenne die FastLed Lib. Dort sind einige nette Effekte drin. Auch ist die 
Farbanpassung sehr gut gelungen, aber bei den meisten Effekten hat man 
dann nur noch wenig Möglichkeiten, großartig einzugreifen.

Ich bin dabei, davon die ein oder anderen Math-Operation zu portieren.

[Karl H. (kbuchegg)]

Aber auch im geposteten Original lassen sich ein paar Dinge lernen

    uint8_t val = (value / (width-1)) * ((width-1)-led);

das willst du nicht so berechnen.
Du willst in derartigen Berechnungen die Division immer ganz zum Schluss 
machen.
Denn 12 / 7 ergibt 1. Und zwar 1 geradeaus!
Das ist eine Division Integer durch Integer. Und damit ist das Ergebnis 
ebenfalls ein Integer. Keine Kommastellen!

void sinelon_new(struct colorRGB *leds, uint8_t numLeds, uint8_t width, int16_t *pos, uint8_t c, uint8_t value)

ich sehe jetzt ehrlich gesagt nicht, wozu pos ein Pointer sein muss. Das 
weitersetzen des Effekts an die nächste Position kann der Aufrufer 
genausogut machen und da er die Länge einer Led Zeile kennt, kann er 
auch den Überlauf entsprechend handhaben, so einer eintreten sollte.

warum sollte ich das für jede Farbe getrennt aufrufen?
Speziell wenn die Funktion dann eigenmächtig pos weiterzählt ist damit 
faktisch schon fast garantiert, dass ich bei 3-fach notwendigem Aufruf 
der Funktion jede Farbe an eine andere Stelle bekomme.

Die Funktion hat die Aufgabe die Farbwerte der Led-Zeile aufgrund des zu 
implementierenden Effektes und der Vorgabe einer Farbe zu füllen. Dann 
gibt der Funktion aber auch die Farbe als ganzes. Wenn eine Farbe 
mittels einer struct colorRGB beschrieben wird, dann übergib auch genau 
so ein Ding um die Farbe in ihrer Gesamtheit zu beschreiben. Dann ist 
dann auch dieser Nonsense

      switch(c)
      {
        case 0: leds[*pos - led].r = correction[val]; break;
        case 1: leds[*pos - led].g = correction[val]; break;
        case 2: leds[*pos - led].b = correction[val]; break;
      }

nicht mehr nötig.

Wenn schon Farbe, dann auch wirklich Farbe:

void sinelon_new(struct colorRGB *leds, uint8_t numLeds, uint8_t width, int16_t pos, struct colorRGB baseColor )

oder

void sinelon_new(struct colorRGB *leds, uint8_t numLeds, uint8_t width, int16_t pos, struct colorRGB *baseColor )

(Der Unterschied ist nur, dass das eine mal ein Farb-Objekt direkt 
übergben wird, das andere mal ein Pointer darauf)

Dann muss eben die Funktion in jedem Schritt jeweils die Werte für Rot, 
Grün und Blau berechnen.

Jetzt erst mal davon abgesehen, dass so ein Schleifenkonstrukt beim 
Aufrufer nicht unbedingt eine gute Idee ist, spricht ja erst mal nichts 
gegen

    struct cometColor = { 0, 6, 12 };

    ...
    for( i = 0; i < NUM_LEDS0 + 8; i++ )
    {
      sinelon_new( leds, NUM_LEDS, 8, i, cometColor );
      ws2812_setleds( leds, NUM_LEDS );
    }

Dann klappts auch mit dem Effekt.

(Wobei natürlich so ein Basisbaukasten, aus dem man dann weitere Dinge 
zusammensetzt, schon eine ganz andere Liga darstellt)

[Ben W. (ben_w)]

ich hatte mich mal an einer kleinen "animations Engine" wenn man das 
überhaupt so nennen kann in C++ versucht.
(https://github.com/benwilliam/equinox_clock/tree/master/WS2812b_SPI/ws2811_2/graphics)

[Stefan S. (sschultewolter)]

Hier noch einmal ein alternativer Ansatz. Die Funktionen sind von 
einander getrennt, da es hier doch eher nur noch wenige Stellen 
identisch sind.

void leds_comettail(struct cRGB *ledarray, const int16_t numLeds, int16_t offset, uint8_t color, int16_t *posLed, uint8_t *revLeds)
{
  #define DIM_CORRECTION(x)  dim_curve[x]
  
  const int16_t WIDTH = numLeds/2;
  const uint8_t VALUE_MAX = 127;
  const uint8_t SHOW_LAST_DOT = 0;
  const uint8_t WAIT_FOR_NEW_RUN = 1;
  
  int16_t maxPos = numLeds - 1;
  int16_t minPos = 0;
  
  // Limits setzen
  if (WAIT_FOR_NEW_RUN)
  {
    maxPos = maxPos + (WIDTH + 1);
    minPos = minPos - (WIDTH + 1);
  }
  
  // Richtungsaenderung abfragen
  if (*posLed >= maxPos)
  {
    *posLed = maxPos;
    *revLeds = 1;
  }
  else if (*posLed <= minPos)
  {
    *posLed = minPos;
    *revLeds = 0;
  }
  
  int16_t pos = *posLed + offset;
  uint8_t value;
  
  // Nachlaufende Leds
  if (*revLeds)
  {
    for (uint8_t i = 0; i <= WIDTH; i++)
    {
      if(*posLed + i < numLeds && *posLed + i >= 0)
      {
        value = (WIDTH - i) * (VALUE_MAX / WIDTH);
        ledarray[pos + i].raw[color] = DIM_CORRECTION(value);
      }
    }
  }
  else
  {
    for (uint8_t i = 0; i <= WIDTH; i++)
    {
      if (*posLed - i >= 0 && *posLed - i < numLeds)
      {
        value = (WIDTH - i) * (VALUE_MAX / WIDTH);
        ledarray[pos - i].raw[color] = DIM_CORRECTION(value);
      }
    }
  }
  
  // Aktuelle Led
  if (*posLed >= 0 && *posLed < numLeds-1) ledarray[pos].raw[color] = DIM_CORRECTION(VALUE_MAX);
  if (SHOW_LAST_DOT)
  {
    if (*posLed < 0) ledarray[0 + offset].raw[color] = DIM_CORRECTION(VALUE_MAX);
    else if (*posLed > numLeds-1) ledarray[(numLeds - 1) + offset].raw[color] = DIM_CORRECTION(VALUE_MAX);
  }
  
  // Positionberechnung fuer naechsten Durchlauf
  if(*revLeds)  --(*posLed);
  else      ++(*posLed);
}

void leds_knightrider (struct cRGB *ledarray, int16_t numLeds, int16_t offset, uint8_t color, int16_t *posLed, uint8_t *revLeds)
{
  #define DIM_CORRECTION(x)  dim_curve[x]
  
  const int16_t WIDTH = numLeds/3;
  const uint8_t VALUE_MAX = 255;

  // Richtungsaenderung abfragen
  if (*posLed >= numLeds-1)
  {
    *posLed = numLeds-1;
    *revLeds = 1;
  }
  else if (*posLed <= 0)
  {
    *posLed = 0;
    *revLeds = 0;
  }

  int16_t pos = *posLed + offset;
  uint8_t value;
  
  // Leds links der aktuellen Led
  for(uint8_t i = 0; i <= WIDTH; i++)
  {
    value = (WIDTH - i) * (VALUE_MAX / WIDTH);
    if (*posLed - i >= 0) ledarray[pos - i].raw[color] = DIM_CORRECTION(value);
  }
  
  // Aktuelle Led
  ledarray[pos].raw[color] = DIM_CORRECTION(VALUE_MAX);
  
  // Leds rechts der aktuellen Led
  for(uint8_t i = 0; i <= WIDTH; i++)
  {
    value = (WIDTH - i) * (VALUE_MAX / WIDTH);
    if (*posLed + i < numLeds) ledarray[pos + i].raw[color] = DIM_CORRECTION(value);
  }
  
  // Positionberechnung fuer naechsten Durchlauf
  if (*revLeds)  --(*posLed);
  else      ++(*posLed);
}