Multi-dimensionale Arrays mit unterschiedlichen Größen in C

Lothar M. schrieb:
> Aber es gibt eine vordefinierte Maximalgröße?
> Oder ist das Alles volldynamisch?

Maximalgröße? - Ja, sicherlich: 240 Bytes. Dennoch würde ich es mehr als 
volldynamisch bezeichnen.

Lothar M. schrieb:
> Das geht am ehesten in Richtung "Union".
> Damit wird über einen bestimmten Speicherbereich einfach eine "Maske"
> gelegt und der jeweilige Speicherinhalt einfach unterschiedlich
> interpretiert.

Da alles Variable ist hilft mir das nicht weiter. Und bei einer Union 
müsste ich auch auf irgendeine "Maske" zugreifen. Das heißt ich muss im 
Programmcode wissen was kommt ...

Lothar M. schrieb:
> Verhindere durch eine "geschickte" Befehlsstruktur das eigentliche
> Problem:
>> Die Anzahl von und die Länge der einzelnen Befehlen
>> variiert von Betriebsmodus zu Betriebsmodus.

Tja ... Das kann ich nicht ändern! Das "System" mit dem ich kommuniziere 
kommt ja nicht von mir bzw. "uns".

...

Mir ist nur ein Umweg über eine Struktur eingefallen. Das ganze kostet 
aber dann je Befehl 5 Byte mehr Speicher. Unschön!

1

#define MAKE_CMD_ENTRY(cmd)     { sizeof(cmd), cmd }

2

3

typedef struct

4

{

5

  const uint8_t  size;

6

  sonst uint8_t* cmd;

7

} CMD;

8

9

const uint8_t Steuerung_Befehl_A[] = {<n=3>};

10

const uint8_t Steuerung_Befehl_B[] = {<n=18>};

11

const uint8_t Steuerung_Befehl_C[] = {<n=10>};

12

13

const CMD Steuerung_Befehl_AutomatikBetrieb[] = { MAKE_CMD_ENTRY(Steuerung_Befehl_A), 

14

                                                    MAKE_CMD_ENTRY(Steuerung_Befehl_B), 

15

                                                    MAKE_CMD_ENTRY(Steuerung_Befehl_C) };

Gruß
Finn

DerBayer schrieb:
> Die Anzahl von und die Länge
> der einzelnen Befehlen variiert von Betriebsmodus zu Betriebsmodus.

Ich denke, du solltest dir mal das Thema "verkettete Listen" anschauen. 
vielleicht trifft das eher deinen Anwendungsfall

vlt ein struct anlegen mit größe und pointer für den einzelnen befehl

wenn sich die befehle wiederholen eine einzelne liste anlegen mit den 
befehlen.

1

const uint8_t cmd1[]={..};

2

const uint8_t cmd2[]={.....};

3

...

4

5

typedef struct{

6

   const uint8_t len;

7

   const uint8_t *cmd;

8

}xxx_t

9

10

// modi 1

11

const xxx_t Steuerung_Befehl_AutomatikBetrieb[]={

12

 { 2 , cmd1},

13

 { 5 , cmd2},

14

 { 5 , cmd2}

15

}

16

17

// modi 2

18

const xxx_t Steuerung_Befehl_Betriebszustand_CROW[]={

19

 { 5 , cmd2},

20

 { 2 , cmd1},

21

 { 2 , cmd1}

22

}

@53453453454353:

Ähm ... Ist das nicht meine Lösung!?

Stromverdichter schrieb:
> Ich denke, du solltest dir mal das Thema "verkettete Listen" anschauen.
> vielleicht trifft das eher deinen Anwendungsfall

Glaube ich nicht. Wären dann sogar 9 Bytes, statt 5, da ich einen 
zusätzlichen Pointer sichern müsste:

1

typedef struct

2

{

3

  const uint8_t  size;

4

  const uint8_t* cmd;

5

  const CMD*     next;

6

} CMD;

Last but not least, sind verkettete Listen nur bei dynamischer 
Speicherallokierung von Nutzen. Nicht bei statischer ...

DerBayer schrieb:
> Ähm ... Ist das nicht meine Lösung!?

quasi gleiche idee ^^
das forum ist manchmal nicht so schnell in der aktualisierung.
als ich geschrieben hatte war dein post nioch nicht da

Eric B. schrieb:
> So variabel ist es anscheint nicht, wenn du alle zu sendene Befehle im
> Flash legen kannst.

Ja richtig. Die sind fest, ohne variablen Inhalt zur Laufzeit.

Eric B. schrieb:
> if(need_to_send_cmd1)
>         send(cmd1);
>     else
>         send(cmd2);

Ein aufeinanderfolgendes explizites Senden von Kommandos a la

1

send(cmd1);

2

send(cmd2);

will ich ja eben vermeiden.


Eric B. schrieb:
> EDIT: nur aufpassen wenn der Befehl 256 bytes lang ist :-)

Gibt es ja eben bei 8 Bit nicht ;-)

Peter D. schrieb:
>

1

char *cmd_str[] = { "Set", "Get", "Calib", "Info", "Uptime", "Reset", "Eestore", "" };

Lustig, dass das so funktioniert und mit einem Byte-Array nicht, obwohl 
es prinzipiell das selbe ist, denn "Set" ist ja ein Byte-Array 
{'S','e','t', 0}.

Dennoch geht das nicht:

1

const uint8_t* Steuerung_Befehl_AutomatikBetrieb[][] = {{<n=3>}, {<n=18>}, {<n=10>}};

Wie wäre es mit einem 1-Dim Array, wo alles hintereinander steht. Und 
ein zweites Array mit jeweils dem Anfangsindex des datensatzes im ersten 
Array.

Du kannst 0-terminierte Listen auch mit einem weiteren Sonderzeichen 
hierarchisch aufbauen. Beispiel: alle Befehle als Strings mit 0 
hintereinander, Ende ist wenn ein String mit 1 anfängt oder aufhört.
Vorteil: einfache Nutzung von stringroutinen, minimalster Overhead