C Effekte Algorithmen gesucht

[Marion (Gast)]

Hallo,

ich habe eine kleine Matrix mti 3x3 Leds aufgebaut (WS2812B).

Die Anordnung sieht so aus

void test(struct cHSV *hsv, int8_t *pos)
{
  const uint8_t ledOrder[3][3]=
  {
    {0, 3, 6},  // Zeile 1
    {1, 4, 7},  // Zeile 2
     {2, 5, 8},  // Zeile 3
  };

  uint8_t x  = 0;
  uint8_t y = *pos;
  
  for(x = 0; x < 3; x++)
  hsv[ledOrder[x][y]].hue += 32;
    
  if(*pos >= 2) *pos = 0;
  else (*pos)++;
}

Gibts da nun ggf. schöne Algorithmen, die mal wer zusammengetragen hat.

[-.-.- (Gast)]

für was schöne Algorithmen?

[Cyblord -. (cyblord)]

Ein Algorithmus ist eine Berechnungsvorschrift. Bist du sicher dass es 
das ist was du suchst?

[Der Bub (Gast)]

Grossartig. Gibt's davon ein Video ?

[Peter D. (peda)]

-.-.- schrieb:
> für was schöne Algorithmen?

Er meint damit Blinkmuster (Animationen).

Ich würde sowas nicht hart codieren, sondern über eine Tabelle im Flash 
steuern, das ist flexibler.

[Marion (Gast)]

Peter D. schrieb:
> -.-.- schrieb:
>> für was schöne Algorithmen?
>
> Er meint damit Blinkmuster (Animationen).
>
> Ich würde sowas nicht hart codieren, sondern über eine Tabelle im Flash
> steuern, das ist flexibler.

Wie kann sowas dann aussehen im Beispiel an den Code von mir oben? Da 
kommt doch sehr viel an Speicher zusammen, wenn ich jede Animation da 
einzeln ablegen will.

const uint8_t pattern_step1[3][3]
{
  {1, 1, 1},
  {0, 0, 0},
  {0, 0, 0}
};
const uint8_t pattern_step1[3][3]
{
  {0, 0, 0},
  {1, 1, 1},
  {0, 0, 0}
};
const uint8_t pattern_step1[3][3]
{
  {0, 0, 0},
  {0, 0, 0},
  {1, 1, 1}
};

[Conny G. (conny_g)]

Ich habe letztes Jahr WS2812 Weihnachtsbäumchen für die Kinder gebastelt 
und bei der Entwicklung der Animationen festgestellt, dass man relativ 
schnell selber auf ein Pattern kommt, dass auf konfigurierbare Weise 
verschiedene Animationen ausspuckt.
Wenn man mal anfängt einen Farbwechsler zu machen, der über die LEDs die 
Farben sanft wechselt und dann weitermacht die Geschwindigkeit und die 
Steps für den Wechsel einzustellen und vielleicht noch weitere Parameter 
einzuführen hat man innerhalb von ein paar Stunden einen Algorithmus, 
der verschiedene Muster ausspuckt.
Und wenn man dann eine Logik einbaut, die diese Parameter mehr oder 
weniger zufällig oder inkrementell weiterzählt/weiterrechnet, dann 
wechseln sich ständig ähnliche Muster ab und es wird nicht langweilig.

[matrixstorm (Gast)]

Ggf. ist das das richtige fuer dich:

--> Glediator (http://www.solderlab.de/index.php/software/glediator)

[Stefan F. (Gast)]

> Da kommt doch sehr viel an Speicher zusammen

Ja, wenn man acht Bits verwendet, um die Werte 0 und 1 zu speichern.

Du kannst in einem Byte aber den Zustand für 8 LED's speichern. Dann 
brauchst du nur noch 1/8 so viel Speicher.

Oder du nimmst ein Byte pro LED, aber das Byte stellt 8 aufeinander 
folgende Schritte (Takte) dar.

[Karl H. (kbuchegg)]

Marion schrieb:

> Wie kann sowas dann aussehen im Beispiel an den Code von mir oben? Da
> kommt doch sehr viel an Speicher zusammen, wenn ich jede Animation da
> einzeln ablegen will.

Klar kommt da was zusammen. Aber von nichts kommt nichts.
Im übrigen ist dein Beispiel ja von der simplen Sorte.
Im ersten Schritt sind alle LED der ersten Zeile auf 1, im 2. Schritt 
alle der 2. ten Zeile und um 3. Schritt alle der 3.ten Zeile. Das kann 
man mit vorgefertigten Mustern abhandlen, das kann man aber auch 
ausprogrammieren.

Vorgefertigte Muster setzt man dann ein, wenn es kein einfaches Schema 
gibt, wie man aus irgendwelchen Zahlen herleiten kann, wie die LED sein 
müssen. In deinem Beispiel ist das Schama ja offensichtlich. Im Schritt 
n sind die LED der Zeile n auf 1, alle anderen sind 0.

Aber selbst wenn man  vorgefertigte Muster einsetzt, würde man das nicht 
so machen, wie du das gemacht hast, sondern man definiert sich eben ein 
komplettes Muster. In deinem Fall wäre das dann eben ein 3 dimensionales 
Array. Warum denn nicht?

const uint8_t Muster1[3] [3][3] =
{
  { { 1, 1, 1 },   { 0, 0, 0 },    { 0, 0, 0 } },
  { { 0, 0, 0 },   { 1, 1, 1 },    { 0, 0, 0 } },
  { { 0, 0, 0 },   { 0, 0, 0 },    { 1, 1, 1 } }
};

Der erste Index ist die Schrittnummer und die restlichen beiden, na die 
kennst du ja schon.

const uint8_t Muster2[6] [3][3] =
{
  { { 1, 0, 0 },
    { 0, 0, 0 },
    { 0, 0, 0 } },

  { { 0, 1, 0 },
    { 1, 0, 0 },
    { 0, 0, 0 } },

  { { 0, 0, 1 },
    { 0, 1, 0 },
    { 1, 0, 0 } },
 
  { { 0, 0, 0 },
    { 0, 0, 1 },
    { 0, 1, 0 } },

  { { 0, 0, 0 },
    { 0, 0, 0 },
    { 0, 0, 1 } },

  { { 0, 0, 0 },
    { 0, 0, 0 },
    { 0, 0, 0 } },
};

[Marion (Gast)]

const uint8_t pattern0[][3]=
{
  {
    0b00000001,
    0b00000000,
    0b00000000,
  },
  {
    0b00000010,
    0b00000011,
    0b00000000,
  },
  {
    0b00000100,
    0b00000100,
    0b00000111,
  },
  {
    0b00000100,
    0b00000000,
    0b00000000,
  },
  {
    0b00000010,
    0b00000110,
    0b00000000,
  },
  {
    0b00000001,
    0b00000001,
    0b00000111,
  },
  {
    0b00000000,
    0b00000000,
    0b00000100,
  },
  {
    0b00000000,
    0b00000110,
    0b00000010,
  },
  {
    0b00000111,
    0b00000001,
    0b00000001,
  },
  {
    0b00000000,
    0b00000000,
    0b00000001,
  },
  {
    0b00000000,
    0b00000011,
    0b00000010,
  },
  {
    0b00000111,
    0b00000100,
    0b00000100,
  }
};

void show_pattern(struct cHSV *hsv, int8_t *pos, const uint8_t array[][3])
{
    printf("\n");
    for(uint8_t x = 0; x < 3; x++)
    {
      for(uint8_t y = 0; y < 3; y++)
      {
        if(array[*pos][x] & (1<<(2-y)))
        {
          printf("x");
          hsv[getLed(x,y)].hue +=85;
        }
        else printf("o");
      }
      printf("\n");
    }
    
    if(++(*pos)>= sizeof(pattern0)/3) {*pos = 0;}
}

show_pattern(ledsHsv, &pos, patter0);

Hab es so gelöst, soweit okay?