Mehrdimensionales Array oder ein struct für PIXEl Tisch

Hallo miteinander,

ich habe einen Pixeltisch gebaut / bin dran.

Jetzt möchte ich für den Test ein paar Bilder / Texte anzeigen lassen, dafür habe ich mir in Excel das Display nach gebaut und kann nun jeden PIXEL eine Farbe zuweisen, und bekomme dann die RGB Werte dazu angezeigt. sehr Praktisch.

Nun stehe ich auf dem Schlauch.

mit dieser Zeile kann ich einem Pixel auf dem Tisch eine Farbe zuweisen.

leds[led_Nr] = CRGB(255, 0, 0);

Der Tisch hat insgesamt 1080 Pixel.

Ich dachte das man alle Pixel RGB Werte in ein Array schreiben könnte um dies dann in einer For schleife aufzurufen.
jetzt habe ich jedoch auch die Alternative struct gesehen.
Mich verwirf das gerade.

  1. das Logische denken mit dem Array ist mir nicht geläufig und fällt mir schwer.
  2. wie würde so was mit struct ausschauen?
    was nimmt weniger Speicher ein?

Auch das befüllen des Mehrdimensionales Array fällt mir gerade schwer ;-(

Das müsste ja so aufgebaut sein
Bilder [1079][0][0][0]
Bilder [Pixel Anzahl] [R Wert] [G Wert] [B Wert]

EDIT: oder mache ich dann 3 einzelne Array`s je wins für einen Wert also
Array R_WERT
Array G_WERT
Array B_WERT
??
die Zähler Fängen ja immer bei 0 an.

Doch wie befülle ich das nun?
Ich stehe da irgend wie auf dem Schlauch und komme nicht weiter, mit der Logik.

Gruß Mücke

Hallo
schaue dir den Inhalt an.

was auch immer dein CRGB macht, aber wenn du dir es speichermäßig erlauben kannst, dann würde ich das einfach in hex in ein uint32_t speichern: 0xFF0000 ... damit sehe ich auch sofort - volles rot, kein grün, kein blau.

ansonsten halt ein struct bauen wie man es braucht und daraus ein Array.
ungetestet

struct Farben{
  byte red;
  byte green;
  byte blue;
};
Farben farben[1080];

schau mal in deine Lib, vieleicht gibt es eh schon ein passendes struct ... für einen 3 Byte Farbwert.

geraten:

for (int i = 0; i<1080; i++)
{
  leds[i]= CRGB(farben[i].red, farben[i].green, farben[i].blue); 
}

finde ich deutlich leichter lesbar als eine Wurscht aus einem multidimensionalen Array.

Und wie gesagt, aufpassen dass dir nicht der Speicher ausgeht, evtl. bezüglich PROGMEM nachlesen...

OK, ich habe kein Drei sondern ein zwei Dimensionales Array :see_no_evil:

aus deinem Link @paulpaulson

int pinMatrix[3][3] = {

{2, 3, 4 },
{5, 6, 7 },
{8, 9, 10 }

};

Demnach müsste das bei mir dann so ausschauen.

// Bilder befüllen 
int Bilder[1080][3] = {
                      {10,  20,  30  },
                      {68,  14,  9   },
                      {19,  17,  255 }
};

void setup() {
  Serial.begin(9600);

    for (int i = 0; i <= 3; i++) {
      // leds['PIXEL_Nr'] = CRGB('R_WERT', 'G_WERT', 'B_WERT');
      Serial.print("leds["); 
      Serial.print(i);     
      Serial.print("] = CRGB("); 
      Serial.print(Bilder[i][0]);    // R_WERT
      Serial.print(", "); 
      Serial.print(Bilder[i][1]);    // G_WERT 
      Serial.print(", "); 
      Serial.print(Bilder[i][2]);    // B_WERT 
      Serial.println("');");     
    } // for i 
} // setup

void loop() {
  delay(1);
} // Loop 

Das hat zumindest ohne Fehler hin gehauen.

Das kommt aus der FastLED.h schätze ich, so ganz genau versteh ich das alles auch noch nicht, ich bin erst dabei das ganze zu verstehen. im Link oben ist der Tisch verlinkt und auch der Code der dort verwendet wird #103

Wie meinst du das mit dem "speichermäßig erlauben kannst" ?
verbrauche ich wenn ich die RGB Werte speichere mehr platz wie mit hex?

Dann muss ich erst heraus finden wie ich in HEX die Pixel "bemale", kein plan wie man das richtig nennt.

@noiasca: das was du da gemacht hast

das gefällt mir sehr gut, und ja es ist unheimlich gut zu lesen :slight_smile:
doch wie befülle ich das?

Henne wie Ei:

Farben farben[][3] = {
                      {10,  20,  30  },
                      {68,  14,  9   },
                      {19,  17,  255 }
};

na auf einem UNO wirst zB. keine 3 x 1080 Bytes zusätzlich im SRAM halten können oder?

umgekehrt: ein uint32_t bräuchte vier Byte, das struct besteht nur aus 3 Byte (zum Overhead fürs struct kann ich nichts sagen, probier es mit einem Testsketch einfach aus).

Ah, der combie schreibt eh schon... mal sehen... was da kommt...

Was für eine seltsame Frage!
Warum fragst du das nicht deinen Compiler?
Der muss schließlich die Arrays für deinen geheimen µC zusammenbasteln.

Grundsätzlich:
Hast du es schon mal mit einem C++ Buch probiert?
Also, meiner Meinung nach, könnte man nach mehr als 2 Tausend 300 Beiträgen schon die Grundlagen halbwegs auf dem Schirm haben.

Nix gutes ....

Lesen, ausprobieren, lernen und für das Neue umsetzen.

da ich nur Fehlermeldungen bekomme und mir der Compiler daher noch nicht sagt welchen Speicher ich verbrauche

Sorry das war nicht meine Absicht , ich verwende ein Teensy 3.2.

das macht den Fehler

Test_Bild:19: error: conflicting declaration 'Farben farben [3]'
Farben farben[3] = {
^

ich möchte mich nicht raus reden oder verteidigen du hast recht, ja das Stimmt das ein oder andere sollte ich schon hin bekommen.
ich bin jedoch einer der das gelegentlich macht, und immer sehr lange pausen zwischen drin hat, was nicht gerade Positiv für den lerneffekt ist.
ich schaue auch ständig in meinen Alten Codes und Beiträgen nach damit ich das was schon mal geschrieben wurde und aufgearbeitet wird, erneut zum Einsatz kommt.
Aktuell habe ich einen neuen µC den ich noch nicht ganz verstehe, dann habe ich den PIXEl Streifen neu den ich noch nicht verstehe. dazu kommt das mir die Logik der Arrays nicht in meiner DNA verankert ist.
Wenn es darum geht, Großraum / Handelsvertreter / Verträge aufzusetzen, deren Rechtslagen zu kennen bin ich dein Mann, und ich garantiere dir das hier du und viele andere in manchen Dingen extrem langsam sein werden mit dem Verständnis warum etwas so ist oder nicht, und auch 1.000 das selbe wieder nachfragen da es einfach nicht eure Baustelle ist.
auch wenn du das dann schon seit 10 Jahren 3 mal im Jahr machen musst kommen immer wieder die selben fragen da du dich sonst unter dem Jahr mit andern Dingen beschäftigst.
@combie bitte fasse das jetzt nicht als Kricket auf, oder als Beleidigung. ich kann das gut verstehen das man als jemand der sich sehr gut auskennt und für den das einfach ist da aufregen kann bei solchen Doofen fragen die ich stelle. auch ich komme mir oft doof vor da ich es einfach nicht hin bekomme. und fragen muss.

Jedoch ist die Commune :wink: hier echt gut, und man findet auch viel im Netz und in Forum dazu.

Ach, da mache dir mal keine Sorgen....
Wir beide hatten die Diskussion schon vor ein paar Jahren. Seit dem habe ich dich wohlwollend ignoriert.
Jetzt wollte ich mal wissen, ob du deine Einstellung geändert hast.
Hast du scheinbar nicht.

Mein Rat: (ähnlich wie damals)
Solange du begründest, warum du was falsch (oder auch gar nicht) machst, hast du keinen Grund es richtig zu machen.
Je öfter du das "falsche" begründest, desto stabiler setzt sich das.
Das Verfahren heißt u.A. Selbstsuggestion.

Bitte nicht falsch verstehen, ich möchte dich nicht ärgern. Hatte nur eine vage Hoffnung.

mach einen minimalen Sketch ohne externe Abhängigkeiten (keine weiteren libs einbinden) die das Problem zeigt dann kann ich drüber schauen. Oder halt selber ein wenig ausprobieren...

Schaue Dir mal das Beispiel XYMatrix.ino an.

struct Farben {
  byte red;
  byte green;
  byte blue;
};

Farben bildA[][3] = {         // erste Diension darfst den Compiler bestimmen lassen
  {10,  20,  30  },
  {68,  14,  9   },
  {19,  17,  255 }
};

Farben bildB[10][3] = {       // erste Dimension darfst auch selber festlegen
  {10,  20,  30  },
  {68,  14,  9   },
  {19,  17,  255 }
};

/*
// das haut es dir um die Ohren
Farben bildB[10][] = {       // FALSCH
  {10,  20,  30  },
  {68,  14,  9   },
  {19,  17,  255 }
};
*/

void setup() {
  // put your setup code here, to run once:

}

void loop() {
  // put your main code here, to run repeatedly:

}

CRGB ist doch schon die passende Struktur:

struct CRGB {
	union {
		struct {
            union {
                uint8_t r;
                uint8_t red;
            };
            union {
                uint8_t g;
                uint8_t green;
            };
            union {
                uint8_t b;
                uint8_t blue;
            };
        };
		uint8_t raw[3];
	};

Wieso soll man das nochmal selbst machen? Das hat man die drei Farben getrennt und gleichzeitig als Byte Array

Ja ich wies das wir das vor ein paar Jahren schon einmal hatten.
und ich meine das ich seit dem auch was dazu gelernt habe, und in zwischen auch mehr stellen habe was nachzuschauen.

Ich wünsche dir dennoch viel Spaß beim mitlesen.

Bleib gesund und Gruß Mücke

Das erste habe ich geschafft, endlich meinen Compiler zu fragen :slight_smile:

1080 Pixel sollen je RGB Werte bekommen

// Zweidimensionales Array
// Bild daten
int Bilder[1080][3] = {
{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, 
{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, 
{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, 
{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, 
{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, 
{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, 
{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, 
{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, 
{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, 
{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, 
{0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {204, 51, 0}, {204, 51, 0}, {204, 51, 0}, {204, 51, 0}, 
{0, 0, 0}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, 
{0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 0, 0}, 
{0, 0, 0}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, 
{0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 0, 0}, 
{0, 0, 0}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, 
{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, 
{0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {204, 51, 0}, {204, 51, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, 
{0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, 
{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, 
{0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, 
{0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, 
{0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {204, 51, 0}, {204, 51, 0}, {204, 51, 0}, {204, 51, 0}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, {0, 0, 0}, {0, 0, 0}, {0, 112, 192}, {0, 112, 192}, 
{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}
};

void setup() {
  // put your setup code here, to run once:
}

void loop() {
  // put your main code here, to run repeatedly:
}

Der Sketch verwendet 7616 Bytes (2%) des Programmspeicherplatzes. Das Maximum sind 262144 Bytes.
Globale Variablen verwenden 3044 Bytes (4%) des dynamischen Speichers, 62492 Bytes für lokale Variablen verbleiben. Das Maximum sind 65536

Jetzt muss ich das mit dem Hex noch hin bekommen ?!?

[EDIT]
habe das als struct auch gerade getestet, mit dem Ergebnis: das es genau selben selben platz bedarf hat wie das Zweidimensionales Array

Das mit dem CRGB habe ich noch nicht ganz verstanden.
ich habe das bisher so verstanden das ich damit über die Lib FastLED die Werte so aufbereite das sie an ein Pixel gesendet werden können.
und mit leds[i] dann das ganze einen Pixel zuweisen tuhe.

Was ich nicht geschrieben habe, wobei mir das erst jetzt auffällt sorry. ich möchte mehrere Bilder im Code hinterlegen die ich dann entsprechend aufrufen kann.
(Warscheinlich wäre es einfacher Texte und zahlen einmal zu definieren und dann zu berechnen in der Matrix wie sie dargestellt werden müssen, wäre Platz Sparender, ich kann das jedoch noch nicht mit der Matrix richtig umzugehen, wüste gerade nicht mal wie ich da ansetzen soll.)
[/EDIT]

Das liegt vielleicht daran das ich auf der suche nach einer Lösung bin, und teilweise hier im Forum es so schnell geht das ich nicht bei allem sofort reagieren kann, sondern ehrt einmal mich dann auch wieder einlesen muss, wenn dann gleich 2 oder 3 Wege vorgeschlagen werden die man machen kann (in meinen Augen) muss ich mich auf einen konzentrieren, sonst komme ich noch mehr durcheinander wie ich eh schon bin.

Alleine hier jetzt für mich sind das jetzt gleich mehrere Lösungsansitze, doch welchen soll ich nun weiter verfolgen?

  1. Mehrdimensionales Array (selbst definieren) mit RGB Werten
  2. Mehrdimensionales Array (selbst definieren) mit HEX Werten, dazu muss ich erst einmal in der FastLED LIB schauen wie ich so ein Pixel beschreibe, denn das weis ich auch noch nicht beim RGb wies ich es
  3. struct, da bin ich mir immer noch nicht sicher wie ich das genau baue, also auch noch einlesen und ausprobieren bis es endlich klappt
  4. Dann muss ich jetzt wieder nachlesen was eine "uint32_t" ist, ich weis das es was mit dem Speichern zu tun hat, wies es aber nicht auswendig also erst einlesen bevor ich was schreibe.
  5. Vorschlag die XYMatrix.ino anschauen, kein Plan was da genau drin vorkommt
  6. CRGB ist doch schon die passende Struktur ! Öm ok, also auch noch mal genauer anschauen.

Für mich sind das nun 6 verschiedene Baustellen, das ich nicht in der Geschwindigkeit wie ihr sie hier mir Ressentiment nachgehen kann, da ich egal bei welcher erst nachlesen, verstehen ausprobieren, testen muss, hoffe ich leuchtet ein. das ich dann irgend was auch mal ignoriere, da ich mit einer der Ansätze beschäftigt bin, versteht man hoffentlich.

Ich bin unheimlich dankbar für jede Hilfe die ich bekomme, da ich wies das es mit mir nicht leicht ist, und das ich ein ziemlicher nicht wissender bin, der sich echt schlecht was merken kann.

Ich glaube ich mache jetzt mit dem Ansatz 5 bzw. 6 Weiter. und lasse den Rest erst einmal liegen.
Es kann gut sein das Ihr Dinge zusammen fasst da euch klar ist das das zusammen gehört für mich nicht. denn ich kenne die zusammenhänge leider nicht.

  1. Was ist daran besser, als an dem Original? Nix, also bleiben lassen.
  2. Unfug, HEX ist nur eine andere Darstellung.
  3. Einlesen, gut und richtig! Aber hast du doch HIER schon fertig vorliegen. Für andere Fälle ok, aber nicht hier.
  4. Natürlich! Lerne was es ist, aber hier ist uint32_t kontraproduktiv.
  5. keine Ahnung.....
  6. Ja!

Je öfter du das wiederholst, desto fester glaubst du da selber dran.
Das ist eine über 5000 Jahre alte psychologische Erkenntnis.
Sie hat bis heute ihre volle Gültigkeit behalten.
Nennt sich z.B. Selbstsuggestion oder Selbstkonditionierung.

Die Frage ist nun: Willst du das wirklich?
(und nein, ich will keine Antwort, die ist nur für dich wichtig)

OK, dann verwerfe ich das was ich gerade mache! und widme mich dem JA
CRGB genauer anschauen.

Jedoch habe ich den Eindruck das ich meine Fragestellung etwas abändern muss.
Sorry, das hat sich für mich erst wehrend der Diskussion so raus kristallisiert.

Was möchte ich genau machen.
ich möchte ein Test Programm schreiben bei dem ich verschiedene Dinge auf meinem PIXEl Tisch darstellen kann. (Verschiebende Texte)
dafür habe ich mir im EXCEL mein PIXEL Tisch nach gebaut und kann jetzt jedem Pixel ein farbe geben, das lasse ich mir dann in die RGB Werte zerlegen und kann mir so mein 2 Dimensionales Array mir ausgeben lassen. (das habe ich gemacht da ich dachte das ist gut und der richtige weg)

Ich möchte ca. 48 unterschiedliche Texte ausgeben lassen.
Demnach habe ich 48 x 1080Pixel die ich mit RGB Farben füllen sollte.

daher hatte ich mich auf die Suche gemacht wie ich das am besten machen kann, da kamm mir die Idee mit dem Mehrdimensionalem Array oder dem Struct. jetzt sagt man mir das die LIB FastLED mir schon was anbietet mit dem ich was zwischen Speichern kann.
Das verwirrt mich gerade, denn hier kann ich 1 mal die gerammte Fläche (1080 Pixel) hinterlegen.
oder stehe ich gerade auf dem Schlauch?

Jedoch wenn ich mir von meinem Test mit dem Struct / Array den Speicher anschaue.

1 x 1080Pixel = 7.616 Bytes dann machen 48 x 1080Pixel = 36.5568 Bytes
ich haeb jedoch auf dem Teensy 3.2 nur 26.2144 Bytes

Das geht also so nicht! Hmm. Jetzt stehe ich gerade wieder auf dem Schlauch.
wie ich das denn gelöst bekomme.

oder habe ich einen Denkfehler?

Ein Array aus int ist sowieso falsch. Ein int hat auf einem 32-Bit Prozessor 4 Bytes! Wo du nur ein Byte pro Farbwert brauchst

Was du willst ist ein Array aus Strukturen. Dann kannst du eine Fläche mit dem Array abbilden und jeder Wert ist eine CRGB Struktur mit je 3 Bytes für die 3 Farben

Das habe ich mir gerade durchgelesen, und ehrlich gesagt verstehe ich nur Bahnhof von begib bis ende.

Code mit DE Übersetzung.

#include <FastLED.h>

#define LED_PIN  3

#define COLOR_ORDER GRB
#define CHIPSET     WS2811

#define BRIGHTNESS 64

// Hilfsfunktionen für eine zweidimensionale XY-Matrix aus Pixeln.
// Einfacher 2-D-Democode ist ebenfalls enthalten.
//
// XY(x,y) nimmt x- und y-Koordinaten und gibt eine LED-Indexnummer zurück,
// zur Verwendung wie folgt: leds[ XY(x,y) ] == CRGB::Red;
// Für die Bereiche von x und y wird keine Fehlerprüfung durchgeführt.
//
// XYsafe(x,y) nimmt x- und y-Koordinaten und gibt eine LED-Indexnummer zurück,
// zur Verwendung wie folgt: leds[ XY(x,y) ] == CRGB::Red;
// Die Fehlerprüfung wird für die Bereiche x und y durchgeführt, und ein
// Index von "-1" wird zurückgegeben.  Spezielle Anweisungen unten
// erklären, wie Sie diese Funktion verwenden können, ohne jedes Mal eine eigene Fehler
// Fehlerprüfung bei jeder Verwendung dieser Funktion durchzuführen.  
// Dies ist eine etwas fortgeschrittenere Technik, und 
// sie erfordert besondere zusätzliche Einstellungen, die weiter unten beschrieben werden.


// Parameter für Breite und Höhe
const uint8_t kMatrixWidth = 45;  // Breite
const uint8_t kMatrixHeight = 24; // Höhe

// Param für verschiedene Pixel-Layouts
const bool    kMatrixSerpentineLayout = true;
// Setzen Sie 'kMatrixSerpentineLayout' auf false, wenn Ihre Pixel 
// alle auf die gleiche Weise angeordnet sind, wie hier:
//
//     0 >  1 >  2 >  3 >  4
//                         |
//     .----<----<----<----'
//     |
//     5 >  6 >  7 >  8 >  9
//                         |
//     .----<----<----<----'
//     |
//    10 > 11 > 12 > 13 > 14
//                         |
//     .----<----<----<----'
//     |
//    15 > 16 > 17 > 18 > 19
//
// Setzen Sie 'kMatrixSerpentineLayout' auf true, wenn Ihre Pixel 
// vorwärts und rückwärts angeordnet sind, etwa so:
//
//     0 >  1 >  2 >  3 >  4
//                         |
//                         |
//     9 <  8 <  7 <  6 <  5
//     |
//     |
//    10 > 11 > 12 > 13 > 14
//                        |
//                        |
//    19 < 18 < 17 < 16 < 15
//
// Bonusvokabel: alles, was in eine Richtung geht 
// in einer Reihe, und dann rückwärts in die nächste Reihe, und so weiter
// wird "boustrophedon" genannt, was "wie der Ochse pflügt" bedeutet.


// Diese Funktion gibt die richtige 'led-Indexnummer' für 
// einen gegebenen Satz von X- und Y-Koordinaten auf Ihrer Matrix zurück.  
// SIE PRÜFT NICHT DIE KOORDINATENGRENZEN.  
// Das bleibt Ihnen überlassen.  Übergeben Sie ihr keine falschen Werte.
//
// Verwenden Sie die Funktion "XY" wie folgt:
//
//    for( uint8_t x = 0; x < kMatrixWidth; x++) {
//      for( uint8_t y = 0; y < kMatrixHeight; y++) {
//      
//        // Here's the x, y to 'led index' in action: 
//        leds[ XY( x, y) ] = CHSV( random8(), 255, 255);
//      
//      }
//    }
//
//
uint16_t XY( uint8_t x, uint8_t y)
{
  uint16_t i;
  
  if( kMatrixSerpentineLayout == false) {
    i = (y * kMatrixWidth) + x;
  }

  if( kMatrixSerpentineLayout == true) {
    if( y & 0x01) {
      // Odd rows run backwards
      uint8_t reverseX = (kMatrixWidth - 1) - x;
      i = (y * kMatrixWidth) + reverseX;
    } else {
      // Even rows run forwards
      i = (y * kMatrixWidth) + x;
    }
  }
  
  return i;
}


// Sobald Sie die Grundlagen zum Laufen gebracht haben (UND NICHT DANN!)
// hier ist eine hilfreiche Technik, die zwar knifflig einzurichten ist, aber 
// dann hilft sie Ihnen, die Notwendigkeit zu vermeiden, Array-Bound-Checking
// durch Ihren Code zu streuen.
//
// Es erfordert eine sorgfältige Aufmerksamkeit, um es richtig einzurichten, aber
// kann Ihren Code potenziell kleiner und schneller machen.
//
// Angenommen, Sie haben eine 8 x 5-Matrix mit 40 LEDs.  Normalerweise würden Sie
// Ihr leds-Array wie folgt auflösen:
// CRGB leds[40];
// Aber stattdessen deklarieren Sie einen LED-Puffer mit einem zusätzlichen Pixel darin
// es, "leds_plus_safety_pixel".  Dann deklarieren Sie "leds" als einen Zeiger auf
// dieses Array, aber beginnend mit dem 2. Element (id=1) dieses Arrays: 
// CRGB leds_mit_Sicherheitspixel[41];
// CRGB* const leds( leds_plus_safety_pixel + 1);
// Dann verwenden Sie das Array "leds" wie gewohnt.
// Jetzt sind "leds[0..N]" Aliase für "leds_plus_safety_pixel[1..(N+1)]",
// UND leds[-1] ist jetzt ein legitimer und sicherer Alias für leds_plus_safety_pixel[0].
// leds_plus_safety_pixel[0] aka leds[-1] ist nun Ihr "Sicherheitspixel".
//
// Verwenden Sie nun anstelle der obigen XY-Funktion die unten stehende Funktion "XYsafe".
//
// Wenn die X- und Y-Werte "in bounds" sind, gibt diese Funktion einen Index
// in das sichtbare Led-Array zurück, genauso wie "XY".
// ABER - und das ist der Trick - wenn die X- oder Y-Werte
// außerhalb der Grenzen liegen, gibt diese Funktion einen Index von -1 zurück.
// Und da leds[-1] eigentlich nur ein Alias für leds_plus_safety_pixel[0] ist,
// ist es ein völlig sicherer und legaler Ort für den Zugriff.  Und da das 'Sicherheitspixel'
// außerhalb des sichtbaren Teils des LED-Arrays liegt, wird alles, was Sie 
// dort schreiben, wird automatisch ausgeblendet.
// Somit ist diese Codezeile völlig sicher, unabhängig von der tatsächlichen Größe der
// Ihrer Matrix:
//    leds[ XYsafe( random8(), random8() ) ] = CHSV( random8(), 255, 255);
//
// Der einzige Haken an der Sache ist, dass dies zwar das Lesen von und
// jedes beliebige Pixel zu lesen und zu schreiben, aber es gibt wirklich nur EIN "Sicherheitspixel".  Egal
// in welche Out-of-Bounds-Koordinaten Sie schreiben, Sie schreiben wirklich in
// dieses eine Sicherheitspixel.  Und wenn Sie versuchen, von dem Sicherheitspixel zu LESEN,
// werden Sie lesen, was immer zuletzt dorthin geschrieben wurde, unabhängig davon, welche Koordinaten
// geliefert wurden.

#define NUM_LEDS (kMatrixWidth * kMatrixHeight)
CRGB leds_plus_safety_pixel[ NUM_LEDS + 1];
CRGB* const leds( leds_plus_safety_pixel + 1);

uint16_t XYsafe( uint8_t x, uint8_t y)
{
  if( x >= kMatrixWidth) return -1;
  if( y >= kMatrixHeight) return -1;
  return XY(x,y);
}


// Demo, die "XY" verwendet, folgt dem folgenden Code

void loop()
{
    uint32_t ms = millis();
    int32_t yHueDelta32 = ((int32_t)cos16( ms * (27/1) ) * (350 / kMatrixWidth));
    int32_t xHueDelta32 = ((int32_t)cos16( ms * (39/1) ) * (310 / kMatrixHeight));
    DrawOneFrame( ms / 65536, yHueDelta32 / 32768, xHueDelta32 / 32768);
    if( ms < 5000 ) {
      FastLED.setBrightness( scale8( BRIGHTNESS, (ms * 256) / 5000));
    } else {
      FastLED.setBrightness(BRIGHTNESS);
    }
    FastLED.show();
}

void DrawOneFrame( byte startHue8, int8_t yHueDelta8, int8_t xHueDelta8)
{
  byte lineStartHue = startHue8;
  for( byte y = 0; y < kMatrixHeight; y++) {
    lineStartHue += yHueDelta8;
    byte pixelHue = lineStartHue;      
    for( byte x = 0; x < kMatrixWidth; x++) {
      pixelHue += xHueDelta8;
      leds[ XY(x, y)]  = CHSV( pixelHue, 255, 255);
    }
  }
}


void setup() {
  FastLED.addLeds<CHIPSET, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalSMD5050);
  FastLED.setBrightness( BRIGHTNESS );
}

OK,
https://www.tutorialspoint.com/cplusplus/cpp_data_types.htm

Ok dann nehme ich anstelle ein int das unsigned char das hat laut Tabelle einen Platzbedarf von 1byte und kann die Werte von 0..255 hinterlegen.

Wenn ich das mit dem Code aus Beitrag #16 mache komme ich auf folgende Werte:

mit int:
Programmspeicherplatze: 7.616 Bytes (2%) von 26.2144 Bytes
dynamischen Speichers: 3.044 Bytes (4%) von 65.536 Bytes

mit unsigned char:
Programmspeicherplatze: 7.616 Bytes (2%) von 26.2144 Bytes
dynamischen Speichers: 3.044 Bytes (4%) von 65.536 Bytes

Für mich kommen da die Selben werte bei raus?
mache ich was Falsch? oder verstehe ich was Falsch?

Den teil kann ich zwar lesen verstehe ihn jedoch gerade nicht.

Was mir gerade im Kopf herum geht dabei:
DIE RGB Werte nicht einzeln aufrufen sondern direkt mit CRGB schon eingeben?
ich kann mir das gerade gar nicht vorstellen wie das gehen soll.
und ich versteh auch nicht wie das dann weniger platz einnehmen sollte, bei meinem Array habe ich 3 x 1Bytes und bei deinem Beispiel habe ich 1x 3Bytes, kommt dann nicht das selbe bei raus?
oder habe ich den Ansatz gerade falsch verstanden?