Ein Menü für LCD Textdisplays hier Nokia3310

[Ralf W. (Gast)]

Hallo,

vor einigen Jahren wollte ich eine Heizungsteuerung bauen, da die alte 
defekt war.Leider ist sie nie ganz fertig geworden und mittlerweile auch 
obsolet, da ich einen neuen Kessel habe.

Warum ich das hier trotzdem poste?
Weil ich hier im Forum viel gelernt habe und andere vielleicht von dem 
implementierten Menü lernen können und weils Spaß macht und weil ich 
auch einiges an Code geborgt habe.

Im Anhang der komplette Quellcode und ein Foto der Hardware auf dem ich 
ihn entwickelt habe. Das war nicht die endgültige Hardware, sondern 
wurde von einem anderen Projekt geborgt. Es ging mir ja erstmal ums Menü 
und die Schaltpunkte.

So los gehts:

Als erstes mal die Menüs deklarieren, bei mir in der main.c:

t_Menu SettingsMenu={
    .Text = "Settings", //der Name des Menüs
    .menu_id = 1,    //eine eindeutige ID
    .Previous = NULL,  //wird von der Menüroutine gebraucht und sollte NULL bleiben
    .Count = 2,      //die Anzahl der Menuitems
    .MenuItems = {
        {
        .Text = "BackLight", //der Name des Items
        .item_id = 15,     //eine eindeutige ID
        },
        {
        .Text = "Set Time",
        .item_id = 14,
        },
    },
};

t_Menu EditSwitchpoints ={
    .Text = "Edit Switp",
    .menu_id = 2,
    .Previous = NULL,
    .Count = SWITCHPOINTS_COUNT,
    .ItemType = 1      //ein Spezialmenü
};

t_Menu MainMenu ={
    .Text = "Hauptmenue",
    .menu_id = 0,
    .Previous = NULL,
    .Count = 3,
    .MenuItems = {
        {
        .Text = "@Settings", //hier habe ich einen Trick verwendet, um nicht alle Menüs geschachtelt aufschreiben zu müssen
               //zeigt das @ an das dies ein Untermenü ist. Der Code findet das Untermenü anhand vom Namen
               //selbst.
        .item_id = 16,     //wieder eine eindeutige ID
        },
        {
        .Text = "@Edit Switp",
        .item_id = 19,
        },
        {
        .Text = "Fertig",
        .item_id = 20,
        },
    },
};

t_Menu *Menus[] = {    //ein Array von Menüs, wie gesagt die Untermenüs werden durch das @ selbständig gefunden
    &MainMenu,
    &SettingsMenu,
    &EditSwitchpoints,
};


uint8_t MenuCount = 3; //wieviele Menüs sind im Array

t_ActiveApplication ActiveApplication = &MenuApplication; // dem von mir erfundenen Menü die Kontrolle übergeben

Ein Wort zu den Applikationen. Ich habe alle Menuitems als Apps 
definiert. Das heißt eine App hat die Kontrolle
über das Display und den Controller. Wenn zB. "Backlight" aufgerufen 
wird, wird die backlightapp aktiv und zeigt
hier ihre Ausgaben auf dem Display. Auf dem Foto im Anhang sieht man zB. 
die Ausgaben der idleapp.

So weiter geht es. MySelect wird gebraucht um auf die Menüitems 
reagieren zu können und somit die entsprechenden
Apps zu aktivieren.

void MySelect(uint8_t MenuId, uint8_t action, uint8_t ItemType){ 
    switch(ItemType){
        case MENU_ITEMTYPE_BUILDIN:{
            switch( MenuId){
                case 14:{
                    Clear();
                    SetDateTimeToChange(RealTime_GetDateTime());
                    ActiveApplication = &SetTimeApp;
                    ActiveApplication(NO_KEY);
                }
                break;
                case 15:{
                    //Beep();
                    Clear();
                    PrintStringPos(0,0,"BackLight");
                    Highlight(1);
                    PrintStringPos(1,1,"Value:");
                    //setBackLightPWMValue(&BackLightPWM);
                    ActiveApplication = &BackLightApplication;
                    ActiveApplication(NO_KEY);
                }
                break;
                case 20:{
                    idle = 1;
                }
                break;
                default:
                break;
            }
        }
        break;
        case 1:{//my special menu type for eeprom array
            if(action == MENU_ACTION_SELECT_SPECIALITEM){
                switch(MenuId){
                    case 2:{
                        Clear();
                        ActiveApplication = &EditSwitchpointApp;
                        ActiveApplication(NO_KEY);
                    }
                    break;
                    default:
                    break;
                }
            }
        }
        break;
    }
}

Jetzt noch die main Routine:

int main(void){
  SetPorts();
  InitTimer1_Timebase();
    InitKeys();
  lcd_init();
  lcd_contrast(0x40);
    InitBackLight();
  //InitUart();

  EnterMenu(&MainMenu, &MySelect); // dies muß einmal aufgerufen werden, um das Menü zu initialisieren
                    // irgendwie muß das Menü ja wissen was es anzeigen soll und welche
                    // Aktion ausgeführt werden soll, wenn ein Menüitem ausgewählt wird.
  sei();
  for(;;){
       if (onesecondover){
            onesecondover = 0;
            ActiveApplication(TICK);  //der aktiven ActiveApplication die Ereignisse wie Tastendrücke
                    //oder Timerevents mitteilen
        }
        if (get_key_short((1<<DOWN))){// get_key_short ist ein Teil von Peter Dannegger Tastenabfrage
                     // die ich aber nicht komplett verwendet habe.
            idle = 0;
            ActiveApplication(DOWN);  
        }
        if (get_key_short((1<<LEFT))){
            idle = 0;
            ActiveApplication(LEFT);
        }
        if (get_key_short((1<<RIGHT))){
            idle = 0;
            ActiveApplication(RIGHT);
        }
        if (get_key_short((1<<OK))){
            idle = 0;
            ActiveApplication(OK);
        }
        if (get_key_short((1<<UP))){
            idle = 0;
            ActiveApplication(UP);
        }
        if(oneminuteover){
            oneminuteover = 0;
            if(ActiveApplication != EditSwitchpointApp){ //nicht aufrufen wenn Schaltpunkte editiert werden
                IdleApplication(ONE_MINUTE_TICK);
            }
        }
        if(idle){
            idle = 0;
//            if(ActiveApplication == MenuApplication){//nur im Menü Idle
//                //display Schaltzustand
                IdleApplication(NO_KEY);
//            }
        }
   }

Hier jetzt der menu.h in dem die Menüs und die wichtigsten Routinen 
dafür definiert werden.

#define TextLenght DisplayColumns -2  //maximum lenght of entry.
                    //DisplayColumns ist die Anzahl der Spalten, die das Display hat

#define MENU_ITEMTYPE_BUILDIN 0

#define MENU_ACTION_CHANGE_MENU 0
#define MENU_ACTION_SELECT_BUILDINITEM 1
#define MENU_ACTION_SELECT_SPECIALITEM 2

/*                  menu_id or item_id,   action, ItemType*/
typedef void (*t_UserSelect)(uint8_t, uint8_t, uint8_t); //die Definition der UserSelect Routione, die aufgerufen
                              //wird, wenn ein Menüitem selektiert wird, welches eine App
                              //ist

extern char* getItemText(uint8_t ItemType, uint8_t index);//im Moment habe ich keinen Plan wozu das hier dient

uint8_t menu_getCurrentItemId(void);//im Moment habe ich keinen Plan wozu das hier dient


struct s_item;
struct s_menu;


typedef struct s_item
  {
    char Text[TextLenght];  //entry title
        uint8_t item_id;
  } t_MenuItem;




typedef struct s_menu
  {
    char Text[TextLenght];  //menu title
    struct s_menu *Previous;  //pointer to previous menu (backtracking)
        uint8_t Count;
        uint8_t ItemType;
        uint8_t menu_id;
    t_MenuItem MenuItems[];  //entrys
  } t_Menu;

extern uint8_t MenuCount;
extern t_Menu *Menus[];

/* called only once from user code, set's the first menu and the Select function*/
void EnterMenu( t_Menu *newMenu, t_UserSelect UserSelect);

/* makes the previous item the current item*/
void PreviousItem();

/* makes the next item the current item*/
void NextItem();

/* exit's the current menu, and makes the menu in Previous the current menu*/
void ExitMenu();

/* executes the items select function or enters a submenu*/
void SelectItem();

/* call this after UserSelect */
void ExitItem();

Hier jetzt die MenuApplication. Die ist recht aufgeräumt. Oder?

void MenuApplication(uint8_t Button){
    switch( Button){
     case UP:
        PreviousItem();
        break;
     case DOWN:
        NextItem();
        break;
     case LEFT:
        ExitMenu();
        break;
     case RIGHT:
     case OK:
        SelectItem();
     case TICK:
        break;
    }
}

Und hier mal die BacklightApplication.

void BackLightApplication(uint8_t Button){
    switch (Button){
     case TICK: return;
     case OK:
         ActiveApplication = &MenuApplication;
         ExitItem();
         return;
     case UP:
        rangedInc_uint8_t((t_ranged_uint8_t *)&BackLightPWM);//t_ranged_uint8_t ist ein von mir erfundener Typ, den 
                                //erkläre ich gleich.
        break;
     case DOWN:
        rangedDec_uint8_t((t_ranged_uint8_t *)&BackLightPWM);
        break;
     case RIGHT:
        break;
    }
    char buffer[3];
    utoa( BackLightPWM.value, buffer, 10);
    PrintStringPos(7,1,"    ");
    PrintStringPos(7,1,buffer);
}

t_ranged_uint8_t habe ich dafür erfunden, um Zahlen zu inkremenitieren 
und dekrementieren, die eine Ober und Untergrenze
haben. Um nicht bei jeder Verwendung dieser Zahl mit if Bedingungen 
darauf prüfen zu müssen, habe ich das halt ausgelagert.
Zum Beispiel wird BackLightPWM so deklariert:

#define BackLightPWMStart 16
t_ranged_uint8_t volatile BackLightPWM = {
    .value = BackLightPWMStart,
    .top = BackLightPWMStart,
    .bottom = 0
};

Das BackLightPWM.value ist 16. BackLightPWM.top ist ebenfalls 16. Beim 
incrementiern muß nach der 16 also
BackLightPWM.bottom kommen. Hier ist BackLightPWM.bottom 0.

ranged.h

#ifndef RANGED_H_INCLUDED
#define RANGED_H_INCLUDED

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

typedef struct{
    uint8_t value;
    uint8_t top;
    uint8_t bottom;
}t_ranged_uint8_t;

void rangedInc_uint8_t(t_ranged_uint8_t *value);
void rangedDec_uint8_t(t_ranged_uint8_t *value);

#endif // RANGED_H_INCLUDED

ranged.c

#include "ranged.h"

void rangedInc_uint8_t(t_ranged_uint8_t *value){
    if(value->value == value->top){
        value->value = value->bottom;
    }
    else{
        value->value +=1;
    }
}


void rangedDec_uint8_t(t_ranged_uint8_t *value){
    if(value->value == value->bottom){
        value->value = value->top;
    }
    else{
        value->value -=1;
    }
}

So erstmal genug geschrieben. Wer Fragen hat gerne Fragen und 
diskutieren. Den mir ist klar,
das hier ist nicht der Weisheit letzter Schluß.

gruß ralf

[Ralf W. (Gast)]

Sorry Leute, ich habe gar nicht gesehen wie groß das Archiv mit dem 
Quellcode ist. Deshalb hier noch mal kleiner.

Ich hatte das Datenblatt vom Atmega 88 noch mit im Archiv.

[Ralf W. (Firma: HEB industrie elektronik) (ralf_werner)]

Hallo,

wollte nur für später darauf hinweisen, das es jetzt einen Artikel
für das Menüsystem gibt.

https://www.mikrocontroller.net/articles/YaMen%C3%BC



Ich hoffe ihr habt Spaß.