Menü im Programmspeicher anlegen

[Ben (Gast)]

Hallo,

ich möchte ein Menü im Programmspeicher anlegen, damit es nicht den 
Arbeitsspeicher belastet. Für einen Menüeintrag habe ich einen struct 
erstellt, welcher Verweise auf den vorherigen, nächsten, ... 
Menüeintrag, so wie einen Text enthält. Des Weiteren beinhaltet er vier 
Verweise auf Funktionen, die später beim Druck von vier verschiedenen 
Tasten zum Navigieren und Ausführen von Funktionen dienen sollen.

Ich habe jedoch das Problem, dass beim Anlegen von z.B. Menüeintrag 0, 
Menüeintrag 1 noch nicht vorhanden ist, Menüeintrag 0 aber auf 
Menüeintrag 1 verweisen. Soll dies für zwangläufig zu einem Fehler.

Eine Alternative wäre, dass ich das Menü in den Arbeitsspeicher packen 
und die Verweise erst in einer Initialiserung anlege, aber ich wollten 
Arbeitsspeicher eigentlich nicht belasten.

Hat jemand eine Idee, wie ich dieses Problem lösen kann?

Des Weiteren tritt noch ein Fehler auf, den ich gerade nicht lösen kann 
(stehe auf dem Schlauch): "warning: initialization discards qualifiers 
from pointer target type" Der Fehler tritt in den Zeilen auf, in denen 
ich einen entsprechenden Kommentar eingefügt habe. (Beim Verweis auf 
andere Einträge.)

Gruß
Ben

typedef struct MENU{
  struct MENU *prev,       //vorheriger Menüpunkt
  *next,                   //nächster Menüpunkt
  *upmen,                  //übergeordneter Menüpunkt
  *downmen;                //untergeordneter Menüpunkt
  const int8_t *mtext;     //Menütext
  void ( *f0 ) (int8_t i), //Tasterfunktionen 1
  ( *f1 ) (int8_t i),      //Tasterfunktionen 1
  ( *f2 ) (int8_t i),      //Tasterfunktionen 1
  ( *f3 ) (int8_t i);      //Tasterfunktionen 1
} MENU_ENTRY;


void test0(int8_t i);
void test1(int8_t i);
void test2(int8_t i);
void test3(int8_t i);


MENU_ENTRY *menu_root;

//Menü-Struktur (Beispiel)
//
// |-Menü0
// | |-Menü00
// |-Menü1
// |-Menü2

const int8_t menu0_text[] PROGMEM = "Menue0\0";
const int8_t menu00_text[] PROGMEM = "Menue00\0";
const int8_t menu1_text[] PROGMEM = "Menue1\0";
const int8_t menu2_text[] PROGMEM = "Menue2\0";

const MENU_ENTRY menu0 PROGMEM = {
  NULL, 
  &menu1, 
  NULL, 
  &menu00, //hier tritt Fehler auf
  menu0_text, 
  test0, 
  test1, 
  test2,   
  test3};

const MENU_ENTRY menu00 PROGMEM = {
  NULL, 
  NULL, 
  &menu0, 
  NULL, 
  menu00_text, 
  test0, 
  test1, 
  test2, 
  test3};

const MENU_ENTRY menu1 PROGMEM = {
  &menu0,  //hier tritt Fehler auf
  &menu2, 
  NULL, 
  NULL, 
  menu1_text, 
  test0, 
  test1, 
  test2, 
  test3};

const MENU_ENTRY menu2 PROGMEM = {
  &menu1,  //hier tritt Fehler auf
  NULL, 
  NULL, 
  NULL, 
  menu2_text, 
  test0, 
  test1, 
  test2, 
  test3};


void test0(int8_t i)
{
  //...
}

void test1(int8_t i)
{
  //...
}

void test2(int8_t i)
{
  //...
}

void test3(int8_t i)
{
  //...
}

[Peter D. (pdiener)]

>Ich habe jedoch das Problem, dass beim Anlegen von z.B. Menüeintrag 0,
>Menüeintrag 1 noch nicht vorhanden ist, Menüeintrag 0 aber auf
>Menüeintrag 1 verweisen. Soll dies für zwangläufig zu einem Fehler.

Das löst man mit Prototypen:

extern const MENU_ENTRY menu0 PROGMEM;
extern const MENU_ENTRY menu00 PROGMEM;

usw.
ganz am Anfang deklarieren.

Den anderen Fehler kann ich im Moment nicht nachvollziehen, weil er 
nicht bei allen Einträgen auftritt.

Grüße,

Peter

[Peter D. (pdiener)]

Ich würde mal folgendes probieren:

typedef struct MENU{
  struct MENU PROGMEM *prev,
usw.

Grüße,

Peter

[Stefan E. (sternst)]

Was den zweiten Fehler betrifft:
Da fehlt ein const bei den Zeigern in der struct-Definition.

[Ben (Gast)]

Super, danke. Jetzt sind die Fehler behoben, in dem ich Prototypen 
angelegt habe und const bei den Zeigern in der struct-Def. verwende.

Jetzt tritt jedoch bei der Zuweisung des Pointers auf das Menü

menu_root = &menu0;

eine Warnung auf: "assignment discards qualifiers from pointer target 
type".
Diese kann ich beheben, wenn ich "menu_root" als const deklariere. Aber 
dies wäre ja nicht so sinnvoll, da ich den Zeiger ja umbiegen möchte.

Hab ihr eine Idee?

Gruß
Ben

[Stefan E. (sternst)]

Ben schrieb:
> Diese kann ich beheben, wenn ich "menu_root" als const deklariere. Aber
> dies wäre ja nicht so sinnvoll, da ich den Zeiger ja umbiegen möchte.

Und? Es ist ein Unterschied, ob der Zeiger selbst const ist, oder das, 
worauf er zeigt.

[Ben (Gast)]

Das ist mir schon klar. Da ich jedoch nicht weiß, woher die 
Fehlermeldung kommt, habe ich dies mal ausprobiert. Aber mir ist klar, 
dass das "falsch" ist. Es hat mich nur gewundert, dass dann die 
Fehlermeldung weg ist.

Hat noch jemand einen Lösungsvorschlag?

[Karl H. (kbuchegg)]

Ben schrieb:

>
> Hat noch jemand einen Lösungsvorschlag?

> Das ist mir schon klar.


Wenn dir das schon klar ist, wo liegt dann das Problem?


const int * pPtr;

  pPtr ist ein Pointer auf einen int. Und dieser int ist const, kann
  also nicht über den Pointer verändert werden. Der Pointer aber, der
  ist nicht const, du kannst pPtr jederzeit einen neuen Wert zuweisen

  const int i = 5;
  const int j = 8;
  const int* pPtr;

  pPtr = &i;    // legal
  pPtr = &j;    // legal
  *pPtr = 9;    // illegal, denn pPtr zeigt ja auf etwas das const ist


Im Gegensatz dazu:

int * const pPtr;

  Jetzt ist das ebenfalls ein Pointer, der auf einen int zeigt. Aber
  diesmal kann der int über den Pointer verändert werden. Der int ist
  nicht const. Wohl aber ist es die Pointervariable, die kann nicht
  auf einen anderen int gesetzt werden.

  int i = 5;
  int j = 8;
  int* const pPtr = &i;

  pPtr = &j;    // illegal, denn pPtr selber ist const
  *pPtr = 9;    // völlig legal, das const bezieht sich auf pPtr und
                // nicht darauf worauf es zeigt

Und dann gibt es noch

const int * const pPtr;

  Wieder ein Pointer, der auf einen int zeigt. Aber diesmal ist sowohl
  der int, als auch die Pointervariable const. Keines von beiden kann
  verändert werden.

  const int i = 5;
  const int j = 8;
  const int* const pPtr = &i;

  pPtr = &j;    // illegal
  *pPtr = 9;    // illegal


> Diese kann ich beheben, wenn ich "menu_root" als const deklariere. Aber
> dies wäre ja nicht so sinnvoll, da ich den Zeiger ja umbiegen möchte.

Was hindert dich am umbiegen?

[Martin (Gast)]

Peter Diener schrieb:
> Das löst man mit Prototypen:

Nein, mit forward declarations.

Prototypen gibts bei Funktionen.

(Deine Lösung war richtig, nur die Begrifflichkeiten sollte man sauber 
benutzen)

[Ben (Gast)]

Karl Heinz Buchegger schrieb:
> const int * pPtr;
>
> int * const pPtr;
>
> const int * const pPtr;

Ok, dann ich es doch nicht richtig verstanden. Vielen Dank für deine 
ausführliche Erklärung. Jetzt ist mir das klar.

Gruß
Ben