Menüführung in C

[Schiri (Gast)]

Ich versuche eine Menüführung in c zu realisieren:

Es sieht in etwa wie folgt aus:

unsigned char flag = 0;
...
while(1)
{
        if ((!BUTBACK_READ && !BUTNEXT_READ && flag == 0))
        {
            DelayMs(500);
            if ((!BUTBACK_READ && !BUTNEXT_READ))
            {
                DelayMs(100);
                flag++;
            }
        }

        if (!BUTNEXT_READ && flag == 1)
        {
              DelayMs(100);
              flag++;
              
        }

           if (!BUTBACK_READ && flag == 1)
          {
              flag--;
              beep();
          }


          switch (flag)
          {
              case =0:
                  menu_anzeigen0(); break;
              case 1:
                  menu_anzeigen1(); break;
              case 2:
                  menu_anzeigen2(); break;
          }

}

Er setzt das Flag immer direkt = 2,was mir unverständlich ist.
Passt das in etwa so oder ist das totaler Schrott? Es soll schon eine 
relativ verschachtelte Menüführung werden.

Welche anderen Optionen gibt es in C?

Danke

[Cyblord -. (cyblord)]

breaks vergessen.

Compilerwarnungen beachten!

[Karl H. (kbuchegg)]

Erst mal Tasterkennung und Tastenentprellung vom Menü trennen. Das sind 
zwei Dinge, die so nicht zusammengehören.

Empfehlen kann ich die Danegger Entprellung aus dem Artikel 
Entprellung. Mit der ist der Teil Tastenerkennung erledigt und die 
weitere Auswertung ein Kinderspiel.

   currentMenu = 0;
   while( 1 ) {

     if( get_key_press( 1 << KEY_NEXT ) ) {
       if( currentMenu < maxNrMenuPoints - 1 )
         currentMenu++;
     }

     if( get_key_press( 1 << KEY_BACK ) ) {
       if( currentMenu > 1 )
         currentMenu--;
     }

    switch( currentMenue )
       .....
  }

Was du da mit den Makros und dem flag aufziehst, sieht nicht koscher 
aus. Da ich aber nicht weiss, was BUTBACK_READ liefert, enthalte ich 
mich der Stimme. Was diese Makros tun, musst du selber wissen. Und auch 
ob die 0 oder 1 bei nicht gedrückter Taste liefern.

[Cyblord -. (cyblord)]

Oha nein die Breaks sind ja da.

[Klaus W. (mfgkw)]

Ich sehe nicht recht, was du mit deinem Quelltext vorhast.

Aber evtl. wolltest du ab dem zweiten if... ein else if.. haben?
Weil so wie es hier steht kann er ja je nach BUT... ggf. mehrfach das 
flag++ machen, und kommt dann leicht auf flag==2.

(Nebenbei: flag ist jetzt kein besonders aussagekräftiger Name, ich sehe 
nicht was es markieren soll...)

[Oliver (Gast)]

Ein Else hilft da auch nicht weiter, denn in der zweiten Runde ist flag 
dann trotzdem wieder 2.

Oliver

[Klaus W. (mfgkw)]

Wenn du das in der zweiten "Runde" (der Durchlauf deiner Schleife?) 
wieder wie zu Anfang haben willst, musst du flag halt nach jedem 
Durchlauf zurücksetzen - sonst bleibt es natürlich auf seinem Wert 
stehen.

[Schiri (Gast)]

Hallo,

ich habe die Menüführung ähnlich dem Vorschlag von Karl Heinz realisiert 
und es klappt auch wie gewünscht, danke dafür.

Jetzt möchte ich aber in den Untermenüs, dieselben Taster mit einer 
anderen Funktion abfragen, also in etwa so:

   currentMenu = 0;
   while( 1 ) {

     if( get_key_press( 1 << KEY_NEXT ) ) {
       if( currentMenu < maxNrMenuPoints - 1 )
         currentMenu++;
     }

     if( get_key_press( 1 << KEY_BACK ) ) {
       if( currentMenu > 1 )
         currentMenu--;
     }

    switch( currentMenue )
       case 0:
       menu_1(); break;

  }

In menu_1

[Schiri (Gast)]

EDIT:
In Menu_1 etc. sollen jetzt wieder dieselben Taster abgefragt werden nur 
natürlich was anderes machen. Es handelt sich also um eine Art 
"verzweigtes Menü". Möchte natürlich keine fertigen Lösungen, sondern 
nur ein paar Rat- bzw. Vorschläge wie man sowas machen kann. Am besten 
wäre, wenn man dabei an das obige Beispiel anknüpfen könnte.

Schönen Dank

[Bastler (Gast)]

Trenne das Ganze in drei Teile:

1. Tastenerkennung mit Entprellung
2. Aktionsmenü -> Hier werden Aktionen je nach aktuellen Menüpunkt 
ausgeführt (Switch case)
3. Anzeigemenü -> Hier werden Dinge angezeigt je nach aktuellen 
Menüpunkt (Switch case)

[Schiri (Gast)]

Bastler schrieb:
> Trenne das Ganze in drei Teile:
>
> 1. Tastenerkennung mit Entprellung
> 2. Aktionsmenü -> Hier werden Aktionen je nach aktuellen Menüpunkt
> ausgeführt (Switch case)
> 3. Anzeigemenü -> Hier werden Dinge angezeigt je nach aktuellen
> Menüpunkt (Switch case)

Hmm, also in etwa so??

currentMenu = 0;
   while( 1 ) {

     if( get_key_press( 1 << KEY_NEXT ) ) {
       Switch(currentMenu)
       {
         case 0:
         currentMenu++;
         case 1:
         if( get_key_press( 1 << KEY_NEXT ) ) ...
         case 2:
         if( get_key_press( 1 << KEY_BACK ) ) ...
         ...
       }
     }

     if( get_key_press( 1 << KEY_BACK ) ) {
       Switch(currentMenu)
       {
         case 0:
         currentMenu--;
         case 1:
         if( get_key_press( 1 << KEY_BACK ) )
       }
     }

    switch( currentMenue )
       case 0:
       menu_1(); break;
       ...

  }

[Karl H. (kbuchegg)]

Schiri schrieb:

>      if( get_key_press( 1 << KEY_NEXT ) ) {
>        Switch(currentMenu)
>        {
>          case 0:
>          currentMenu++;
>          case 1:
>          if( get_key_press( 1 << KEY_NEXT ) ) ...

Nope. Das wird nicht funktionieren. Du wirst es wohl kaum schaffen, die 
Taste genau in dem kurzen Zeitraum zwischen dem ersten Aufruf von 
get_key_press und dem zweiten AUfruf zu drücken. Dazu bist du nicht 
schnell genug.

Eine einfache Version besteht darin, dass man jedes Menü in eine eigene 
Funktion mit ihrer eigenen Schleife verpackt. WIrd ein Submenu 
ausgewählt, dann springt man in die betreffende Funktion, die dieses 
Submenue behandelt. Der Nachteil ist natürlich, dass der Prozessor dann 
in diesem Submenu hängt und nebenbei ausser Interrupts nichts anderes 
mehr macht.

void configMenu();

void mainMenu()
{
  uint8_t currentMenu = 0;

  while( 1 )
  {
    if( get_key_press( 1 << KEY_NEXT ) )
    {
      if( currentMenu < 1 )
        currentMenu++;
    }

    if( get_key_press( 1 << KEY_PREV ) )
      if( currentMenu > 0 )
        currentMenu--;
    }

    if( get_key_press( 1 << KEY_ACTION ) )
      if( currentMenu == 0 )
        configMenu();
        lcd_clear();
      }

      else if( currentMenu == 1 )
        return;
    }

    lcd_gotoxy( 0, 0 );
    if( currentMenu == 0 )
      lcd_puts( "Konfig" );
    else if( currentMenu == 1 )
      lcd_puts( "Exit   " );
  }
}

void configMenu()
{
  uint8_t currentMenu = 0;

  while( 1 )
  {
    if( get_key_press( 1 << KEY_NEXT ) )
    {
      if( currentMenu < 2 )
        currentMenu++;
    }

    if( get_key_press( 1 << KEY_PREV ) )
      if( currentMenu > 0 )
        currentMenu--;
    }

    if( get_key_press( 1 << KEY_ACTION ) )
      if( currentMenu == 0 )
        LightOn = !LightOn;

      else if( currentMenu == 1 )
        SoundOn = !SoundOn;

      else if( currentMenu == 2 )
        return;
    }

    lcd_gotoxy( 0, 0 );
    if( currentMenu == 0 )
      lcd_puts( LightOn ? "Licht ein" : "Licht aus" );
    else if( currentMenu == 1 )
      lcd_puts( SoundOn ? "Ton ein  " : "Ton aus  " );
    else if( currentMenu == 2 )
      lcd_puts( "Zurueck  " );
  }
}

int main()
{
  ....


  while( 1 )
  {

    // wenn der Benutzer auf 'Action' drückt, kommt er in die Menuesteuerung
    if( get_key_press( 1 << KEY_ACTION ) )
      mainMenu();

    ....
  }
}

Optimal ist das noch lange nicht. Aber es ist mal ein Anfang für ein 
simples Menuesystem. Hier kann man sich zb mal überlegen, wie man die 
prinzipiell gleichen Funktionen für die Menues zu einer allgemeinen 
Funktion zusammenfassen kann, so dass man all das was ein Menu ausmacht 
in einer Struktur sammelt und die gleiche Funktion datengetrieben 
arbeitet, so dass man nicht für jedes Submenu eine weitere Funktion 
schreiben muss.

[Schiri (Gast)]

OK vielen Dank, sieht recht plausibel aus.
Das Problem ist, wenn ich einmal im MainMenu oder im configMenu hänge, 
wie komme ich bei Tasten Druck dann wieder in das vorherige Menu?

Diese Funktionalität muss in meinem Beispiel auf jeden Fall 
gewährleistet sein.
Ist dies irgendwie auch in dem obigen Beispiel möglich

[Uwe (de0508)]

Hallo Schiri,

ich löse dass bei mir mit zwei Tasten, für die ich zwei Funktionen nutze 
- short_keypress und long_keypress - und somit 4 Events erhalte.

Hier mal die Tabelle zu den Events

-------------------------
Keypress | Key1  | Key2
-------------------------
short    | Links | Rechts
-------------------------
long     | Exit  | Ok
-------------------------

Wenn man PeDas Entprellroutine verwendet, dann kann man das so 
konfigurieren.

[Karl H. (kbuchegg)]

Schiri schrieb:
> OK vielen Dank, sieht recht plausibel aus.
> Das Problem ist, wenn ich einmal im MainMenu oder im configMenu hänge,
> wie komme ich bei Tasten Druck dann wieder in das vorherige Menu?

Entweder mit einer speziellen Taste oder aber so wie ich das 
vorgeschlagen habe, mit einem Menüpunkt "Zurück".
Aber egal wie, mit der programmteschnischen Umsetzung verschachtelter 
Menues hat das ja nichts zu tun. Denn egal wie du das dann konkret 
machst, dieses Problem hast du in jedem Fall. Bei verschachtelten Menüs 
gibt es nun mal 4 mögliche Aktionen:
 nächter Menüpunkt
 vorhergehender Menüpunkt
 Menüpunkt auswählen bzw. in ein Submenü einsteigen
 aus einem Submenü wieder eine Hierarchieebene aussteigen.

Und die musst du unterscheiden können. Egal wie.


> Diese Funktionalität muss in meinem Beispiel auf jeden Fall
> gewährleistet sein.
> Ist dies irgendwie auch in dem obigen Beispiel möglich

Du hast den Code aber schon studiert. Oder?

[Schiri (Gast)]

OK Danke,

ich versuche meinen Code mal anzupassen und werde dann berichten. Vielen 
Dank schon einmal für den Denkanstoss.

Mein grundsätzliches Problem ist, dass ich keine "reinen" Action Tasten 
und keine reinen Next oder Back Tasten habe, d.h. je nachdem in welchem 
Menuunterpunkt ich mich befinde, muss ich immer abfragen was der 
jeweilige Taster überhaupt bezwecken soll/muss.

[Nop (Gast)]

Wäre es nicht einfacher eine Baumstruktur aufzubauen mit einer 
geeigneten struct die auch gleichzeitig noch die Funktionspointer für 
die unterschiedlichen Aktionen des jeweiligen Menupunktes beinhalten?

[Schiri (Gast)]

Hmmm,

wie (nur in etwa) würde das aussehen?

[Karl H. (kbuchegg)]

Schiri schrieb:
> Hmmm,
>
> wie (nur in etwa) würde das aussehen?

zb ungefähr so

typedef void (*FnctPtr)(void);

struct MenuEntry
{
  const char* text;       // Text für den Menüpunkt
  uint8_t     idForNext;  // Welcher Menüeintrag ist der nächste wenn Next gedrückt wird
  uint8_t     idForBack;  // Welcher Menueeintrag ist der nächste wenn Back gedrückt wird
  uint8_t     ifForAction; // welches Submenue soll aufgerufen werden, wenn ... ???
  FnctPtr     function;   // Welche Funktion soll aufgerufen werden, wenn ... ???
};

void ToggleLight( void )
{
  LightOn != LightOn;
}

void ToggleSound( void )
{
  SoundOn != SoundOn;
}

struct MenuEntry[] = {
  { "Konfig  ",     1, 0xFF,    2, NULL },         // 0
  { "Exit    ",  0xFF,    0, 0xFE, NULL },         // 1

  { "Light   ",     3, 0xFF, 0xFF, ToggleLight },  // 2
  { "Sound   ",     4,    2, 0xFF, ToggleSound },  // 3
  { "Zurueck ",  0xFF,    3,    0, NULL }          // 4 
};

für jeden Menüpunkt gibt es eine Beschreibung: welcher Menüpunkt ist der 
nächste, wenn auf NEXT gedrückt wird, welcher Menüpunkt ist der nächste 
wenn auf PREV gedrückt wird und welcher Menüpunkt wird angesprungen wenn 
eine entsprechende Aktion auszuführen ist. Das kann entweder ein anderer 
Menüpunkt sein oder eine Funktion die auszuführen ist.
(Bei allen Id der Menüpunkte hab ich eingeführt, das 0xFF als 'kein 
Eintrag' angesehen wird, da ich die 0 brauche, weil 0 ja ein gültiger 
Index ins Array ist. 0xFE ist der Code an dieser Stelle, dass das 
Menüsystem überhaupt verlassen werden soll)

Da kann man dann eine einfache FUnktion schreiben, die ganz einfach beim 
ersten Menüpunkt anfängt und die Information, welche Taste gedrückt 
wurde mit den Informationen der Beschreibung verknüpft, um die 
gewünschte Aktion zu machen

void HandleMenu()
{
  uint8_t currentId = 0;

  while( currentId != 0xFE )
  {
    if( get_key_press( 1 << NEXT ) )
    {
      if( MenuEntry[currentId].idForNext != 0xFF )
        currentId = MenuEntry[currentId].idForNext;
    }

    if( get_key_press( 1 << PREV ) ) {
      if( MenuEntry[currentId].idForPrev != 0xFF )
        currentId = MenuEntry[currentId].idForPrev;
    }

    if( get_key_press( 1 << ACTION ) ) {
      if( MenuEntry[currentId].idForAction != 0xFF )
        currentId = MenuEntry[currentId].idForAction;

      else if( MenuEntry[currentId].function != NULL )
        MenuEntry[currentId].function();
    }

    lcd_gotoxy( 0, 0 )
    lcd_puts( MenuEntry[currentId].text );
  }
}

wie du allerdings mit nur 2 Tasten eine vernünftige Menüführung 
hinkriegen willst, ist mir noch schleierhaft. Zumindest 3 Tasten 
brauchst du mindestens. Denn 2 Tasten brauchst du ja schon, um durch die 
Menüs vorwärts und rückwärts zu navigieren.
Gut, bei kleinen Menüs könnte man auf das rückwärts navigieren 
verzichten und die Menüpunkte einer Ebene im Kreis durchlaufen lassen. 
Dann würden nur 2 Tasten reichen. Aber du willst ja anscheinend vorwärts 
und rückwärts navigieren können. Dann allerdings brauchst du noch eine 
3. Taste mit der Bedeutung "Diese Aktion jetzt ausführen". Gedanken 
lesen kann ein Computer nun mal nicht.

[Karl H. (kbuchegg)]

Schiri schrieb:

> Mein grundsätzliches Problem ist, dass ich keine "reinen" Action Tasten
> und keine reinen Next oder Back Tasten habe, d.h. je nachdem in welchem
> Menuunterpunkt ich mich befinde, muss ich immer abfragen was der
> jeweilige Taster überhaupt bezwecken soll/muss.

Ohne jetzt die Details zu kennen, kann ich dir davon nur abraten. 
Benutzer haben es gerne, wenn dieselben Tasten immer dieselben Aktionen 
machen. Oder zumindest eine thematisch ähnliche Aktion. Die 'Vorwärts' 
bzw. 'Rückwärts' Tasten können im Fall des Falles natürlich auch einen 
Wert erhöhen bzw. erniedrigen, oder eine Option nach der anderen 
durchschalten, aber zumindest die Bestätigungstaste ist immer dieselbe. 
Egal ob damit der aktuell angezeigte Menüpunkt bestätigt wird, oder ob 
damit eine Zahleneingabe bestätigt wird oder die Auswahl einer Farbe aus 
5 Möglichkeiten.
Die Metapher ist dann: Mit den Tasten '<+>' bzw. '<->' verändere ich das 
angezeite. Mit der dritten Taste 'OK' übernehme ich diese Veränderung. 
Was immer dann auch diese 'Übernahme' konkret bedeutet.
Das kann sich jeder merken und das kommt jedem natürlich vor, weil er 
das schon 100-te male bei anderen Geräten genau so gemacht hat.

[Schiri (Gast)]

Danke sehr für die ausführlichen Erläuterungen und Anmerkungen.
Ich werde berichten :)