menu.c

Go to the documentation of this file.

/*********************************************************
* Function: menu system
*
* File: menu.c
* Author: Book Chen
* Date 2009.07.06
***********************************************************
*/
#include "includes.h"

#define MenuIdleState     0
#define MenuInitial0State 1
#define MenuInitial1State 2
#define MenuInitial2State 3
#define MenuInitial3State 4
#define MenuNoMenuState   5
#define MenuRunMenuState  6

MENU_CONTROL MenuCtrl;

void MenuInit(void){
    MenuCtrl.pCurMenu=(const MENU_ENTRY *)0;
    MenuCtrl.pCurItem=(const ITEM_ENTRY *)0;
    MenuCtrl.HasKey=FALSE;
    MenuCtrl.Timer=0;
    MenuCtrl.State=MenuInitial0State;
    //MenuCtrl.State=MenuIdleState;
}

void MenuSvc(void){
    switch(MenuCtrl.State){
        case MenuIdleState:
            break;
        case MenuInitial0State:
            if(LcmStateGet()!=0) break;
            if(LcmUpdate(LcmInitialCommand0,LCM_COMMAND)==IS_ERROR){ 
                MenuCtrl.State=MenuIdleState;
                break;
            }
            MenuCtrl.State=MenuInitial1State;
            break;
        case MenuInitial1State:
            if(LcmStateGet()!=0) break;
            //if(LcmUpdate(MenuString0,LCM_DATA)==IS_ERROR) break;
            MenuReset();
            MenuCtrl.State=MenuInitial2State;
            break;
        case MenuInitial2State:
            //if(LcmStateGet()!=0) break;
            MenuCtrl.State=MenuInitial3State;
            break;
        case MenuInitial3State:
            MenuCtrl.pCurMenu=&MenuMainMenu;
            MenuCtrl.pCurItem=MenuCtrl.pCurMenu->pItemList;
            MenuMenuInit(MenuCtrl.pCurMenu);
            MenuItemInit(MenuCtrl.pCurItem);
            MenuCtrl.State=MenuRunMenuState;
            break;
        case MenuNoMenuState:            
            break;
        case MenuRunMenuState:
            KeySvc();       // detect key
            if(KeyStatusCheck()==TRUE){
                //i=KeyGet();
                //DebugStringPrint("\r\n key code is : ");          
                //DebugHex2AsciiInt8uPrint(MenuCtrl.KeyValue);
                MenuKeySet(KeyGet());
            }
            if(MenuCtrl.HasKey==FALSE) break;
            MenuCtrl.HasKey=FALSE;  
            MenuOpcodeParser(MenuCtrl.KeyValue);
            break;            
    }
}

void MenuStop(void){
    MenuCtrl.State=MenuIdleState;
}

void MenuStart(void){
    MenuCtrl.State=MenuInitial0State;
}

void MenuReset(void){
    MenuCtrl.pCurMenu=(const MENU_ENTRY *)0;
    MenuCtrl.pCurItem=(const ITEM_ENTRY *)0;
    MenuCtrl.HasKey=FALSE;
    MenuCtrl.Timer=0;
}

void MenuKeySet(INT8U KeyValue){
    if(MenuCtrl.HasKey==FALSE){
        MenuCtrl.KeyValue=KeyValue;
        MenuCtrl.HasKey=TRUE;
    }
}

void MenuMenuInit(const struct _MENU_ENTRY_ *pMenu){
    LcmUpdate(Lcm1stLineStart,LCM_COMMAND);
    LcmUpdate((INT8U *)MenuMessage[pMenu->MsgIndex],LCM_DATA);
}

void MenuItemInit(const struct _ITEM_ENTRY_ *pItem){
    LcmUpdate(Lcm2ndLineStart,LCM_COMMAND);
    //LcmUpdate(MenuMessage[MENU_MSG_16SPACES],LCM_DATA);
    LcmUpdate(Lcm2ndLineStart,LCM_COMMAND);
    LcmUpdate((INT8U *)MenuMessage[pItem->MsgIndex],LCM_DATA);
}

void MenuItemAct(const struct _ITEM_ENTRY_ *pItem){
    if(pItem->pValue==(const void *)0) return;
    MenuCtrl.pCurMenu=(const struct _MENU_ENTRY_ *)((void *)pItem->pValue);
    MenuCtrl.pCurItem=MenuCtrl.pCurMenu->pItemList;
    MenuMenuInit(MenuCtrl.pCurMenu);
    MenuItemInit(MenuCtrl.pCurItem);
}

void MenuOpcodeParser(INT8U KeyValue){
    if(KeyValue==KEY_UP){
        if(MenuCtrl.pCurItem->pUpItem==(const ITEM_ENTRY *)0) return;
        MenuCtrl.pCurItem=MenuCtrl.pCurItem->pUpItem;
        MenuItemInit(MenuCtrl.pCurItem);
    }
    else if(KeyValue==KEY_DOWN){
        if(MenuCtrl.pCurItem->pDownItem==(const ITEM_ENTRY *)0) return;
        MenuCtrl.pCurItem=MenuCtrl.pCurItem->pDownItem;
        MenuItemInit(MenuCtrl.pCurItem);
    }
    else if(KeyValue==KEY_LEFT){
        if(MenuCtrl.pCurMenu->pPrevMenu==(const struct _MENU_ENTRY_ *)0) return;
        MenuCtrl.pCurMenu=MenuCtrl.pCurMenu->pPrevMenu;
        MenuCtrl.pCurItem=MenuCtrl.pCurMenu->pItemList;
        MenuMenuInit(MenuCtrl.pCurMenu);
        MenuItemInit(MenuCtrl.pCurItem);
    }
    else if(KeyValue==KEY_RIGHT){
        if(MenuCtrl.pCurItem->pValue==(const void *)0) return;
        MenuCtrl.pCurMenu=(const struct _MENU_ENTRY_ *)MenuCtrl.pCurItem->pValue;
        MenuCtrl.pCurItem=MenuCtrl.pCurMenu->pItemList;
        MenuMenuInit(MenuCtrl.pCurMenu);
        MenuItemInit(MenuCtrl.pCurItem);
    }
    else if(KeyValue==KEY_ENTER){                
        MenuItemAct(MenuCtrl.pCurItem);
    }
}
/*****************
 main menu functions
******************/
const ITEM_ENTRY MenuMainmenuItem[MENU_MAINMENU_ITEM_MAX]={
    { // item 0: 
     MenuItemInit,
     MenuItemAct,
     (const ITEM_ENTRY *)0,      // up    item
     &MenuMainmenuItem[1], // dowm  item
     (const void *)&MenuSytemSubmenu,            // next menu
     MENU_MSG_SYSTEM,
    },
    { // item 1:
     MenuItemInit,
     MenuItemAct,
     &MenuMainmenuItem[0], // up    item
     &MenuMainmenuItem[2], // dowm  item
     (const void *)&MenuVideoEncoderSubmenu,            // next menu
     MENU_MSG_VIDEO_ENCODER,
    },
    { // item 2: 
     MenuItemInit,
     MenuItemAct,
     &MenuMainmenuItem[1], // up    item
     &MenuMainmenuItem[3], // dowm  item
     (const void *)&MenuAudioEncoderSubmenu,            // next menu
     MENU_MSG_AUDIO_ENCODER,
    },
    { // item 3:
     MenuItemInit,
     MenuItemAct,
     &MenuMainmenuItem[2], // up    item
     &MenuMainmenuItem[4], // dowm  item
     (const void *)&MenuCodecSubmenu,            // next menu
     MENU_MSG_HARDWARE_CODEC,
    },
    { // item 4:
     MenuItemInit,
     MenuItemAct,
     &MenuMainmenuItem[3], // up    item
     (const ITEM_ENTRY *)0,            // dowm  item
     (const void *)&MenuMuxSubmenu,            // next menu
     MENU_MUX_SETTING,
    },
};

const MENU_ENTRY MenuMainMenu={
    (ITEM_ENTRY *)MenuMainmenuItem,
    (MENU_ENTRY *)0,           // previous menu
    MenuMenuInit,         
    MenuOpcodeParser,
    MENU_MAINMENU_ITEM_MAX,    // total item number
    MENU_MSG_1ST_LAYER,        //
};

/*****************
submenu functions
******************/
const ITEM_ENTRY MenuSystemmenuItem[MENU_SYSTEMMENU_ITEM_MAX]={
    { // item 0: 
     MenuItemInit,
     MenuItemAct,
     (const ITEM_ENTRY *)0,      // up    item
     &MenuSystemmenuItem[1], // dowm  item
     (const void *)0,            // next menu
     MENU_MSG_SYSTEM_ITEM0,
    },
    { // item 1:
     MenuItemInit,
     MenuItemAct,
     &MenuSystemmenuItem[0], // up    item
     &MenuSystemmenuItem[2], // dowm  item
     (const void *)0,            // next menu
     MENU_MSG_SYSTEM_ITEM1,
    },
    { // item 2: 
     MenuItemInit,
     MenuItemAct,
     &MenuSystemmenuItem[1], // up    item
     &MenuSystemmenuItem[3], // dowm  item
     (const void *)0,            // next menu
     MENU_MSG_SYSTEM_ITEM2,
    },
    { // item 3: 
     MenuItemInit,
     MenuItemAct,
     &MenuSystemmenuItem[2], // up    item
     &MenuSystemmenuItem[4], // dowm  item
     (const void *)0,            // next menu
     MENU_MSG_SYSTEM_ITEM3,
    },
    { // item 4: 
     MenuItemInit,
     MenuItemAct,
     &MenuSystemmenuItem[3], // up    item
     (const ITEM_ENTRY *)0,            // dowm  item
     (const void *)0,            // next menu
     MENU_MSG_SYSTEM_ITEM4,
    },
};

const MENU_ENTRY MenuSytemSubmenu={
    (const ITEM_ENTRY *)MenuSystemmenuItem,
    (const MENU_ENTRY *)&MenuMainMenu,           // previous menu
    MenuMenuInit,         
    MenuOpcodeParser,
    MENU_SYSTEMMENU_ITEM_MAX,  // total item number
    MENU_MSG_SYSTEM,        //
};

/*****************
submenu functions
******************/
const ITEM_ENTRY MenuVideoEncoderMenuItem[MENU_VIDEOMENU_ITEM_MAX]={
    { // item 0: 
     MenuItemInit,
     MenuItemAct,
     (const ITEM_ENTRY *)0,        // up    item
     &MenuVideoEncoderMenuItem[1], // dowm  item
     (const void *)0,              // next menu
     MENU_MSG_VIDEO_ENCODER_ITEM0,
    },
    { // item 1: 
     MenuItemInit,
     MenuItemAct,
     &MenuVideoEncoderMenuItem[0], // up    item
     &MenuVideoEncoderMenuItem[2], // dowm  item
     (const void *)0,            // next menu
     MENU_MSG_VIDEO_ENCODER_ITEM1,
    },
    { // item 2: 
     MenuItemInit,
     MenuItemAct,
     &MenuVideoEncoderMenuItem[1], // up    item
     &MenuVideoEncoderMenuItem[3], // dowm  item
     (const void *)0,            // next menu
     MENU_MSG_VIDEO_ENCODER_ITEM2,
    },
    { // item 3: 
     MenuItemInit,
     MenuItemAct,
     &MenuVideoEncoderMenuItem[2], // up    item
     &MenuVideoEncoderMenuItem[4], // dowm  item
     (const void *)0,            // next menu
     MENU_MSG_VIDEO_ENCODER_ITEM3,
    },
    { // item 4: 
     MenuItemInit,
     MenuItemAct,
     &MenuVideoEncoderMenuItem[3], // up    item
     (const ITEM_ENTRY *)0,            // dowm  item
     (const void *)0,            // next menu
     MENU_MSG_VIDEO_ENCODER_ITEM4,
    },
};

const MENU_ENTRY MenuVideoEncoderSubmenu={
    (const ITEM_ENTRY *)MenuVideoEncoderMenuItem,
    (const MENU_ENTRY *)&MenuMainMenu, // previous menu
    MenuMenuInit,         
    MenuOpcodeParser,
    MENU_VIDEOMENU_ITEM_MAX,   // total item number
    MENU_MSG_VIDEO_ENCODER,        //
};

/*****************
submenu functions
******************/
const ITEM_ENTRY MenuAudioEncoderMenuItem[MENU_AUDIOMENU_ITEM_MAX]={
    { // item 0: 
     MenuItemInit,
     MenuItemAct,
     (const ITEM_ENTRY *)0,        // up    item
     &MenuAudioEncoderMenuItem[1], // dowm  item
     (const void *)0,              // next menu
     MENU_MSG_AUDIO_ENCODER_ITEM0,
    },
    { // item 1:
     MenuItemInit,
     MenuItemAct,
     &MenuAudioEncoderMenuItem[0], // up    item
     &MenuAudioEncoderMenuItem[2], // dowm  item
     (const void *)0,            // next menu
     MENU_MSG_AUDIO_ENCODER_ITEM1,
    },
    { // item 2: 
     MenuItemInit,
     MenuItemAct,
     &MenuAudioEncoderMenuItem[1], // up    item
     &MenuAudioEncoderMenuItem[3], // dowm  item
     (const void *)0,            // next menu
     MENU_MSG_AUDIO_ENCODER_ITEM2,
    },
    { // item 3: 
     MenuItemInit,
     MenuItemAct,
     &MenuAudioEncoderMenuItem[2], // up    item
     &MenuAudioEncoderMenuItem[4], // dowm  item
     (const void *)0,            // next menu
     MENU_MSG_AUDIO_ENCODER_ITEM3,
    },
    { // item 4: 
     MenuItemInit,
     MenuItemAct,
     &MenuAudioEncoderMenuItem[3], // up    item
     (const ITEM_ENTRY *)0,            // dowm  item
     (const void *)0,            // next menu
     MENU_MSG_AUDIO_ENCODER_ITEM4,
    },
};

const MENU_ENTRY MenuAudioEncoderSubmenu={
    (const ITEM_ENTRY *)MenuAudioEncoderMenuItem,
    (const MENU_ENTRY *)&MenuMainMenu, // previous menu
    MenuMenuInit,         
    MenuOpcodeParser,
    MENU_AUDIOMENU_ITEM_MAX,   // total item number
    MENU_MSG_AUDIO_ENCODER,        //
};

/*****************
submenu functions
******************/
const ITEM_ENTRY MenuCodecMenuItem[MENU_CODECMENU_ITEM_MAX]={
    { // item 0:
     MenuItemInit,
     MenuItemAct,
     (const ITEM_ENTRY *)0,        // up    item
     &MenuCodecMenuItem[1], // dowm  item
     (const void *)0,              // next menu
     MENU_MSG_HARDWARE_CODEC_ITEM0,
    },
    { // item 1: 
     MenuItemInit,
     MenuItemAct,
     &MenuCodecMenuItem[0], // up    item
     &MenuCodecMenuItem[2], // dowm  item
     (const void *)0,            // next menu
     MENU_MSG_HARDWARE_CODEC_ITEM1,
    },
    { // item 2: 
     MenuItemInit,
     MenuItemAct,
     &MenuCodecMenuItem[1], // up    item
     &MenuCodecMenuItem[3], // dowm  item
     (const void *)0,            // next menu
     MENU_MSG_HARDWARE_CODEC_ITEM2,
    },
    { // item 3: 
     MenuItemInit,
     MenuItemAct,
     &MenuCodecMenuItem[2], // up    item
     &MenuCodecMenuItem[4], // dowm  item
     (const void *)0,            // next menu
     MENU_MSG_HARDWARE_CODEC_ITEM3,
    },
    { // item 4: 
     MenuItemInit,
     MenuItemAct,
     &MenuCodecMenuItem[3], // up    item
     (const ITEM_ENTRY *)0,            // dowm  item
     (const void *)0,            // next menu
     MENU_MSG_HARDWARE_CODEC_ITEM4,
    },
};

const MENU_ENTRY MenuCodecSubmenu={
    (const ITEM_ENTRY *)MenuCodecMenuItem,
    (const MENU_ENTRY *)&MenuMainMenu, // previous menu
    MenuMenuInit,         
    MenuOpcodeParser,
    MENU_CODECMENU_ITEM_MAX,   // total item number
    MENU_MSG_HARDWARE_CODEC,        //
};

/*****************
submenu functions
******************/
const ITEM_ENTRY MenuMuxMenuItem[MENU_MUXMENU_ITEM_MAX]={
    { // item 0:
     MenuItemInit,
     MenuItemAct,
     (const ITEM_ENTRY *)0,        // up    item
     &MenuMuxMenuItem[1], // dowm  item
     (const void *)0,              // next menu
     MENU_MUX_SETTING_ITEM0,
    },
    { // item 1: 
     MenuItemInit,
     MenuItemAct,
     &MenuMuxMenuItem[0], // up    item
     &MenuMuxMenuItem[2], // dowm  item
     (const void *)0,            // next menu
     MENU_MUX_SETTING_ITEM1,
    },
    { // item 2:
     MenuItemInit,
     MenuItemAct,
     &MenuMuxMenuItem[1], // up    item
     &MenuMuxMenuItem[3], // dowm  item
     (const void *)0,            // next menu
     MENU_MUX_SETTING_ITEM2,
    },
    { // item 3: 
     MenuItemInit,
     MenuItemAct,
     &MenuMuxMenuItem[2], // up    item
     &MenuMuxMenuItem[4], // dowm  item
     (const void *)0,            // next menu
     MENU_MUX_SETTING_ITEM3,
    },
    { // item 4: 
     MenuItemInit,
     MenuItemAct,
     &MenuMuxMenuItem[3], // up    item
     (const ITEM_ENTRY  *)0,            // dowm  item
     (const void *)0,            // next menu
     MENU_MUX_SETTING_ITEM4,
    },
};

const MENU_ENTRY MenuMuxSubmenu={
    (const ITEM_ENTRY *)MenuMuxMenuItem,
    (const MENU_ENTRY *)&MenuMainMenu, // previous menu
    MenuMenuInit,         
    MenuOpcodeParser,
    MENU_MUXMENU_ITEM_MAX,   // total item number
    MENU_MUX_SETTING,        //
};

//*****************
// menu strings
//*****************
const INT8U MsgLineChange[]="\n\r";
const INT8U MenuMsg00[]="                "; // 16 spaces
const INT8U MenuMsg01[]="main menu       "; // submenu 
const INT8U MenuMsg02[]="sub  menu       "; // submenu 
const INT8U MenuMsg03[]="item menu       "; // submenu 
const INT8U MenuMsg04[]="MAINMENU ITEM 0 "; // submenu 
const INT8U MenuMsg05[]="MAINMENU ITEM 1 "; // submenu 
const INT8U MenuMsg06[]="MAINMENU ITEM 2 "; // submenu 
const INT8U MenuMsg07[]="MAINMENU ITEM 3 "; // submenu 
const INT8U MenuMsg08[]="MAINMENU ITEM 4 "; // submenu
const INT8U MenuMsg09[]="ITEM0 SUBITEM 0 "; // submenu item 
const INT8U MenuMsg10[]="ITEM0 SUBITEM 1 "; // submenu item
const INT8U MenuMsg11[]="ITEM0 SUBITEM 2 "; // submenu item
const INT8U MenuMsg12[]="ITEM0 SUBITEM 3 "; // submenu item
const INT8U MenuMsg13[]="ITEM0 SUBITEM 4 "; // submenu item
const INT8U MenuMsg14[]="ITEM1 SUBITEM 0 "; // submenu item
const INT8U MenuMsg15[]="ITEM1 SUBITEM 1 "; // submenu item
const INT8U MenuMsg16[]="ITEM1 SUBITEM 2 "; // submenu item
const INT8U MenuMsg17[]="ITEM1 SUBITEM 3 "; // submenu item
const INT8U MenuMsg18[]="ITEM1 SUBITEM 4 "; // submenu item
const INT8U MenuMsg19[]="ITEM2 SUBITEM 0 "; // submenu item
const INT8U MenuMsg20[]="ITEM2 SUBITEM 1 "; // submenu item
const INT8U MenuMsg21[]="ITEM2 SUBITEM 2 "; // submenu item
const INT8U MenuMsg22[]="ITEM2 SUBITEM 3 "; // submenu item
const INT8U MenuMsg23[]="ITEM2 SUBITEM 4 "; // submenu item
const INT8U MenuMsg24[]="ITEM3 SUBITEM 0 "; // submenu item
const INT8U MenuMsg25[]="ITEM3 SUBITEM 1 "; // submenu item
const INT8U MenuMsg26[]="ITEM3 SUBITEM 2 "; // submenu item
const INT8U MenuMsg27[]="ITEM3 SUBITEM 3 "; // submenu item
const INT8U MenuMsg28[]="ITEM3 SUBITEM 4 "; // submenu item
const INT8U MenuMsg29[]="ITEM4 SUBITEM 0 "; // submenu item
const INT8U MenuMsg30[]="ITEM4 SUBITEM 1 "; // submenu item
const INT8U MenuMsg31[]="ITEM4 SUBITEM 2 "; // submenu item
const INT8U MenuMsg32[]="ITEM4 SUBITEM 3 "; // submenu item
const INT8U MenuMsg33[]="ITEM4 SUBITEM 4 "; // submenu item
const INT8U MenuMsg34[]="SYSTEM POWER ON "; // system power on
const INT8U MenuMsg35[]="PLEASE WAIT...  "; // please wait
const INT8U MenuMsg36[]="PPPP CONNECTED  "; // system power on
const INT8U MenuMsg37[]="ON PPPP BOOTUP  "; // sdcp bootup message
const INT8U MenuMsg38[]="PPPP BOOTUP OK  "; // sdcp boot ok message

const INT8U *MenuMessage[39]={
MenuMsg00,
MenuMsg01,
MenuMsg02,
MenuMsg03,
MenuMsg04,
MenuMsg05,
MenuMsg06,
MenuMsg07,
MenuMsg08,
MenuMsg09,
MenuMsg10,
MenuMsg11,
MenuMsg12,
MenuMsg13,
MenuMsg14,
MenuMsg15,
MenuMsg16,
MenuMsg17,
MenuMsg18,
MenuMsg19,
MenuMsg20,
MenuMsg21,
MenuMsg22,
MenuMsg23,
MenuMsg24,
MenuMsg25,
MenuMsg26,
MenuMsg27,
MenuMsg28,
MenuMsg29,
MenuMsg30,
MenuMsg31,
MenuMsg32,
MenuMsg33,
MenuMsg34,
MenuMsg35,
MenuMsg36,
MenuMsg37,
MenuMsg38
};

---