Zugriff auf PROGMEM struct-pointer-array in atmega328p

[Stefan (Gast)]

Hallo liebes Forum :-)
ich habe ein Problem beim Zugriff auf ein Array aus Pointern auf 
Structs, die im Flash-Memory liegen. Es geht um einen Kommando-Parser, 
den ich schreiben möchte.

Jedes struct, das ein einzelnes Kommando hält ist vom Typ

/* to hold one command */
typedef struct{

  char *cmd;
  uint8_t numberOfOptions;
  uint8_t cmdCode;

}command;

Um die Kommandos einfach zu erzeugen habe ich mir das Makro

/* generate the structs that hold the commands */
#define ADD_COMMAND(NUMBER, CMD_NAME, NUMBER_OPT, CMD_CODE)                      \
  const char cmd_ ## NUMBER ## _name[] PROGMEM = CMD_NAME;                       \
  const command cmd_ ## NUMBER ## _ PROGMEM = { .cmd = cmd_ ## NUMBER ## _name,  \
                                                .numberOfOptions = NUMBER_OPT,   \
                                                .cmdCode = CMD_CODE              \
                                              };

geschrieben, das mir alle Informationen im Flash-Memory ablegt. Als 
nächstes lege ich die Kommandos an mit

ADD_COMMAND(0,  "\0" ,           0, 0x80)     /* no command*/
ADD_COMMAND(1,  "*RST\0",        0, 0x81)     /* reset */
ADD_COMMAND(2,  "*IDN?\0",       0, 0x82)     /* get IDN */
ADD_COMMAND(3,  "*IDN\0",        1, 0x83)     /* set IDN */
ADD_COMMAND(4,  "SETPIN\0",      2, 0x84)     /* turn pin on/off */
ADD_COMMAND(5,  "GETPIN\0",      1, 0x85)     /* get pin status */
ADD_COMMAND(6,  "SETPATT\0",     2, 0x86)     /* define pulse pattern */
ADD_COMMAND(7,  "STARTPATT\0",   0, 0x87)     /* start pattern */
ADD_COMMAND(8,  "STOPPATT\0",    0, 0x88)     /* stop pattern */
ADD_COMMAND(9,  "ALIVE?\0",      0, 0x89)     /* are you alive? */
ADD_COMMAND(10, "CFGEVENTCNT\0", 2, 0x8A)     /* configure event counter */
ADD_COMMAND(11, "GETEVENTCNT\0", 1, 0x8B)     /* get INT event counter value */

usw...da kommen dann noch ein paar mehr dazu.

Die einzelnen structs werden dann in einem Array gehalten, das auch im 
Flash-Speicher liegen soll. Um Compilezeit-Konstanten zu erhalten mache 
ich das als Pointer-Array. Das sieht dann so aus:

const command* const commandList[] PROGMEM = {&cmd_0_, &cmd_1_, &cmd_2_,
                                              &cmd_3_, &cmd_4_, &cmd_5_,
                                              &cmd_6_, &cmd_7_, &cmd_8_,
                                              &cmd_9_, &cmd_10_, &cmd_11_
                                             };

Jetzt kommts zur eigentlichen Frage:
Ich möchte gerne auf die einzelnen Kommando-Strings im Flash über einen 
Index zugreifen können um sie mit einem (im SRAM liegenden) über RS232 
empfangenen String zu vergleichen. Hierzu mache ich folgendes:

uint8_t i;
command *cmdPtr;

for(i=0; i<=TOTAL_NUMBER_OF_COMMANDS; i++){
  cmdPtr = (command*)pgm_read_word(commandList[i]);
  if(strcmp_P(rxString.buffer, cmdPtr->cmd) == 0){
    /* found known command */
    /* mache irgendwas tolles :-) */
  }
}

Das funktioniert jedoch nicht. Wo liegt also mein Denkfehler?
Bisher habe ich mir das so gedacht:

Im Array commandList liegen lauter Adressen auf structs vom Typ command 
im Flash-Memory. Diese Adressen hole ich mit pgm_read_word und weise sie 
dem cmdPtr zu. Nun kann man doch mit strcmp_P() direkt auf Adressen im 
Flash verweisen, was ich mit cmdPtr->cmd versucht habe. Leider klappt 
das nicht...

Habt ihr eine Idee woran das liegen könnte und wie man das beheben kann?

Viele Liebe Grüße,
Stefan

[Karl H. (kbuchegg)]

Stefan schrieb:

> ich das als Pointer-Array. Das sieht dann so aus:
>
>

> const command* const commandList[] PROGMEM = {&cmd_0_, &cmd_1_, &cmd_2_,
>                                               &cmd_3_, &cmd_4_, &cmd_5_,
>                                               &cmd_6_, &cmd_7_, &cmd_8_,
>                                               &cmd_9_, &cmd_10_, 
> &cmd_11_
>                                              };
>

Du hast also das hier gebaut

  commandList  PROGMEM         cmd_0_   PROGMEM
  +--------------+             +----------+
  |  o------------------------>|   o--------------->"\0" (PROGMEM)
  +--------------+             |          |
  |  o---------------+         +----------+
  +--------------+   |
  |  o-------------+ |      +-----------+
  +--------------+ | +----->|   o------------>"RST" (PROGMEM)
  |              | |        |           |
  +--              |        +-----------+

auf alle Inhalte, die mit PROGMEM markiert sind, kannst du nicht direkt 
zugreifen, sondenr musst den UMweg über die pgm_xxx Funktionen gehen.

> Im Array commandList liegen lauter Adressen auf structs vom Typ command
> im Flash-Memory.

Ja.
Aber das Array, welches diese Adresse hält liegt ja selbst auch im 
Flash. Daher ja auch ...

>   cmdPtr = (command*)pgm_read_word(commandList[i]);

...
Aber: No.
Hier würdest du ja den Inhalt von commandList[i] an pgm_read_word 
übergeben. Das ist aber nicht das was du willst.
Du willst ja von der Flash Adresse vom i-ten Element von commandList 
lesen. Also

   cmdPtr = (command*)pgm_read_word( &commandList[i] );

[Stefan (Gast)]

Hallo Karl Heinz,
erstmal vielen lieben Dank für deine Hilfe!

Das habe ich jetzt so übernommen. Wenn ich das richtig verstanden haben, 
dann enthält cmdPtr jetzt eine Adresse zu einem struct im Flash, das 
über den Index i ausgewählt wurde. Stimmt das?

Die Funktion sieht dann jetzt so aus (ich habe mal eine geschrieben, die 
mir einfach die Kommandos an den PC schickt...zum einfachen testen).

char txBuffer[50];
char *cmd;

for(i=0; i <= TOTAL_NUMBER_OF_COMMANDS; i++){
  cmdPtr = (command*)pgm_read_word(&commandList[i]);
  cmd = (char*)pgm_read_word( &cmdPtr->cmd );
  strcpy_P(txBuffer, cmd);
  sendText(txBuffer);
}

So funktionierts dann :-)

Also da muss ich mich noch etwas dran gewöhnen, mich durch die PROGMEMs 
zu hangeln, aber das wird klappen :-)

Vielen lieben Dank nochmals! Jetzt kommen die strings wunderbar bei mir 
an :-)

[Karl H. (kbuchegg)]

Stefan schrieb:
> Hallo Karl Heinz,
> erstmal vielen lieben Dank für deine Hilfe!
>
> Das habe ich jetzt so übernommen. Wenn ich das richtig verstanden haben,
> dann enthält cmdPtr jetzt eine Adresse zu einem struct im Flash, das
> über den Index i ausgewählt wurde. Stimmt das?

Genau


> for(i=0; i <= TOTAL_NUMBER_OF_COMMANDS; i++){
>   cmdPtr = (command*)pgm_read_word(&commandList[i]);

Ja

>   cmd = (char*)pgm_read_word( &cmdPtr->cmd );

Exakt

>   strcpy_P(txBuffer, cmd);

Und auch hier richtig. Das 2.te Argument an strcpy_P ist die Adresse des 
Strings im Flash


> So funktionierts dann :-)
>
> Also da muss ich mich noch etwas dran gewöhnen, mich durch die PROGMEMs
> zu hangeln, aber das wird klappen :-)

Dein Fehler war

pgm_read_word, will die Adresse von der es lesen soll.
commandList[i] ist zwar auch eine Adresse (formal - ist ja 
datantypmässig ein Pointer) aber nicht die Adresse an der der Inhalt von 
commandList[i] steht. Die lautet &commandList[i]

[Johann L. (gjlayde)]

Kannst du nicht einfach __flash verwenden? Dann braucht es dan ganze 
Geraffel mit den pgm_read_xxx Funktionen erst garnicht.

Das einzige, worum du dich dann kümmern musst, sind richtige 
Deklarationen / Definitionen der entsprechenden Daten und Zeiger.