Menü - Array in Struct

[Markus (Gast)]

Hallo Leute,

ich hab hier ein kleines Problem. Leider hilft mir auch die Suche nicht 
weiter ... ich sitz mittlerweile seit zwei Tagen vor dem Problem.

Ich möchte auf meinem ATMEGA 128 ein Menü auf einem 2x16 Display 
ausgeben. Vom Aufbau bin ich mir eigentlich auch ganz im Klaren, wie ich 
das machen möchte.
Dafür hab ich jetzt Structs "gebaut", die meine einzelnen Menüelemente 
darstellen:

typedef struct sValueValue{
  const char *text;
  int prev;
  int next;
  char value;
} MenuValueValues;

typedef struct sValue{
  const char *text;
  int prev;
  int next;
  MenuValueValues values[];
} MenuValue;

typedef struct sChild{
  const char *text;
  int prev;
  int next;
  MenuValue child[];
} MenuChild;

typedef struct sMenu{
  const char *text;
  int prev;
  int next;
  MenuChild child[];
} MenuEntry;

Dann mache ich ein Array, welches ich manuell fülle:

MenuEntry myMenu[];

void InitMenu(void)
{
    
  MenuEntry myI1;
  myI1.text = "System          ";
  myI1.prev = 4;
  myI1.next = 1;
    
    MenuChild myC1;
    myC1.text = "Kommunikation   ";
    myC1.prev = 1;
    myC1.next = 1;
      
      MenuValue myV1;
      myV1.text = "Aktiviert       ";
      myV1.prev = 0;
      myV1.next = 0;
      
        MenuValueValues myVV1;
        myVV1.text = "Ja              ";
        myVV1.prev = 1;
        myVV1.next = 1;
        myVV1.value = 1;
        myV1.values[0] = myVV1;
        
        MenuValueValues myVV2;
        myVV2.text = "Nein            ";
        myVV2.prev = 0;
        myVV2.next = 0;
        myVV2.value = 0;
        myV1.values[1] = myVV2;
        
      myC1.child[0] = myV1;
      
    myI1.child[0] = myC1;
  
    MenuChild myC2;
    myC2.text = "Uhrzeit / Datum ";
    myC2.prev = 0;
    myC2.next = 0;
    myI1.child[1] = myC2;
  
  myMenu[0] = myI1;
  
  MenuEntry myI2;
  myI2.text = "Beleuchtung     ";
  myI2.prev = 0;
  myI2.next = 2;
    
    MenuChild myC3;
    myC3.text = "Type            ";
    myC3.prev = 0;
    myC3.next = 0;
    myI2.child[0] = myC3;
    
  myMenu[1] = myI2;
  
  MenuEntry myI3;
  myI3.text = "Temperatur      ";
  myI3.prev = 1;
  myI3.next = 3;
    
    MenuChild myC4;
    myC4.text = "Temperaturen    ";
    myC4.prev = 3;
    myC4.next = 1;
    myI3.child[0] = myC4;
    
    MenuChild myC5;
    myC5.text = "Zeitsteuerung   ";
    myC5.prev = 0;
    myC5.next = 2;
    myI3.child[1] = myC5;
    
    MenuChild myC6;
    myC6.text = "Type            ";
    myC6.prev = 1;
    myC6.next = 3;
    myI3.child[2] = myC6;
    
    MenuChild myC7;
    myC7.text = "Kalibrieren     ";
    myC7.prev = 2;
    myC7.next = 0;
    myI3.child[3] = myC7;
    
  myMenu[2] = myI3;
  
  MenuEntry myI4;
  myI4.text = "Rolladen        ";
  myI4.prev = 2;
  myI4.next = 4;
    
    MenuChild myC8;
    myC8.text = "Zeitsteuerung   ";
    myC8.prev = 0;
    myC8.next = 0;
    myI4.child[0] = myC8;

  myMenu[3] = myI4;
  
  MenuEntry myI5;
  myI5.text = "Fernbedienung   ";
  myI5.prev = 3;
  myI5.next = 0;
  myMenu[4] = myI5;
  
}

Wenn ich aber jetzt auf meinen ersten "Untermenüpunkt" zugreifen will, 
bekomme ich den zweite "Hauptmenüeintrag zurück.

lcd_string(myMenu[0].child[0].text;

Am Display erscheint dann "Beleuchtung".

Ich muss noch dazu sagen, dass ich mit C als Programmiersprache noch 
ziemlich neu bin. Auch mit uCs hab ich noch nicht viel gemacht.

Vielleicht kann mir jemand von Euch helfen.

Danke schon mal,

Markus

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Markus schrieb:
> Ich muss noch dazu sagen, dass ich mit C als Programmiersprache noch
> ziemlich neu bin.
Das sehe ich auch so. Denn so unbedarft, wie du hier mit (für uCs) 
relativ großen Speichermengen um dich schmeißt...

Das schreibt sich zwar schön kurz:
 myMenu[3] = myI4;
Aber es steckt für den Prozessor durchaus einiges an Arbeit dahinter.

> Auch mit uCs hab ich noch nicht viel gemacht.
Du solltest solche Strukturen nicht im Programm InitMenu() aufbauen, 
sondern gleich vorneweg definieren und im Programmspeicher ablegen.

Seis drum:
Microsoft VC meldet für diese Zeilen
  MenuValue child[];
den Fehler:
error C2233: '<Unknown>' : arrays of objects containing zero-size arrays 
are illegal

Und es ist ja klar: woher soll der Compiler wissen, wieviel 
Speicherplatz für
 MenuEntry myMenu[];
zu reservieren ist?
Du könntest ja später ohne weiteres schreiben:
 lcd_string(myMenu[1234567].child[654321].text;

Also: flugs geändert und deinen Quellcode so geändert:

typedef struct sValueValue{
:
} MenuValueValues;

typedef struct sValue{
:
  MenuValueValues values[5];  //!!!!
} MenuValue;

typedef struct sChild{
:
  MenuValue child[5];  //!!!!
} MenuChild;

typedef struct sMenu{
:
  MenuChild child[5];  //!!!!
} MenuEntry;

MenuEntry myMenu[5];  //!!!!


int main(int argc, char* argv[])
{
  MenuEntry myI1;
  myI1.text = "System          ";
  myI1.prev = 4;
  myI1.next = 1;
    
    MenuChild myC1;
    myC1.text = "Kommunikation   ";
    myC1.prev = 1;
    myC1.next = 1;
      
      MenuValue myV1;
      myV1.text = "Aktiviert       ";
      myV1.prev = 0;
      myV1.next = 0;
:
:
:
  MenuEntry myI5;
  myI5.text = "Fernbedienung   ";
  myI5.prev = 3;
  myI5.next = 0;
  myMenu[4] = myI5;

  printf("%s", myMenu[0].child[0].text);

  return 0;
}

Und heraus kommt: "Kommunikation   "

[Markus (Gast)]

Hallo Lothar,

vielen Dank für Deine Antwort.

Wie ich gesagt hab, ich bin noch ziemlich neu in C und uC ... deshalb 
musst Du mich auch nicht gleich steinigen ... dass mein Code 
opmimierungsfähig ist, ist mir klar. Anfangs hab ich das auch anders 
gehabt - Arrays bei der Definition gefüllt, aber nachdem das nicht 
funktioniert hat, hab ich mich auf die Fehlersuche gemacht und das ganze 
mal (für mich) übersichtlicher geschrieben.

Ich werd das jetzt mal probieren und mal schaun.

Also, vielen Dank nochmals.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Markus schrieb:
> deshalb musst Du mich auch nicht gleich steinigen ...
Kein Sorge, steinigen sieht anders aus... ;-)

> Ich werd das jetzt mal probieren und mal schaun.
Du hast Glück, denn du bist nicht der erste, der so eine Menüstruktur 
fürs Display aufbauen will. Sieh dich doch einfach mal hier im Forum um, 
wie andere das machen:
http://www.mikrocontroller.net/search?query=men%C3%BC+c+progmem&forums[]=1&forums[]=2&max_age=-&sort_by_date=1

[Markus (Gast)]

Ok, so weit so schlecht ... ich denke, ich hab das jetzt verstanden, was 
Du versucht hast, mir zu erklären. Allerdings steig ich, was die Structs 
angeht, in C noch nicht so ganz durch. Meine Deklaration sieht jetzt so 
aus:

typedef struct sValueValue{
  const char *text;
  int prev;
  int next;
  char value;
} MenuValueValues;

typedef struct sValue{
  const char *text;
  int prev;
  int next;
  MenuValueValues values[];
} MenuValue;

typedef struct sChild{
  const char *text;
  int prev;
  int next;
  MenuValue child[];
} MenuChild;

typedef struct sMenu{
  const char *text;
  int prev;
  int next;
  MenuChild child[4];
} MenuEntry;


static const MenuChild MenuSystem[2] = {
  {"Kommunikation   ",1,1},
  {"Uhrzeit / Datum ",0,0},
};

static const MenuChild MenuBeleuchtung[1] = {
  {"Type            ",0,0},
};

static const MenuChild MenuTemperatur[4] = {
  {"Temperaturen    ",3,1},
  {"Zeitsteuerung   ",0,2},
  {"Type            ",1,3},
  {"Kalibrieren     ",2,0},
};

static const MenuChild MenuRolladen[1] = {
  {"Zeitsteuerung   ",0,0},
};

static const MenuChild MenuFernbedienung[1] = {
  {"Lernen          ",0,0},
};

static const MenuEntry myMenu[5] = {
  {"System          ",4,1,MenuSystem},
  {"Beleuchtung     ",0,2,MenuBeleuchtung},
  {"Temperatur      ",1,3,MenuTemperatur},
  {"Rolladen        ",2,4,MenuRolladen},
  {"Fernbedienung   ",3,0,MenuFernbedienung},
};

Jetzt bekomm ich aber beim Kompilieren die folgende Warunung:

initialization from incompatible pointer type

Ich hab doch in der TypeDef von MenuEntry Child als MenuChild 
deklariert.
Warum ist er der Meinung, dass das der falsche Typ ist (das bedeutet 
diese Fehlermeldung doch, soweit google mir das mitgeteilt hat).

[Markus (Gast)]

Hab ich übersehen ... ich bekomm auch noch die Warunung

 missing braces around initializer

Ich wüsste aber nicht wo die {} abgehen?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

So gehts:

typedef struct {
  const char *text;
  int prev;
  int next;
  char value;
} MenuValueValues;

typedef struct {
  const char *text;
  int prev;
  int next;
  MenuValueValues values[4];
} MenuValue;

typedef struct {
  const char *text;
  int prev;
  int next;
  MenuValue child[4];
} MenuChild;

typedef struct sMenu{
  const char *text;
  int prev;
  int next;
  MenuChild child[4];
} MenuEntry;

static const MenuEntry myMenu[5] = {
  {"System          ",4,1,{{"Kommunikation   ",1,1},{"Uhrzeit / Datum ",0,0}} },
  {"Beleuchtung     ",0,2,{{"Type            ",0,0}} },
  {"Temperatur      ",1,3,{{"Temperaturen    ",3,1},{"Zeitsteuerung   ",0,2},{"Type            ",1,3},{"Kalibrieren     ",2,0}} },
  {"Rolladen        ",2,4,{{"Zeitsteuerung   ",0,0}} },
  {"Fernbedienung   ",3,0,{{"Lernen          ",0,0}} },
};

int main(int argc, char* argv[])
{
  printf("%s", myMenu[0].child[0].text);
  printf("%s", myMenu[2].child[3].text);

  return 0;
}

// --> Ausgabe: Kommunikation   Kalibrieren

Überleg mal warum.
Als Tipp: jetzt passiert die Initialisierung genau an 1 Stelle. Es 
werden keine "Zwischenkonstanten" erzeugt...

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Und dann war da noch...

:
:
} MenuEntry;

#define MenuSystem         {{"Kommunikation   ",1,1},{"Uhrzeit / Datum ",0,0}}
#define MenuBeleuchtung    {{"Type            ",0,0}}
#define MenuTemperatur     {{"Temperaturen    ",3,1},{"Zeitsteuerung   ",0,2},{"Type            ",1,3},{"Kalibrieren     ",2,0}}
#define MenuRolladen       {{"Zeitsteuerung   ",0,0}}
#define MenuFernbedienung  {{"Lernen          ",0,0}}

static const MenuEntry myMenu[5] = {
  {"System          ",4,1, MenuSystem         },
  {"Beleuchtung     ",0,2, MenuBeleuchtung    },
  {"Temperatur      ",1,3, MenuTemperatur     },
  {"Rolladen        ",2,4, MenuRolladen       },
  {"Fernbedienung   ",3,0, MenuFernbedienung  }
};
:
:

[Markus (Gast)]

Ok, vielen Dank.

So ähnlich hatte ich das schon gehabt. Hat aber irgendwie nicht 
funktioniert. Bin leider im Moment nicht bei meinem uC, werd das aber 
dann gleich mal probieren.

Das mait #define schaut für mich am Besten aus ... ich denke, so werde 
ich das machen. Ist auch noch schön übersichtlich für mich.

Funktioniert das auch noch, wenn ich eine zusätzliche Ebene habe?

#define NochNMenuy {{"Test",1,1},{"Test2",0,0}}

#define MenuSystem         {{"Kommunikation   ",1,1,NochNMenu},...}

static const MenuEntry myMenu[5] = {
  {"System          ",4,1, MenuSystem         },
  ...
};

Das mit den Konstanten und den Zwischekonstanten ist mir schon klar ... 
ein wenig ;o)
Ich weiß ja, dass es wichtig ist, bei einem uC performant und sparsam zu 
Programmieren. Als Windows-Applikations-Programmierer muss man sich ja 
heutzutage nicht mehr um den Speicher kümmern.
Es ist schon noch irgendwo in meinem Hinterkopf und ich versuche auch 
unter Windows so sparsam und performant wie möglich zu programmieren ... 
nur mit C ist es eben noch nicht so leicht für mich.

[Markus (Gast)]

Funktioniert bestens! Vielen Dank.

[Peter (Gast)]

Zusatzaufgabe: Wie bringt man ganze noch im FLASH statt im RAM ?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Peter schrieb:
> Zusatzaufgabe: Wie bringt man ganze noch im FLASH statt im RAM ?
Das wird insgesamt aufwendiger....
Dein Stichwort dafür ist: PROGMEM
Siehe AVR-GCC-Tutorial unter "Programmspeicher"

[Markus (Gast)]

Hallo Leute,

ich wieder ... jetzt steh ich schon wieder da und blick nicht mehr 
durch.

Also, mein Menü funktioniert wunderbar. Jetzt bin ich dabei, das ganze 
im Programmspeicher mit PROGMEM abzulegen. Dabei jammert der Compiler, 
weil der Pointer umgewandelt wird, oder so. Gut, also versuche ich den 
.text im Struct auf eine fixe Größe zu definieren und mein "Konstrukt" 
kann im Programm-Speicher abgelegt werden:

typedef struct sValueValue{
  char text[16];
  uint8_t prev;
  uint8_tnext;
  uint8_tvalue;
} MenuValueValues;

typedef struct sValue{
  char text[16];
  uint8_tprev;
  uint8_tnext;
  MenuValueValues values[5];
} MenuValue;

typedef struct sChild{
  char text[16];
  uint8_tprev;
  uint8_tnext;
  MenuValue child[12];
} MenuChild;

typedef struct sMenu{
  char text[16];
  uint8_t prev;
  uint8_t next;
  MenuChild child[4];
} MenuEntry;

Wenn ich bei MenuEntry und MenuChild die Größe mit 16 angeb, 
funktioniert es auch. Nur sobald ich die Größe von .text bei MenuValue 
und MenuValuesValue auf 16 setze, funktioniert es nicht mehr.

Der Compiler meldet keinen Fehler, aber das Program am uC läuft nicht 
mehr.

Ich hab jetzt leider die genaue Deklaration meiner Struktur nicht hier, 
aber ich poste sie dann noch.

Kann mir da jemand helfen?

Danke, Markus

[Markus (Gast)]

So, hier ist meine Deklaration:

#define MenuSystemKommunikation   {{"Aktiviert       ",2,1},{"Geschwindigkeit ",0,2},{"Adresse         ",1,0}}
#define MenuSystemUhrzeit       {{"Uhrzeit         ",1,1},{"Datum           ",0,0}}
#define MenuSystem           {{"Kommunikation   ",1,1,MenuSystemKommunikation},{"Uhrzeit / Datum ",0,0,MenuSystemUhrzeit}}

#define MenuBeleuchtungType     {{"Ansteuerung     ",0,0}}
#define MenuBeleuchtung       {{"Type            ",0,0,MenuBeleuchtungType}}

#define MenuTemperaturTemperaturen   {{"Tagestemperatur ",1,1},{"Absenktemperatur",0,0}}
#define MenuTemperaturZeitsteuerung {{"Zeitplanung     ",0,0}}
#define MenuTemperaturType       {{"Regelung        ",1,1},{"Thermostat      ",0,0}}
#define MenuTemperaturKalibrieren   {{"Raumtemperatur  ",1,1},{"Aussentemperatur",0,0}}
#define MenuTemperatur         {{"Temperaturen    ",3,1,MenuTemperaturTemperaturen},{"Zeitsteuerung   ",0,2,MenuTemperaturZeitsteuerung},{"Type            ",1,3,MenuTemperaturType},{"Kalibrieren     ",2,0,MenuTemperaturKalibrieren}}

#define MenuRolladenZeitsteuerung   {{"Zeitplanung     ",0,0}}
#define MenuRolladenKalibrieren    {{"jetzt kalib.    ",0,0}}
#define MenuRolladen         {{"Zeitsteuerung   ",1,1, MenuRolladenZeitsteuerung},{"Kalibrieren     ",0,0,MenuRolladenKalibrieren}}

#define MenuFernbedienungLernen   {{"Licht ein       ",11,1},{"Licht aus       ",0,2},{"Licht heller    ",1,3},{"Licht dunkler   ",2,4},{"Temp. wärmer    ",3,5},{"Temp. kühler    ",4,6},{"Temp. absenken  ",5,7},{"Temp. Tag       ",6,8},{"Rolladen auf    ",7,9},{"Rolladen ab     ",8,10},{"Rolladen öffnen ",9,11},{"Rolladen schl.  ",10,0}}
#define MenuFernbedienung       {{"Lernen          ",0,0,MenuFernbedienungLernen}}

const MenuEntry myMenu[5] = {
  {"System          ",4,1,MenuSystem},
  {"Beleuchtung     ",0,2,MenuBeleuchtung},
  {"Temperatur      ",1,3,MenuTemperatur},
  {"Rolladen        ",2,4,MenuRolladen},
  {"Fernbedienung   ",3,0,MenuFernbedienung},
};

[Karl H. (kbuchegg)]

2 Dinge

1) wie verwendest du das Ganze? (Code)
2) Hast du dir schon mal ausgerechnet, wie gross deine komplette
   Menüstruktur ist?
   Wenn dir beim Ausrechnen etwas kleineres als 17kByte rauskommt,
   dann hast du dich verrechnet. Und da hab ich die ganzen uint8_t
   noch gar nicht mit eingerechnet, sondern nur die Strings.


Nichts gegen diese fix allokierten Arrays. Für kleinere Sachen kann man 
das schon so machen. Aber hier ist definitiv Schluss damit. Du musst 
lernen, wie man mit Verpointerungen arbeitet. Hilft nichts. Du 
allokierst hier ~20kB und mehr als die Hälfte des Speichers liegt 
komplett brach und/oder enthält Leerzeichen oder 0-en

Ich hab auch den Eindruck, dass deine 4-stufige Hierarchie zu 
kompliziert aufgebaut ist. Was machst du, wenn da noch eine Menüebene 
dazukommt? Ein MenuValueValueValues?

[Karl H. (kbuchegg)]

Ich hab mich verrechnet. Ich hab übersehen, dass du ja 5 Stück MenuEntry 
anlegst. Damit verbraucht dein komplettes Menu insgesamt über 100kB an 
Speicher!

Und damit bist du in einem Bereich, in dem du mit pgm_read_byte und 
Konsorten schon gar nicht mehr arbeiten kannst, sondern FAR Zugriffe 
benutzen musst. Definitiv viel zu aufwändig, für so ein Micky Mouse 
Menü!

[Markus (Gast)]

Das ist der Vorteil von diesen neuen WXGA-Displays ... da haben viele 
MenueValuesValuesValues ... Platz.

Du hast schon Recht, ich hab mir das ganze hier nochmal angesehen und 
muss sagen ... das kann nix ... ich denke, ich muss das anders machen. 
Ich glaub ich hab auch schon (wieder) eine (wieder so geistreiche?) Idee 
... aber es happert schon wieder hier.

Ich denke, ich werde es jetzt mal mit Pointern auf Funktionen probieren. 
Für jedes Menü eine eigene Funktion, in welcher die Navigation für das 
jeweilige Menü ist.

Ich hab hier einen Pointer, der ich eine Void zuweise. Aber wenn ich 
diese Void ausführen möchte, meint mein Compiler, ich habe eine 
Anweisung ohne Funktion ...

[c]
void MenuKommunikation(void);

void *myZeiger

int main(void) {

  while(1) {
    //prüfen auf Tasten und so und ggf:
    myZeiger;
  }
}

void MenuKommunikation(void) {
  //hier wird das Menü dargestellt

  //while(nicht auf zurück gedruckt wurde){

  //}
}

[Karl H. (kbuchegg)]

Markus schrieb:

> Ich denke, ich werde es jetzt mal mit Pointern auf Funktionen probieren.
> Für jedes Menü eine eigene Funktion, in welcher die Navigation für das
> jeweilige Menü ist.

Ist eine Möglichkeit.

ABer besser wäre es, wenn du lernst erst mal mit normalen Pointer 
umzugehen


>
> Ich hab hier einen Pointer, der ich eine Void zuweise. Aber wenn ich
> diese Void ausführen möchte, meint mein Compiler, ich habe eine
> Anweisung ohne Funktion ...

Beschäftige dich definitiv zuerst mit normalen Pointern. Dir fehlt noch 
viel.
http://www.mikrocontroller.net/articles/FAQ#Funktionszeiger

[Albert .. (albert-k)]

Hallo
Die ganze Menustruktur im Flash unterzubringen wird etwas ugneschickt 
sein, da wirst du nciht viel gewinnen. Was sich aber lohnt sind die 
namen der Menüeinträge im Flash abzulegen. Im Anhang findest du mal ein 
Beispiel aus einem meiner Projekte wie es dort aussehen könnte. 
Zusätzlich auch noch die Headerdatei mit den typedefs für die Menu 
structs und die verwendeten Funktionen.
Das ganze stammt vom Projekt tinyMenu für AVR. Dort wurden die Strings 
aber im RAM abgelegt, nun liegen sie alle im Flash.

Im Hauptprogramm sieht das ganze dann so aus:

gvMenuEnter(&tdsMenuContext,&tdsMainMenu);
gvMenuDisplay(&tdsMenuContext);

while(1){
    s8MenuSelect = s8GetIncEncVal(4); //read Encoder delta
    //Encoder turned right
    if(s8MenuSelect > 0){
      gvMenuNextEntry(&tdsMenuContext);

    }

    //Encoder turned left
    if(s8MenuSelect < 0){
      gvMenuPrevEntry(&tdsMenuContext);

    }

    //Check if Button has been pushed
    if(u8GetIncEncButtonVal()){
      //call Select routine for the selected menu
      gvMenuSelect(&tdsMenuContext);
    }
}

[Markus (Gast)]

Ich weiß, dass ich mit Pointern noch nicht viel am Hut habe, aber wie 
heißt es so schön? Der Mensch wächst mit seinen Aufgaben.

Ich werd mir jetzt mal überlegen, wie ich mein Menü ändern kann, so dass 
es den gewünschten Komfort bietet und trotzdem sparsam und klein ist.

[Karl H. (kbuchegg)]

Vorschlag für eine rudimentäre Menüstruktur und Programmteilen, die 
dieses Menü ausdumpen. Getestet auf einem PC, daher die printf.

#include <stdio.h>
#include <string.h>

typedef unsigned char uint8_t;

struct ;

typedef struct sMenuChild
{
  const char*   text;
  uint8_t       prev;
  uint8_t       next;
  struct sMenu* subMenu;
} MenuChild;

typedef struct sMenu
{
  uint8_t     nrChilds;
  MenuChild*  childs;
} Menu;

#define NR_ENTRIES(x)  (sizeof(x)/sizeof(*x))


MenuChild commMenu[] = {
  { "Aktiviert",       2, 1, NULL },
  { "Geschwindigkeit", 0, 2, NULL },
  { "Adresse",         1, 0, NULL },
};

Menu menuComm = { NR_ENTRIES( commMenu ), commMenu };


MenuChild timeMenu[] = {
  { "Uhrzeit",         1, 1, NULL },
  { "Datum",           0, 0, NULL },
};

Menu menuTime = { NR_ENTRIES( timeMenu ), timeMenu };


MenuChild systemMenu[] = {
  { "Kommunikation",   1, 1, &menuComm },
  { "Uhrzeit / Datum", 0, 0, &menuTime },
};

Menu menuSystem = { NR_ENTRIES( systemMenu ), systemMenu };


MenuChild lightsMenu[] = {
  { "Ansteuerung",     0, 0, NULL },
};

Menu menuLights = { NR_ENTRIES( lightsMenu ), lightsMenu };


MenuChild mainMenu[] = {
  { "System",        4, 1, &menuSystem },
  { "Beleuchtung",   0, 2, &menuLights },
  { "Temperatur",    1, 3, NULL },
  { "Rolladen",      2, 4, NULL },
  { "Fernbedienung", 3, 0, NULL },
};

Menu menu = { NR_ENTRIES( mainMenu ), mainMenu };

void printIndent( uint8_t level )
{
  uint8_t i;
  for( i = 0; i < level; ++i )
    printf( " " );
}


void dumpMenu( Menu* whichMenu, uint8_t indent );

void dumpChilds( MenuChild* whichChild, uint8_t indent )
{
  printIndent( indent );
  printf( "%-16s %d %d\n", whichChild->text, (int)whichChild->next, (int)whichChild->prev );

  if( whichChild->subMenu )
    dumpMenu( whichChild->subMenu, indent + 2 ); 
}

void dumpMenu( Menu* whichMenu, uint8_t indent )
{
  uint8_t i;

  for( i = 0; i < whichMenu->nrChilds; ++i )
    dumpChilds( &whichMenu->childs[i], indent );
}

int main()
{
  dumpMenu( &menu, 0 );

  return 0;
}

Jedes Menu besteht aus einer gewissen Anzahl an Childs. Jeder Child kann 
selbst wieder einen Verweis zu einem Submenu enthalten (das dann 
seinerseits wieder Childs hat welche Submenues beinhalten können, 
welches wiederrum Childs enthält, welche ..... ad infinitum).

und so sieht der Dump aus

System           1 4
  Kommunikation    1 1
    Aktiviert        1 2
    Geschwindigkeit  2 0
    Adresse          0 1
  Uhrzeit / Datum  0 0
    Uhrzeit          1 1
    Datum            0 0
Beleuchtung      2 0
  Ansteuerung      0 0
Temperatur       3 1
Rolladen         4 2
Fernbedienung    0 3

Jede Einrückung kennzeichnet eine neue Menüebene, in der die zugehörigen 
Menüpunkte samt Verknüpfungsinformation (wozu brauchst du die 
eigentlich, ist doch sowieso durch die Reihenfolge der Einträge 
festgelegt) aufgelistet sind.

[Markus (Gast)]

Ja, das macht natürlich Sinn ...

Die Verknüpfungs-Information brauche ich eigentlich nicht wirklich. Es 
war nur eine Version, die ich mir von jemanden aus dem Forum abgeschaut 
habe. Aber Du hast recht. Die Reihenfolge ist eh mit der Reihenfolge der 
Einträge festgelegt.

Wenn ich das richtig verstehe, werden nur die wirklich benötigten 
Einträge deklariert, nicht wie bei mir, dass das Array auf eine Größe 
von 12 deklariert ist, auch wenn es nur 5 Einträge hat ... nur weil ein 
anderes Menü 12 Einträge hat.

In diese Richtung ist sind auch meine Gedanken am Anfang gegangen, 
allerdings wurde mir im Forum versichert, dass es nicht möglich ist, die 
Größe eines Arrays zu ermitteln. Meiner Meinung nach, ist diese Funktion 
aber Voraussetzung (in meinem Fall) für eine "sparsame" Programmierung.

Ich denke, diese Zeile ist das, was ich gesucht hab.

#define NR_ENTRIES(x)  (sizeof(x)/sizeof(*x))

Ich werde Deinen Vorschlag am Wochenende gleich mal testen.

[Karl H. (kbuchegg)]

Markus schrieb:
> Ja, das macht natürlich Sinn ...
>
> Die Verknüpfungs-Information brauche ich eigentlich nicht wirklich. Es
> war nur eine Version, die ich mir von jemanden aus dem Forum abgeschaut
> habe. Aber Du hast recht. Die Reihenfolge ist eh mit der Reihenfolge der
> Einträge festgelegt.

Die Verknüpfungsinformation kann man auch brauchen. Aber das ist dann 
ein komplett anderer Menüaufbau.
Die Datenstruktur ist dann nicht hierarchisch, sondern einfach nur ein 
Array (und du brauchst noch up und down Einträge um die Ebene wechseln 
zu können). D.h. alle Menüebenen sind in einem einzigen großen Array 
enthalten und nur mit den prev/next/up/down Einträgen wird in diesem 
Array navigiert bzw. die Menüs zur Laufzeit zusammengestellt.

> Wenn ich das richtig verstehe, werden nur die wirklich benötigten
> Einträge deklariert,

genau

> In diese Richtung ist sind auch meine Gedanken am Anfang gegangen,
> allerdings wurde mir im Forum versichert, dass es nicht möglich ist, die
> Größe eines Arrays zu ermitteln.

C-Buch!
Solange dein Array ein Array ist, funtioniert sizeof perfekt. Nur wenn 
du das Array an eine Funktion übergibst, dann übergibst du nicht 
wirklich das Array sondern einen Pointer auf das erste Array Element. 
sizeof liefert dann klarerweise die Größe eines Pointers.

Das ist aber ein anderer Schuh!
Hier ist das Array als Array verfügbar, daher kann man sizeof 
nutzbringend einsetzen.

> Meiner Meinung nach, ist diese Funktion
> aber Voraussetzung (in meinem Fall) für eine "sparsame" Programmierung.

Nimms mir nicht übel.
Aber Voraussetzung für eine 'sparsame' Programmierung ist, dass man 
seinen Werkzeugkasten kennt. Soll heißen, dass man C nicht nur 
oberflächlich durch sammeln von Halbwissen in Foren lernt, sondern dass 
man ein C-Buch durcharbeitet und die Sprache systematisch in all ihren 
Facetten lernt. Da bleibt dann immer noch genügend übrig, was nicht in 
den Büchern steht.

[Markus (Gast)]

Karl heinz Buchegger schrieb:
> Nimms mir nicht übel.
>
> Aber Voraussetzung für eine 'sparsame' Programmierung ist, dass man
>
> seinen Werkzeugkasten kennt. Soll heißen, dass man C nicht nur

Nehm ich Dir nicht übel. Ich geb Dir da vollkommen recht, das man 
Bescheid weiß und sparsam und performant zu Programmieren. Allerdings 
sind das zwei komplett verschiedene Sachen. Ich kann nicht sparsam 
Programmieren, so lange ich die jeweiligen Funktionen nicht kenne, klar 
... andererseits kann man auch nicht sparsam Programmieren, wenn man die 
Sprach zwar perfekt beherscht, aber die Technologien die man dafür 
braucht, nicht vorhanden sind.

[Karl H. (kbuchegg)]

Bei seinen ersten Programmierschritten, ist 'sparsames Programmieren' 
noch gar nicht gefragt. Es soll nicht ausser Acht gelassen werden, ok, 
aber es hat für einen Neuling nicht die Top-Priorität. So wie ein 
Radfahr-Neuling seine Top-Priorität auf dem Obenhalten auf dem Rad hat 
und nicht darauf, welche Atmentechnik er über 2500m Seehöhe für eine 
Alpenüberquerung braucht.

[Markus (Gast)]

Ja, so sehe ich das schon auch. Aber ich denke, speziel bei uCs ist es 
wichtig, dass man eben diese Sache nicht aus den Augen verlieren darf. 
Besonders wichtig ist es dann, wenn man auf einem uC mit gewissen 
Ressourcen entwickelt und sein Programm dann auch auf andere portieren 
möchte ...