Arduino Uno struct in PROGMEM lesen ?

[Tom (tom_iphi)]

Hallo,

ich habe Probleme auf eine komplexere Datenstruktur im Programmspeicher 
des Atmega328P mittels Arduino C zuzugreifen.
Es geht um den Zugriff mit:

  strcpy_P(s, (char*)pgm_read_byte(&(SubArray[i].submenu[j])));

Wenn i eine Konstante ist gehts, wenn i eine Variable ist gehts nicht.
Was geht da schief und wie mach ichs richtig?

Danke, Tom

Hier der Arduino Sketch mit meiner Datenstruktur und meinen 
Leseversuchen:

const char sub0_0[] PROGMEM = "IT00"; 
const char sub0_1[] PROGMEM = "IT01"; 
const char* const sub0[] PROGMEM = { sub0_0, sub0_1}; 
                                                                 
const char sub1_0[] PROGMEM = "IT10";                                                                  
const char sub1_1[] PROGMEM = "IT11";
const char sub1_2[] PROGMEM = "IT12";
const char* const sub1[] PROGMEM = { sub1_0, sub1_1, sub1_2}; 
                                                                
// Define a data structure containing an array of submenus and an integer
// indicating the number of submenus
struct TSubs{
char count;
char** submenu; 
};

const struct TSubs SubArray[2] PROGMEM = {
{2, sub0},
{3, sub1}
};

void test(void){
  char s[5];
  //accessing submenus with constant first index works!
  Serial.print("constant index i=0");
  Serial.write(0x0D);
  Serial.write(0x0A);
  char i=0;
  char n=pgm_read_byte(&(SubArray[i].count));
  for (char j=0;j<n;j++){
    strcpy_P(s, (char*)pgm_read_byte(&(SubArray[i].submenu[j])));
    Serial.print(s);
    Serial.write(0x0D);
    Serial.write(0x0A);    
  }
  Serial.print("constant index i=1");
  Serial.write(0x0D);
  Serial.write(0x0A);
  i=1;
  n=pgm_read_byte(&(SubArray[i].count));
  for (char j=0;j<n;j++){
    strcpy_P(s, (char*)pgm_read_byte(&(SubArray[i].submenu[j])));
    Serial.print(s);
    Serial.write(0x0D);
    Serial.write(0x0A);    
  }
  
  //accessing submenus with variable first index fails!
  for (i=0;i<2;i++){
    Serial.print("variable index i=");
    Serial.print((int)i);  
    Serial.write(0x0D);
    Serial.write(0x0A);
    n=pgm_read_byte(&(SubArray[i].count));
    for (char j=0;j<n;j++){
      strcpy_P(s, (char*)pgm_read_byte(&(SubArray[i].submenu[j])));
      Serial.print(s);
      Serial.write(0x0D);
      Serial.write(0x0A);    
    }
  }
}

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

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

[Arduino F. (Firma: Gast) (arduinof)]

Tom schrieb:
> Serial.write(0x0D);
> Serial.write(0x0A);

Serial.println();

Tom schrieb:
> ich habe Probleme auf eine komplexere Datenstruktur im Programmspeicher
> des Atmega328P mittels Arduino C zuzugreifen.
Ich sehe keine komplexe Datenstruktur.
Das ist C++, kein C

Mein Vorschlag!
Verwende Codetags.
Reduziere das Programm auf ein Minimum.
Sage, was du erreichen willst, dem Code sehe ich das nicht an.

Warum Machst du das nicht so, wie in der Doku beschrieben?

[Rainer W. (rawi)]

Tom schrieb:
> Hier der Arduino Sketch mit meiner Datenstruktur und meinen
> Leseversuchen (sorry, habe nicht herausfinden können, wie man hier Code
> vernünftig formatiert):

"Wichtige Regeln - erst lesen, dann posten!"
Formatierung unter: "C-Code"

[Tom (tom_iphi)]

Sorry, ich dachte, wenns im Editor zum Formatieren keinen Knopf gibt, 
dann kann man auch nicht formatieren. Habe ich jetzt repariert.

Das obige Beispiel ist bereits das lauffähige Minimalbeispiel.

Was ich erreichen will:

Ich habe diese Menü-Datenstruktur im Flash:

const char sub0_0[] PROGMEM = "IT00"; 
const char sub0_1[] PROGMEM = "IT01"; 
const char* const sub0[] PROGMEM = { sub0_0, sub0_1}; 
                                                                 
const char sub1_0[] PROGMEM = "IT10";                                                                  
const char sub1_1[] PROGMEM = "IT11";
const char sub1_2[] PROGMEM = "IT12";
const char* const sub1[] PROGMEM = { sub1_0, sub1_1, sub1_2}; 
                                                                
// Define a data structure containing an array of submenus and an integer
// indicating the number of submenus
struct TSubs{
char count;
char** submenu; 
};

const struct TSubs SubArray[2] PROGMEM = {
{2, sub0},
{3, sub1}
};

Die Strings will ich indiziert in ein Array im RAM kopieren, z.B. so:

char s[5];
strcpy_P(s, (char*)pgm_read_byte(&(SubArray[i].submenu[j])));

Das funktioniert aber nur solange i eine Konstante ist. Sobald i eine 
Schleifenvariable ist, kommt Mist raus. Warum? Wie gehts richtig?

[Arduino F. (Firma: Gast) (arduinof)]

Tom schrieb:
> Wie gehts richtig?

Wenn du ein Array mit Zeigern hast, dann solltest du auch Zeiger aus dem 
Array lesen.

Tom schrieb:
> Die Strings will ich indiziert in ein Array im RAM kopieren,
Warum?
Eine Ausgabe ist auch ohne Kopie möglich.

Vorschlag:
Wenn die Zeichenketten immer gleich lang sind, dann kannst du auch mit 
einem 2 Dimensionalen Array arbeiten.
Den doofen Count mitzuführen ist dann nicht notwendig. (vielleicht)
count als char ist doof, weil man mit char nicht rechnen kann/soll

[Arduino F. (Firma: Gast) (arduinof)]

Tom schrieb:
> Wenn i eine Konstante ist gehts, wenn i eine Variable ist gehts nicht.
> Was geht da schief und wie mach ichs richtig?

Das ist die interessante Frage....
Warum?

#include <Streaming.h> // die Lib findest du selber ;-)
Print &cout = Serial; // cout Emulation für "Arme"

const unsigned a PROGMEM {42};
const unsigned b PROGMEM {4711};
volatile const unsigned c PROGMEM {22};

void setup() 
{
  Serial.begin(9600);
  cout << F("a: ") << a << endl;  // falscher Zugriff
  cout << F("b: ") << pgm_read_word(&b) << endl; // richtiger Zugriff
  cout << F("c: ") << c << endl;  // falscher Zugriff
  cout << F("c: ") <<  pgm_read_word(&c) << endl;  // richtiger Zugriff
}

void loop() 
{

}

Es ist die Optimierung die dir einen Streich spielt.
Der Compiler weiß nix über PROGMEM und EEMEM.
Kennt er nicht, darum benötigen wir auch besondere Zugriffsfunktionen um 
in die Speicher zu greifen.
Die Verwendung von Konstanten kann der Optimizer super gut optimieren.
Den Zugriff über Variablen weniger.
Wenn man die Optimierung deaktiviert, dann brichts auch mit Konstanten 
ins Essen.

Hier schalte ich partiell die Optimierung per volatile ab.
a funktioniert trotz falschem Zugriff, dank Optimierung richtig
b funktioniert, zeigt wie es muss

c hat zwei Gesichter ein richtiges, da mit Zugriffsmethode und ein 
falsches, da Optimierung für c abgeschaltet

Das ist genau die Falle in die du getappt bist


Dein Menü:

#include <Streaming.h> // die Lib findest du selber ;-)
Print &cout = Serial; // cout Emulation für "Arme"

using FlashStr = __FlashStringHelper *;

template<typename T, size_t N > constexpr size_t arrayCount(T (&)[N])
{
  return N;
}


const char sub0_0[] PROGMEM {"IT00"};
const char sub0_1[] PROGMEM {"IT01"};
const char *const sub0[]  PROGMEM { sub0_0, sub0_1};

const char sub1_0[] PROGMEM {"IT10"};
const char sub1_1[] PROGMEM {"IT11"};
const char sub1_2[] PROGMEM {"IT12"};
const char *const sub1[]  PROGMEM { sub1_0, sub1_1, sub1_2};

struct Sub
{
  const size_t count;
  const char *const *submenu;
};

const Sub subArray[] PROGMEM 
{
  {arrayCount(sub0), sub0},
  {arrayCount(sub1), sub1}
};



void setup()
{
  Serial.begin(9600);
  cout << F("Start:") << endl;
  for(auto &sub : subArray)
  {
    const char **menuArray = reinterpret_cast<const char **>(pgm_read_ptr(&sub.submenu));
    for(unsigned i = 0; i < pgm_read_word(&sub.count); i++)
    {
      const char *menuItem = reinterpret_cast<const char*>(pgm_read_ptr(menuArray+i));
      cout <<  FlashStr(menuItem) << endl;
    }
    cout << endl;
  }
}

void loop()
{

}

[Oliver S. (oliverso)]

Arduino F. schrieb:
> Hier schalte ich partiell die Optimierung per volatile ab.
> a funktioniert trotz falschem Zugriff, dank Optimierung richtig
> b funktioniert, zeigt wie es muss
>
> c hat zwei Gesichter ein richtiges, da mit Zugriffsmethode und ein
> falsches, da Optimierung für c abgeschaltet

Sei mir nicht böse, aber das ist Wort für Wort von vorne bis hinten 
völliger Unsinn.

Die richtige Antwort ist schlicht RTFM.

Ob es die von der avrlibc ist, oder die vom Arduino, ist egal. Oder 
gleich hier:
https://www.mikrocontroller.net/articles/AVR-Tutorial:_Speicher

Da ist beschrieben und dokumentiert, wie man auf Daten im Flash 
zugreift. Das hat mit irgendwelchen Gesichtern von C (die es nicht gibt) 
oder abschalten der Optimierung durch volatile (was völliger Unsinn ist) 
nichts zu tun.

Oliver

[Arduino F. (Firma: Gast) (arduinof)]

Oliver S. schrieb:
> ...
Du hast das Problem des TO nicht verstanden!
Natürlich liegt es an der Optimierung, dass er "versehentlich" richtige 
Daten bekommt, wenn ihm Konstanten verwendet.

Oliver S. schrieb:
> RTFM
Da hast du allerdings wahr.

Oliver S. schrieb:
> Ob es die von der avrlibc ist, oder die vom Arduino, ist egal.
Das ist nicht egal, sondern exakt das selbe.

Oliver S. schrieb:
> Ob es die von der avrlibc ist, oder die vom Arduino, ist egal. Oder
> gleich hier:
> https://www.mikrocontroller.net/articles/AVR-Tutorial:_Speicher
>
> Da ist beschrieben und dokumentiert, wie man auf Daten im Flash
> zugreift.
Was soll die dämliche Nebelkerze?
Wir sind hier in C++ und nicht  in ASM.

[Peter D. (peda)]

Arduino F. schrieb:
> Vorschlag:
> Wenn die Zeichenketten immer gleich lang sind, dann kannst du auch mit
> einem 2 Dimensionalen Array arbeiten.

So mache ich das auch. Ansonsten ist das ein riesen Wust an 
Schreibarbeit und somit gerne eine Fehlerquelle.
Im Flash muß man ja nicht mit jedem Byte geizen, da legt man einfach die 
maximale Länge für alle Strings im Array fest.

Wie schon gesagt wurde, einen Pointer im Flash muß man dann mit 
pgm_read_word() zugreifen, die Pointerschreibweise x[i] funktioniert 
also nicht mehr.

[Oliver S. (oliverso)]

Arduino F. schrieb:
> Du hast das Problem des TO nicht verstanden!
> Natürlich liegt es an der Optimierung, dass er "versehentlich" richtige
> Daten bekommt, wenn ihm Konstanten verwendet.

Wenn ein Programm mit/ohne Optimierung funktioniert, und ohen/mit nicht, 
liegt es niemals an der Optimierung, sondern immer am Programm (seltene 
Compilerfehler mal ausgenommen). Und den Begriif volatile mit 
Optimierung in einem Satz zu nennen ist ebenso immer garantiert 
unsinnig.

Das Problem, daß folgendes nicht das tut, was der TO erwartet
> strcpy_P(s, (char*)pgm_read_byte(&(SubArray[i].submenu[j])));

hat nichts mit Optimierungen zu tun, sondern damit, daß SubArray in 
Flash liegt, und submenu auch. pgm_read_byte macht das, was es lt. Doku 
macht, und liest ein byte von der übergeben Adresse aus dem Flash. 
SubArray[i] wird in dem Fall aber einer Adressen im SRam gelesen, obwohl 
das eigentlich im Flash stehen. Das liefert in solchen Fällen sogar 
häufig trotzdem das richtige Ergebnis, weil der gleiche Fehler auch beim 
Schreiben gemacht wird, und die Daten daher tatsächlich im SRAM stehen, 
und gar nicht bzw. nicht nur, wie eigentlich gewollt, im Flash.

Falsch ist das trotzdem.

Man kann per PROGMEM ins Flash gelegte Daten, auf die ein ebenfalls im 
Flash liegender Pointer zeigt, nicht in einem Schritt mit pgm_read über 
den Flashpointer auslesen. Das braucht immer zwei pgm_read-Aufrufe, 
einer für den Pointer, den zweiten dann für die Daten.

Arduino F. schrieb:
> Was soll die dämliche Nebelkerze?
> Wir sind hier in C++ und nicht  in ASM.

Das war tatsächlich der falsche link. Hier der richtige:
https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Flash_mit_PROGMEM_und_pgm_read

Oliver

[Arduino F. (Firma: Gast) (arduinof)]

Oliver S. schrieb:
> liegt es niemals an der Optimierung,

Merke: Ich habe nicht gesagt, dass die Optimierung kaputt ist.
Mit keinem Wort!
Noch nicht einmal angedeutet.


Ja, der TO verwendet die Zugriffsfunktionen nicht, bzw. unzureichend.
Und die Optimierung bügelt seinen Fehler teilweise/manchmal wieder aus.

Das habe ich gesagt/gemeint und sogar mit einem Programm belegt.
Reproduzierbar.
Auch für dich.

Oliver S. schrieb:
> hat nichts mit Optimierungen zu tun,
Offensichtlich doch!
Siehe Beispiel mit  a b c



Oliver S. schrieb:
> Das war tatsächlich der falsche link.
Nicht nur ein falscher Link, sondern auch extrem blöde Anmache, obwohl 
das Verständnisproblem alleine auf deiner Seite liegt.

Oliver S. schrieb:
> Und den Begriif volatile mit
> Optimierung in einem Satz zu nennen ist ebenso immer garantiert
> unsinnig.
Deine Kompetenz leuchtet heute recht schwach!
Eigentlich erwarte ich viel mehr von dir.....