Led Matrix in 1D Array umwandeln

[Sebbi (Gast)]

Hallo,

ich habe mehrere Led Module (3x3) hintereinandergeschaltet. Insgesamt 8 
Stück. Das ganze wird über ein Array mit Werten befeuert.

Nun geht es darum, dass ich die Koordinaten xy in ein 1D umrechne. Die 
Anordnung ist wie im Kommentar zu erkennen. Ist die Funktion soweit 
okay, oder kann man die ggf. kürzen?

Die Reihen sind fix. Die Länge der Spalten hängt von der Menge 
aneinandergereihter Module ab.

int getLedNumber(int x, int y)
{
  /*
  Panel0      Panel1      Panel2
  00  01  02  |  09  10  11  |  18  19  20
  03  04  05  |  12  13  14  |  21  22  23
  06  07  08  |  15  16  17  |  24  25  26

  */
  const int rowsEachPanel  = 3;    // Anzahl Reihen
  const int colsEachPanel  = 3;    // Anzahl Spalten
  const int ledsEachPanel  = 9;    // Anzahl pro Panel
  int numPanel = x / colsEachPanel;  // Anzahl Panels
  int led;

  led = (numPanel * ledsEachPanel) + (x % rowsEachPanel) + (y * rowsEachPanel);
  return led;
}

[asdfasd (Gast)]

Der Kode sieht korrekt aus.  Falls deine CPU bei Divison/Modulo langsam 
ist, bietet es sich an, eine Lookup-Tabelle zu benutzen:

int getLedNumber(int x, int y)
{
  /*
  Panel0      Panel1      Panel2
  00  01  02  |  09  10  11  |  18  19  20
  03  04  05  |  12  13  14  |  21  22  23
  06  07  08  |  15  16  17  |  24  25  26
  */

  static const unsigned char col[] = {
    0, 1, 2,  9, 10, 11,  18, 19, 20
  };

  return col[x] + y * 3;
}

Ich gehe davon aus, dass das "y*3" zu "(y<<1)+y" optimiert wird.

[asdfasd (Gast)]

Hmm... kein Edit.  Für 8 Panels muss die Tabelle natürlich entsprechend 
erweitert werden.

[Matthias L. (Gast)]

Wenns nicht am Flash hapert, dann leg das hier doch direkt als 2D-Array 
ins Flash:

  /*
  Panel0      Panel1      Panel2
  00  01  02  |  09  10  11  |  18  19  20
  03  04  05  |  12  13  14  |  21  22  23
  06  07  08  |  15  16  17  |  24  25  26
  */

[Karl H. (kbuchegg)]

Sebbi schrieb:

>

> int getLedNumber(int x, int y)
> {
>   /*
>   Panel0      Panel1      Panel2
>   00  01  02  |  09  10  11  |  18  19  20
>   03  04  05  |  12  13  14  |  21  22  23
>   06  07  08  |  15  16  17  |  24  25  26
> 
>   */
>   const int rowsEachPanel  = 3;    // Anzahl Reihen
>   const int colsEachPanel  = 3;    // Anzahl Spalten
>   const int ledsEachPanel  = 9;    // Anzahl pro Panel
>   int numPanel = x / colsEachPanel;  // Anzahl Panels
>   int led;
> 
>   led = (numPanel * ledsEachPanel) + (x % rowsEachPanel) + (y * 
> rowsEachPanel);

Nitpicking.
Ich denke hier müsste es colsEachPanel lauten und nicht rowsEachPanel. 
Die Anzahl der Zeilen kommt nirgends vor, weil du diese Anzahl nur in 
der Anzahl der LED in einem kompletten Modul 'ledsEachPanel' implizit 
drinnen hast.

Bei dir spielt das jetzt insofern keine Rolle, weil du gleiche viele 
Zeilen (rows) wie Spalten (cols) hast. Aber überleg dir das mal am 
Beispiel von 4*3 Modulen

   Panel0            Panel1         Panel2
   00  01  02  03 |  12 13 14 15 |  24 25 26 27 28
   04  05  06  07 |  16 17 18 19 |  29 39 31 32 33
   08  09  10  11 |  20 21 22 23 |  34 35 36 37 28

  const int rowsEachPanel  =  3;    // Anzahl Reihen
  const int colsEachPanel  =  4;    // Anzahl Spalten
  const int ledsEachPanel  = 12;    // Anzahl pro Panel

wir wollen die Nummer der LED an der Position x = 7 und y = 1
Aus der Grafik entnehmen wir, das das richtige Ergebnis

                              |
                              |
                              v
   Panel0            Panel1         Panel2
   00  01  02  03 |  12 13 14 15 |  24 25 26 27 28
   04  05  06  07 |  16 17 18 19 |  29 39 31 32 33   <-----
   08  09  10  11 |  20 21 22 23 |  34 35 36 37 28

19 wäre.

Was ergibt deine Formel

  int numPanel = x / colsEachPanel;     // 7 / 4 -> 1 . OK

  led = (numPanel * ledsEachPanel) +    // 1 * 12  ->    12
        (x % rowsEachPanel) +           // 7 % 3   ->     1
        (y * rowsEachPanel);            // 1 * 3   ->     3
                                        //             ------
                                        //               16

und das ist offensichtlich nicht richtig.

Gegentest

  led = (numPanel * ledsEachPanel) +    // 1 * 12  ->    12
        (x % colsEachPanel) +           // 7 % 4   ->     3
        (y * colsEachPanel);            // 1 * 4   ->     4
                                        //             ------
                                        //               19

welches korrekt und auch logisch nachvollziehbar ist. In Y Richtung 
werden die Anzahl der LED in einer kompletten Zeile gezählt. Dies ist 
aber in colsEachPanel vermerkt - die Anzahl der Spalten in jedem Modul. 
Genauso in X Richtung. Die ANzahl der dann noch fehlenden LED in der 
letzten nicht vollständigen Zeile, ist die X Position modulo der Anzahl 
der Spalten. Du hast ja auch völlig korrekt die Nummer des Panels 
dadurch ermittelt, dass du die X Koordinate durch colsEachPanel 
dividiert hast.

Wenn man Dinge ausprobiert, dann ist es meistens keine gute Idee, 
quadratische Verhältnisse anzunehmen. Man merkt dann nie direkt, ob man 
sich mit x und y bzw. Zeilen und Spalten vertan hat. Bei nicht 
quadratischen Verhältnissen fällt so etwas viel früher auf.