Integerwerte aus einem Array zerlegen und durch Schleifen laufen lassen

[Kolja L. (kolja82)]

Guten Abend

Nachdem mir mein erster, dynamischer, Ansatz zu komplex ist,
würde ich es gerne erstmal so versuchen:

  const uint8_t lauflicht[18][2] = {
    {100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100},
    {010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010}
  };

  for (int j = 0; j <= 1; j++) {
    for (int i = 1; i <= 18; i++) {

      setPWM(j, lauflicht[i][j].substring(0, 1), lauflicht[i][j].substring(0, 1), lauflicht[i][j].substring(0, 1));
    }
   delay(1000);
  }

Was soll der Code machen?

Die Funktion setPWM() erwartet 4 Parameter.
Der erste ist die ID der RGB Leiste (1-18), die nächsten drei die 
Helligkeit der einzelnen Farben von 0-9.

So kann in dem Array ein "komplexes" Lauflicht programmiert werden.

Was macht der Code?
Nix, der Compiler (ArduinoIDE) meckert schon bei dem Array:
too many initializers for 'const uint8_t [2] {aka const unsigned char 
[2]}'

Dabei habe ich doch nur ein funktionierendes Array erweitert.

Könnte mir da jemand helfen?

[Johannes S. (Gast)]

du hast die Initialisierung für ein Array

lauflicht[2][18]

definiert.

und substrings auf ein uint8_t geht auch nicht so wie du möchtest.

010 ist eine Konstante im Octalsystem.

[Kolja L. (kolja82)]

OK, die Initialiesierung muss andersherum.
Das Beispiel war eine 3x3 Matrix ;-)

  int lauflicht[6][18] = {
    {100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100},
    {010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010},
    {100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100},
    {010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010},
    {100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100},
    {010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010}
  };

  for (int j = 0; j <= 1; j++) {
    for (int i = 1; i <= 18; i++) {

      setPWM(j, lauflicht[i][j].substring(0, 1), lauflicht[i][j].substring(0, 1), lauflicht[i][j].substring(0, 1));
    }
   delay(1000);
  }

So passt zumindest das Array :-)

Johannes S. schrieb:
> und substrings auf ein uint8_t geht auch nicht so wie du möchtest.

Stimmt!
Verstehe ich jetzt auch.

Muss ich die Zahl jetzt erst in ein String wandeln,
oder kann ich die "010" auch als Integer zerlegen?
Modulo fällt ja wegen der führenden Nullen weg...

Danke schomal

[Johannes S. (Gast)]

Vorschlag: Array von Strukturelementen benutzen.

typedef  struct {
  uint8_t stripeIndex;
  uint8_t intensityRed;
  uint8_t intensityGreen;
  uint8_t intensityBlue;
} RGBITEM;

const RGBITEM rgbItems[] = {
  {0, 1, 0, 0 },
  {1, 255, 128, 42 }     // und noch viele mehr
};

void setRGBItem(uint16_t index) {
  setPWM(rgbItems[index].stripeIndex,
         rgbItems[index].intensityRed,
         rgbItems[index].intensityGreen,
         rgbItems[index].intensityBlue);
}

[Kolja L. (kolja82)]

Johannes S. schrieb:
> Vorschlag: Array von Strukturelementen benutzen.

Das ist mir leider nicht anschaulich genug.
Aber prinzipiell verstehe ich , was du meinst.

Für das einfachere programmieren des Lichteffektes hätte ich gerne jeden 
Frame in einer Zeile.

Sollte ja auch funktionieren, wenn ich nur die "010" in R=0, G=1, B=0 
zerlegt bekommen würde.

Aber auch dir danke für die Idee!

[Dr. Sommer (Gast)]

Kolja L. schrieb:
> Modulo fällt ja wegen der führenden Nullen weg...

Wieso, dann wird halt 0 übergeben:

setPWM(j, lauflicht[i][j] / 100, (lauflicht[i][j] / 10) % 10, lauflicht[i][j] % 10);

So werden die 3 Ziffern auseinander gedröselt und einzeln übergeben. Das 
ist allerdings ziemlich ineffizient, weil die meisten Prozessoren solche 
Divisionen nicht direkt können. Effizienter wäre z.B. so:

  uint16_t lauflicht[6][18] = {
    {0x100, 0x100, 0x100 ...},
    {0x010, 0x010, 0x010, ...},
    ...
  };

setPWM(j, lauflicht[i][j] / 256, (lauflicht[i][j] / 16) % 16, lauflicht[i][j] % 16);

Divisionen/Modulo mit 2-erPotenzen werden als Bits-Operationen 
kompiliert und sind viel schneller. Dazu werden die Zahlen hexadezimal 
definiert. Außerdem sollte man den Typ des Arrays als uint16_t 
definieren, damit er nicht unnötig groß ist (int kann z.B. auch 32bit 
groß sein, obwohl die Zahl nie größer 4095 wird), und um negative Zahlen 
ganz auszuschließen. Du könntest due setPWM Funktion so umbauen dass sie 
Zahlen von 0-15 nimmt; dann hast du gleich eine höhere Auflösung. Auf 
Computern im 10er-System zu rechnen ist generell nicht so optimal.
Alternativ kann man die 3 Farbwerte in 3 einzelne uint8_t packen, das 
braucht aber 50% mehr Speicher.
Warum speicherst du überhaupt zig mal die gleichen Werte im Array? Das 
ist sinnlos...

Als Schleifenzähler (i, j) sollte man size_t nehmen, weil dies 
vorzeichenlos ist und auf allen Plattformen groß genug für alle Arrays; 
"int" kann z.B. auf AMD64 zu klein sein.

[Johannes S. (Gast)]

Kolja L. schrieb:
> Das ist mir leider nicht anschaulich genug.
> Aber prinzipiell verstehe ich , was du meinst.

Mit den Strukturelementen kann R,G, und B jeweils 0...255 sein. Man kann 
das auch in einen Hexadezimalwert schreiben, dann wäre es z.B. 
0xiirrggbb kodiert. Dann kann ii der Stripindex sein und der Rest die 
Farbwerte. Kommt aufs gleiche raus, aber mit der Struktur ist der 
Zugriff besser lesbar, aus dem uint32_t musst die Element maskieren und 
schieben, für rr z.B. ((value & 0x00ff0000) >> 16;

[Kolja L. (kolja82)]

Dr. Sommer schrieb:
> uint16_t lauflicht[6][18] = {
>     {0x100, 0x100, 0x100 ...},
>     {0x010, 0x010, 0x010, ...},
>     ...
>   };

Das möchte ich, auch wenn es vielleicht albern ist,
der Übersichtlichkeit wegen nicht verwenden.

Dr. Sommer schrieb:
> setPWM(j, lauflicht[i][j] / 100, (lauflicht[i][j] / 10) % 10,
> lauflicht[i][j] % 10);

Wenn das funktionieren würde, ware ja super!

Leider gibt dieser Code:

void loop() {

  int lauflicht[6][18] = {
    {100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100},
    {010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010},
    {100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100},
    {010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010},
    {100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100},
    {010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010, 010}
  };


  for (int j = 1; j <= 6; j++) {
    
    for (int i = 1; i <= 18; i++) {     
      Serial.print("J:");      Serial.print(j);      Serial.print(" I: ");      Serial.print(i); 
      Serial.print(" R:");      Serial.print(lauflicht[j][i] / 100); 
      Serial.print(" G:");      Serial.print((lauflicht[j][i] / 10) % 10); 
      Serial.print(" B:");      Serial.println(lauflicht[j][i] % 10);      
      setPWM(j, lauflicht[j][i] / 100, (lauflicht[j][i] / 10) % 10, lauflicht[j][i] % 10);
    }
    
    delay(1000);
    
  }


  
} // loop

Diese Ausgabe:

J:1 I: 1 R:0 G:0 B:8
J:1 I: 2 R:0 G:0 B:8
J:1 I: 3 R:0 G:0 B:8
J:1 I: 4 R:0 G:0 B:8
J:1 I: 5 R:0 G:0 B:8
J:1 I: 6 R:0 G:0 B:8
J:1 I: 7 R:0 G:0 B:8
J:1 I: 8 R:0 G:0 B:8
J:1 I: 9 R:0 G:0 B:8
J:1 I: 10 R:0 G:0 B:8
J:1 I: 11 R:0 G:0 B:8
J:1 I: 12 R:0 G:0 B:8
J:1 I: 13 R:0 G:0 B:8
J:1 I: 14 R:0 G:0 B:8
J:1 I: 15 R:0 G:0 B:8
J:1 I: 16 R:0 G:0 B:8
J:1 I: 17 R:0 G:0 B:8
J:1 I: 18 R:1 G:0 B:0
J:2 I: 1 R:1 G:0 B:0
J:2 I: 2 R:1 G:0 B:0
J:2 I: 3 R:1 G:0 B:0
J:2 I: 4 R:1 G:0 B:0
J:2 I: 5 R:1 G:0 B:0
J:2 I: 6 R:1 G:0 B:0
J:2 I: 7 R:1 G:0 B:0
J:2 I: 8 R:1 G:0 B:0
J:2 I: 9 R:1 G:0 B:0
J:2 I: 10 R:1 G:0 B:0
J:2 I: 11 R:1 G:0 B:0
J:2 I: 12 R:1 G:0 B:0
J:2 I: 13 R:1 G:0 B:0
J:2 I: 14 R:1 G:0 B:0
J:2 I: 15 R:1 G:0 B:0
J:2 I: 16 R:1 G:0 B:0
J:2 I: 17 R:1 G:0 B:0
J:2 I: 18 R:0 G:0 B:8

Werde mir trotzdem nochmal die Modulo Funktion anschauen.

[Dr. Sommer (Gast)]

Kolja L. schrieb:
> Diese Ausgabe:

Tja, weil die führende 0 die Zahl als Oktal-Zahl markiert, somit ist 
"010" dezimal der Wert 8.

[Johannes S. (Gast)]

Weil 010 = 8 ist. Schrieb ich doch schon.
Heute ist irgendwie der Tag des nicht-Lesens...

[Kolja L. (kolja82)]

Dr. Sommer schrieb:
> Kolja L. schrieb:
>> Modulo fällt ja wegen der führenden Nullen weg...
>
> Wieso, dann wird halt 0 übergeben:

Dann habe ich das falsch verstanden?

[Kolja L. (kolja82)]

Aber so:

void loop() {

  uint16_t  lauflicht[2][18] = {
    {0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100},
    {0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010}
  };


  for (int j = 1; j <= 2; j++) {
    
    for (int i = 1; i <= 18; i++) {     
      Serial.print("J:");      Serial.print(j);      Serial.print(" I: ");      Serial.print(i); 
      Serial.print(" R:");      Serial.print(lauflicht[j][i] / 256); 
      Serial.print(" G:");      Serial.print((lauflicht[j][i] / 16) % 16); 
      Serial.print(" B:");      Serial.println(lauflicht[j][i] % 16);      
      setPWM(j, lauflicht[j][i] / 256, (lauflicht[j][i] / 16) % 16, lauflicht[j][i] % 16);
    }
    
    delay(2000);
    
  }


  
} // loop

Funktioniert es leider auch nicht:

J:1 I: 1 R:0 G:1 B:0
J:1 I: 2 R:0 G:1 B:0
J:1 I: 3 R:0 G:1 B:0
J:1 I: 4 R:0 G:1 B:0
J:1 I: 5 R:0 G:1 B:0
J:1 I: 6 R:0 G:1 B:0
J:1 I: 7 R:0 G:1 B:0
J:1 I: 8 R:0 G:1 B:0
J:1 I: 9 R:0 G:1 B:0
J:1 I: 10 R:0 G:1 B:0
J:1 I: 11 R:0 G:1 B:0
J:1 I: 12 R:0 G:1 B:0
J:1 I: 13 R:0 G:1 B:0
J:1 I: 14 R:0 G:1 B:0
J:1 I: 15 R:0 G:1 B:0
J:1 I: 16 R:0 G:1 B:0
J:1 I: 17 R:0 G:1 B:0
J:1 I: 18 R:239 G:15 B:14
J:2 I: 1 R:254 G:14 B:15
J:2 I: 2 R:147 G:11 B:0
J:2 I: 3 R:63 G:15 B:14
J:2 I: 4 R:0 G:0 B:15
J:2 I: 5 R:0 G:0 B:0
J:2 I: 6 R:0 G:0 B:0
J:2 I: 7 R:0 G:0 B:0
J:2 I: 8 R:0 G:0 B:0
J:2 I: 9 R:0 G:0 B:0
J:2 I: 10 R:239 G:15 B:14
J:2 I: 11 R:254 G:14 B:15
J:2 I: 12 R:0 G:0 B:0
J:2 I: 13 R:0 G:0 B:0
J:2 I: 14 R:0 G:0 B:0
J:2 I: 15 R:0 G:0 B:0
J:2 I: 16 R:0 G:0 B:1
J:2 I: 17 R:0 G:0 B:0
J:2 I: 18 R:0 G:4 B:0


Vielleicht reden wir aneinander vorbei?

[Dr. Sommer (Gast)]

Könnte vielleicht daran liegen, dass die Indices des äußeren Arrays 0-1 
sind, und du 1-2 iterierst... Lies doch mal ein Buch über C.

[Kolja L. (kolja82)]

Dr. Sommer schrieb:
> Könnte vielleicht daran liegen, dass die Indices des äußeren
> Arrays 0-1
> sind, und du 1-2 iterierst... Lies doch mal ein Buch über C.

Danke, Tippfehler, sorry.

Ändert aber auch nichts.

[Dr. Sommer (Gast)]

Kolja L. schrieb:
> Ändert aber auch nichts.

Unwahrscheinlich. Zeig den korrigierten Code.

[Kolja L. (kolja82)]

Dr. Sommer schrieb:
> Unwahrscheinlich. Zeig den korrigierten Code.

Mea culpa, da war ein "j" wo ein "i" sein sollte...:

void loop() {

  uint16_t  lauflicht[2][18] = {
    {0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100},
    {0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010, 0x010}
  };


  for (int j = 0; j <= 1; j++) {
    
    for (int i = 0; i <= 17; i++) {     
      Serial.print("J:");      Serial.print(j);      Serial.print(" I: ");      Serial.print(i); 
      Serial.print(" R:");      Serial.print(lauflicht[j][i] / 256); 
      Serial.print(" G:");      Serial.print((lauflicht[j][i] / 16) % 16); 
      Serial.print(" B:");      Serial.println(lauflicht[j][i] % 16);      
      setPWM(i, (lauflicht[j][i] / 256) * 400, ((lauflicht[j][i] / 16) % 16) * 400, (lauflicht[j][i] % 16) *400);
    }
    
    delay(2000);
    
  }


  
} // loop

das funktioniert schon mal, Danke!