C Effekte Algorithmen gesucht

Marion Gast #4400596
Lesenswert?
• ▲
▼ 
Hallo,

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

Die Anordnung sieht so aus
1
void test(struct cHSV *hsv, int8_t *pos)

2
{

3
  const uint8_t ledOrder[3][3]=

4
  {

5
    {0, 3, 6},  // Zeile 1

6
    {1, 4, 7},  // Zeile 2

7
     {2, 5, 8},  // Zeile 3

8
  };

9


10
  uint8_t x  = 0;

11
  uint8_t y = *pos;

12
  

13
  for(x = 0; x < 3; x++)

14
  hsv[ledOrder[x][y]].hue += 32;

15
    

16
  if(*pos >= 2) *pos = 0;

17
  else (*pos)++;

18
}


Gibts da nun ggf. schöne Algorithmen, die mal wer zusammengetragen hat.
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Marion Gast #4400881
Lesenswert?
• ▲
▼ 
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.

1
const uint8_t pattern_step1[3][3]

2
{

3
  {1, 1, 1},

4
  {0, 0, 0},

5
  {0, 0, 0}

6
};

7
const uint8_t pattern_step1[3][3]

8
{

9
  {0, 0, 0},

10
  {1, 1, 1},

11
  {0, 0, 0}

12
};

13
const uint8_t pattern_step1[3][3]

14
{

15
  {0, 0, 0},

16
  {0, 0, 0},

17
  {1, 1, 1}

18
};
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Conny G. #4400892
Lesenswert?
• ▲
▼ 
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Stefan F. Gast #4401016
Lesenswert?
• ▲
▼ 
> 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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #4401140
Lesenswert?
• ▲
▼ 
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?
1
const uint8_t Muster1[3] [3][3] =

2
{

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

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

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

6
};


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


1
const uint8_t Muster2[6] [3][3] =

2
{

3
  { { 1, 0, 0 },

4
    { 0, 0, 0 },

5
    { 0, 0, 0 } },

6


7
  { { 0, 1, 0 },

8
    { 1, 0, 0 },

9
    { 0, 0, 0 } },

10


11
  { { 0, 0, 1 },

12
    { 0, 1, 0 },

13
    { 1, 0, 0 } },

14
 

15
  { { 0, 0, 0 },

16
    { 0, 0, 1 },

17
    { 0, 1, 0 } },

18


19
  { { 0, 0, 0 },

20
    { 0, 0, 0 },

21
    { 0, 0, 1 } },

22


23
  { { 0, 0, 0 },

24
    { 0, 0, 0 },

25
    { 0, 0, 0 } },

26
};
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Marion Gast #4402019
Lesenswert?
• ▲
▼ 
1
const uint8_t pattern0[][3]=

2
{

3
  {

4
    0b00000001,

5
    0b00000000,

6
    0b00000000,

7
  },

8
  {

9
    0b00000010,

10
    0b00000011,

11
    0b00000000,

12
  },

13
  {

14
    0b00000100,

15
    0b00000100,

16
    0b00000111,

17
  },

18
  {

19
    0b00000100,

20
    0b00000000,

21
    0b00000000,

22
  },

23
  {

24
    0b00000010,

25
    0b00000110,

26
    0b00000000,

27
  },

28
  {

29
    0b00000001,

30
    0b00000001,

31
    0b00000111,

32
  },

33
  {

34
    0b00000000,

35
    0b00000000,

36
    0b00000100,

37
  },

38
  {

39
    0b00000000,

40
    0b00000110,

41
    0b00000010,

42
  },

43
  {

44
    0b00000111,

45
    0b00000001,

46
    0b00000001,

47
  },

48
  {

49
    0b00000000,

50
    0b00000000,

51
    0b00000001,

52
  },

53
  {

54
    0b00000000,

55
    0b00000011,

56
    0b00000010,

57
  },

58
  {

59
    0b00000111,

60
    0b00000100,

61
    0b00000100,

62
  }

63
};

64


65
void show_pattern(struct cHSV *hsv, int8_t *pos, const uint8_t array[][3])

66
{

67
    printf("\n");

68
    for(uint8_t x = 0; x < 3; x++)

69
    {

70
      for(uint8_t y = 0; y < 3; y++)

71
      {

72
        if(array[*pos][x] & (1<<(2-y)))

73
        {

74
          printf("x");

75
          hsv[getLed(x,y)].hue +=85;

76
        }

77
        else printf("o");

78
      }

79
      printf("\n");

80
    }

81
    

82
    if(++(*pos)>= sizeof(pattern0)/3) {*pos = 0;}

83
}

84


85
show_pattern(ledsHsv, &pos, patter0);


Hab es so gelöst, soweit okay?
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren