标题: LPC2214主控ucos ii下液晶菜单的设计 [打印本页]
作者: 51hei学习技术中    时间: 2017-3-13 02:28
标题: LPC2214主控ucos ii下液晶菜单的设计
主控芯片采用的是LPC2214单片机.

公司里的废弃电路板比较多就是拿回来自己折腾玩了，

以前大学的时候用51做过数字万年历，但是51那可怜的资源真是设计起来麻烦的要死，现在在ARM7
上搞，简直很随意了。



其实原理也很简单没啥技术含量，纯属娱乐，就当做对ucos ii的学习了。

  1. #include "Menu.h"
  2. //Common
  3. //extern const stStateInfo NormalClock;
  4. const stMenuList *pMenuListEntry = NULL;

  6. //Home

  8. const char clockStr[] = {
  9.         MENU_ZH_CODE_START, 43,
  10.         MENU_ZH_CODE_START,        44,
  11. };
  12. static const stHomeIcon clockIcon = {
  13.         BMP_ICON_ID_CLOCK,
  14.         {clockStr, sizeof(clockStr)},
  15.         &NormalClock,
  16.         0x00000000,
  17. };
  18. const char calendarStr[] = {
  19.         MENU_ZH_CODE_START, 0,
  20.         MENU_ZH_CODE_START, 45,
  21. };
  22. static const stHomeIcon calendarIcon = {
  23.         BMP_ICON_ID_CALENDAR,
  24.         {calendarStr, sizeof(calendarStr)},
  25.         &NormalClock,
  26.         0x00000000,
  27. };
  28. const char gameStr[] = {
  29.         MENU_ZH_CODE_START, 46,
  30.         MENU_ZH_CODE_START, 47,
  31. };
  32. static const stHomeIcon gameIcon = {
  33.         BMP_ICON_ID_GAME,
  34.         {gameStr, sizeof(gameStr)},
  35.         &NormalClock,
  36.         0x00000000,
  37. };
  38. const char settingStr[] = {
  39.         MENU_ZH_CODE_START, 48,
  40.         MENU_ZH_CODE_START, 49,
  41. };
  42. static const stHomeIcon settingIcon = {
  43.         BMP_ICON_ID_SETTING,
  44.         {settingStr, sizeof(settingStr)},
  45.         &Menu,
  46.         (INT32U)&MenuSetList,
  47. };
  48. const char systemStr[] = {
  49.         MENU_ZH_CODE_START, 50,
  50.         MENU_ZH_CODE_START, 51,
  51. };
  52. static const stHomeIcon systemIcon = {
  53.         BMP_ICON_ID_SYSTEM,
  54.         {systemStr, sizeof(systemStr)},
  55.         &NormalClock,
  56.         0x00000000,
  57. };

  59. const stHomeIcon *HomeIcon[] = {
  60.         &clockIcon,
  61.     &calendarIcon,
  62.         &gameIcon,
  63.         &settingIcon,
  64.         &systemIcon,
  65. };

  67. const INT8U HomeIconTotalNum = sizeof(HomeIcon) / sizeof(stHomeIcon *);
  68. //Set menu
  69. static INT8U menuSetInputData[2] = {1, 1};
  70. #define MENU_SET_ITEM_ID                        0u

  72. #define MENU_SET_TIME_ITEM_ID                MENU_SET_ITEM_ID + 0u
  73. static const char menuSetTimeStr[] = {
  74.         MENU_ZH_CODE_START, 43,
  75.         MENU_ZH_CODE_START, 56,
  76.         MENU_ZH_CODE_START, 48,
  77.         MENU_ZH_CODE_START, 49
  78. };
  79. const stMenuItem MenuSetTime = {
  80.         0u,
  81.         MENU_SET_TIME_ITEM_ID,
  82.         {menuSetTimeStr, sizeof(menuSetTimeStr)},
  83.         &NormalClock,
  84. };

  86. #define MENU_SET_DATE_ITEM_ID                MENU_SET_TIME_ITEM_ID + 1u
  87. static const char menuSetDateStr[] = {
  88.         MENU_ZH_CODE_START, 0,
  89.         MENU_ZH_CODE_START, 13,
  90.         MENU_ZH_CODE_START, 48,
  91.         MENU_ZH_CODE_START, 49
  92. };
  93. const stMenuItem MenuSetDate = {
  94.         0u,
  95.         MENU_SET_DATE_ITEM_ID,
  96.         {menuSetDateStr, sizeof(menuSetDateStr)},
  97.         &SetDate,
  98. };

  100. #define MENU_SYSTEM_SET_ITEM_ID                MENU_SET_DATE_ITEM_ID + 1u
  101. static const char menuSystemSetStr[] = {
  102.         MENU_ZH_CODE_START, 50,
  103.         MENU_ZH_CODE_START, 51,
  104.         MENU_ZH_CODE_START, 48,
  105.         MENU_ZH_CODE_START, 49
  106. };
  107. const stMenuItem MenuSystemSet = {
  108.         3u,
  109.         MENU_SYSTEM_SET_ITEM_ID,
  110.         {menuSystemSetStr, sizeof(menuSystemSetStr)},
  111.         &MenuSystemSetList,
  112. };

  114. const stMenuItem *menuSetListGroup[] = {
  115.         &MenuSetTime,
  116.         &MenuSetDate,
  117.         &MenuSystemSet,
  118. };
  119. const stMenuList MenuSetList = {
  120.         sizeof(menuSetListGroup) / sizeof(stMenuItem *),
  121.         menuSetInputData,
  122.         &settingIcon.str,
  123.         NULL,
  124.         NULL,
  125.         menuSetListGroup,
  126. };
  127. //System set menu
  128. static INT8U menuSystemSetInputData[2] = {1, 1};
  129. #define MENU_SET_SYSTEM_ID                0u
  130. #define MENU_BACK_LIGHT_TIME_ITEM_ID                MENU_SET_SYSTEM_ID + 0u
  131. static const char menuBackLightTimeStr[] = {
  132.         MENU_ZH_CODE_START, 57,
  133.         MENU_ZH_CODE_START, 58,
  134.         MENU_ZH_CODE_START, 43,
  135.         MENU_ZH_CODE_START, 56
  136. };
  137. const stMenuItem MenuBackLightTime = {
  138.         0u,
  139.         MENU_BACK_LIGHT_TIME_ITEM_ID,
  140.         {menuBackLightTimeStr, sizeof(menuBackLightTimeStr)},
  141.         &NormalClock,
  142. };

  144. #define MENU_MENU_OVERTIME_ITEM_ID                MENU_BACK_LIGHT_TIME_ITEM_ID + 0u
  145. static const char menuOvertimeStr[] = {
  146.         MENU_ZH_CODE_START, 59,
  147.         MENU_ZH_CODE_START, 60,
  148.         MENU_ZH_CODE_START, 61,
  149.         MENU_ZH_CODE_START, 43,
  150.         MENU_ZH_CODE_START, 43,
  151.         MENU_ZH_CODE_START, 56
  152. };
  153. const stMenuItem MenuOvertime = {
  154.         0u,
  155.         MENU_MENU_OVERTIME_ITEM_ID,
  156.         {menuOvertimeStr, sizeof(menuOvertimeStr)},
  157.         &NormalClock,
  158. };

  160. #define MENU_LCD_CONTRAST_ITEM_ID                MENU_MENU_OVERTIME_ITEM_ID + 0u
  161. static const char menuLcdContrastStr[] = {
  162.         'L',
  163.         'C',
  164.         'D',
  165.         MENU_ZH_CODE_START, 64,
  166.         MENU_ZH_CODE_START, 65,
  167.         MENU_ZH_CODE_START, 66
  168. };
  169. const stMenuItem MenuLcdContrast = {
  170.         0u,
  171.         MENU_LCD_CONTRAST_ITEM_ID,
  172.         {menuLcdContrastStr, sizeof(menuLcdContrastStr)},
  173.         &NormalClock,
  174. };

  176. const stMenuItem *menuSystemSetListGroup[] = {
  177.         &MenuBackLightTime,
  178.         &MenuOvertime,
  179.         &MenuLcdContrast,
  180. };
  181. const stMenuList MenuSystemSetList = {
  182.         sizeof(menuSystemSetListGroup) / sizeof(stMenuItem *),
  183.         menuSystemSetInputData,
  184.         &MenuSystemSet.itemName,
  185.         &MenuSystemSet,
  186.         &MenuSetList,
  187.         menuSystemSetListGroup,
  188. };

复制代码


  1. #ifndef MENU_H_
  2. #define MENU_H_
  3. #include "Platform.h"
  4. #include "ucos_ii.h"
  5. #include "State.h"
  6. #define MENU_ZH_CODE_START                        0xA1

  8. #define HOME_ICON_ID_TYPE        INT8U

  10. struct ST_MENU_ITEM;
  11. struct ST_MENU_ITEM_STR;
  12. struct ST_MENU_LIST;

  14. typedef struct ST_MENU_ITEM_STR{
  15.         const char *pstr;
  16.         INT8U len;
  17. }stMenuItemStr;

  19. typedef struct ST_MENU_LIST {
  20.         INT8U itemNum;
  21.         INT8U *pdata;
  22.         const stMenuItemStr *pname;
  23.         const struct ST_MENU_ITEM *pparentItem;
  24.         const struct ST_MENU_LIST *pparentItemList;
  25.         const struct ST_MENU_ITEM **pItem;
  26. }stMenuList;

  28. typedef struct ST_MENU_ITEM {
  29.         INT8U subItemNum;
  30.         INT8U thisItemID;
  31.         stMenuItemStr itemName;
  32.         const void *pData;
  33. }stMenuItem;

  35. typedef struct {
  36.         const HOME_ICON_ID_TYPE iconID;
  37.         const stMenuItemStr str;
  38.         const struct ST_STATE_INFO *pstate;
  39.         INT32U data;
  40. }stHomeIcon;

  42. extern const stMenuList MenuSetList;
  43. extern const stMenuList MenuSystemSetList;
  44. extern const stMenuList *pMenuListEntry;

  46. extern const stHomeIcon *HomeIcon[];
  47. extern const INT8U HomeIconTotalNum;
  48. #endif /* MENU_H_ */
复制代码


  1. #include "State.h"
  2. #include "CalendarCalculated.h"

  4. //NormalClock data
  5. void State_NormalClock(void *ptr);
  6. const stStateInfo NormalClock = {
  7.         0x00000000,
  8.         State_NormalClock,
  9.         NULL,
  10. };
  11. //Home data
  12. void State_Home(void *ptr);
  13. static INT8U homeInputData[2] = {1, 1};
  14. const stStateInfo Home = {
  15.         0x00000000,
  16.         State_Home,
  17.         homeInputData,
  18. };

  20. //Power off data
  21. void State_PowerOff(void *ptr);
  22. static INT32U lastStateAddr = 0;
  23. const stStateInfo PowerOff = {
  24.         0x00000000,
  25.         State_PowerOff,
  26.         &lastStateAddr,
  27. };
  28. //Menu data
  29. void State_Menu(void *ptr);
  30. const stStateInfo Menu = {
  31.         (INT32U)&pMenuListEntry,
  32.         State_Menu,
  33.         NULL,
  34. };
  35. //Set date
  36. void State_SetDate(void *ptr);
  37. const stStateInfo SetDate = {
  38.         (INT32U)&pMenuListEntry,
  39.         State_SetDate,
  40.         (void *)&MenuSetList,
  41. };
  42. //Common data
  43. const stStateInfo *pState = &NormalClock;
  44. static void (*pTimeAction)(void);
  45. OS_EVENT *pStateQ;
  46. static stStateMsg stateMsg[STATE_MSG_SIZE];
  47. void *StateMsg[STATE_MSG_SIZE];
  48. static void __defaultEventProcess(INT8U *pexitFlag, stMSG *pmsg, void *ptr);

  50. //NormalClock
  51. static void __lunarCalendarDisplay(void)
  52. {
  53.         INT8U x = 48;
  54.         switch (lunaCalendarData.month)
  55.         {
  56.                 case 1:
  57.                         LCD_PutZH16x16(x, 4, 17, 1);
  58.                         break;
  59.                 case 2:
  60.                         LCD_PutZH16x16(x, 4, 2, 1);
  61.                         break;
  62.                 case 3:
  63.                         LCD_PutZH16x16(x, 4, 3, 1);
  64.                         break;
  65.                 case 4:
  66.                         LCD_PutZH16x16(x, 4, 4, 1);
  67.                         break;
  68.                 case 5:
  69.                         LCD_PutZH16x16(x, 4, 5, 1);
  70.                         break;
  71.                 case 6:
  72.                         LCD_PutZH16x16(x, 4, 6, 1);
  73.                         break;
  74.                 case 7:
  75.                         LCD_PutZH16x16(x, 4, 7, 1);
  76.                         break;
  77.                 case 8:
  78.                         LCD_PutZH16x16(x, 4, 8, 1);
  79.                         break;
  80.                 case 9:
  81.                         LCD_PutZH16x16(x, 4, 9, 1);
  82.                         break;
  83.                 case 10:
  84.                         LCD_PutZH16x16(x, 4, 10, 1);
  85.                         break;
  86.                 case 11:
  87.                         LCD_PutZH16x16(x, 4, 10, 1);
  88.                         x += 16;
  89.                         LCD_PutZH16x16(x, 4, 1, 1);
  90.                         break;
  91.                 case 12:
  92.                         LCD_PutZH16x16(x, 4, 10, 1);
  93.                         x += 16;
  94.                         LCD_PutZH16x16(x, 4, 2, 1);
  95.                         break;
  96.                 default:
  97.                         break;
  98.         }
  99.         x += 16;
  100.         LCD_PutZH16x16(x, 4, 19, 1);
  101.         if(lunaCalendarData.day < 11)
  102.         {
  103.                 //初
  104.                 x += 16;
  105.                 LCD_PutZH16x16(x, 4, 18, 1);
  106.                 x += 16;
  107.                 LCD_PutZH16x16(x, 4, lunaCalendarData.day, 1);
  108.         }
  109.         else if(lunaCalendarData.day < 20)
  110.         {
  111.                 //十
  112.                 x += 16;
  113.                 LCD_PutZH16x16(x, 4, 10, 1);
  114.                 x += 16;
  115.                 LCD_PutZH16x16(x, 4, lunaCalendarData.day % 10, 1);
  116.         }
  117.         else if(lunaCalendarData.day < 30)
  118.         {
  119.                 //廿
  120.                 x += 16;
  121.                 LCD_PutZH16x16(x, 4, 11, 1);
  122.                 x += 16;
  123.                 if(lunaCalendarData.day % 10)
  124.                         LCD_PutZH16x16(x, 4, lunaCalendarData.day % 10, 1);
  125.                 else
  126.                         LCD_PutZH16x16(x, 4, 10, 1);
  127.         }
  128.         else
  129.         {
  130.                 //三十
  131.                 x += 16;
  132.                 LCD_PutZH16x16(x, 4, 3, 1);
  133.                 x += 16;
  134.                 LCD_PutZH16x16(x, 4, 10, 1);
  135.         }
  136.         x += 16;
  137.         if(x < 128)
  138.         {
  139.                 LCD_PutMiddleString(x, 4, "  ", 1);
  140.         }

  142.         x = 64;
  143.         LCD_PutZH16x16(x, 2, lunaCalendarData.tianGan + 20, 1);
  144.         x += 16;
  145.         LCD_PutZH16x16(x, 2, lunaCalendarData.diZhi + 30, 1);
  146. }

  148. static void __NormalClock_TimeAction(void)
  149. {
  150.         INT8U err, x = 0;
  151.         INT8U h = 0;
  152.         INT8U m = 0;
  153.         INT8U s = 0;
  154.         INT8U d = 0;
  155.         INT8U month = 0;
  156.         INT8U date = 0;
  157.         INT8U year = 0;

  159.         stStateMsg *pStateMsg;
  160.         while(1)
  161.         {
  162.                 pStateMsg = (stStateMsg *)OSQPend(pStateQ, 10, &err);
  163.                 switch(err)
  164.                 {
  165.                 case OS_ERR_NONE:
  166.                         switch(pStateMsg->cmd)
  167.                         {
  168.                         case NORMAL_CLOCK_TIMEUPDATE:
  169.                                 x = 0;
  170.                                 LCD_PutLargeNumber(x, 0, ((h >> 4) & 0x0f), 1);
  171.                                 x += 12;
  172.                                 LCD_PutLargeNumber(x, 0, (h & 0x0f), 1);
  173.                                 x += 12;
  174.                                 if(s % 2)
  175.                                         LCD_PutLargeNumber(x, 0, 10, 1);
  176.                                 else
  177.                                         LCD_PutLargeNumber(x, 0, 11, 1);
  178.                                 x += 12;
  179.                                 LCD_PutLargeNumber(x, 0, ((m >> 4) & 0x0f), 1);
  180.                                 x += 12;
  181.                                 LCD_PutLargeNumber(x, 0, (m & 0x0f), 1);

  183.                                 break;
  184.                         case NORMAL_CLOCK_DATEUPDATE:
  185.                                 x = 0;
  186.                                 LCD_PutSmallChar(x, 3, '2', 1);
  187.                                 x += 6;
  188.                                 LCD_PutSmallChar(x, 3, '0', 1);
  189.                                 x += 6;
  190.                                 LCD_PutSmallChar(x, 3, '0' + ((year >> 4) & 0x0f), 1);
  191.                                 x += 6;
  192.                                 LCD_PutSmallChar(x, 3, '0' + (year & 0x0f), 1);

  194.                                 x += 12;
  195.                                 LCD_PutSmallChar(x, 3, '0' + ((month >> 4) & 0x0f), 1);
  196.                                 x += 6;
  197.                                 LCD_PutSmallChar(x, 3, '0' + (month & 0x0f), 1);

  199.                                 x += 12;
  200.                                 LCD_PutSmallChar(x, 3, '0' + ((date >> 4) & 0x0f), 1);
  201.                                 x += 6;
  202.                                 LCD_PutSmallChar(x, 3, '0' + (date & 0x0f), 1);

  204.                                 if(d == 7)
  205.                                         LCD_PutZH16x16(96, 0, 0, 1);
  206.                                 else
  207.                                         LCD_PutZH16x16(96, 0, d, 1);

  209.                                 solaCalendarToLunarCalendar(
  210.                                                                                         ((year >> 4) & 0x0f) * 10 +
  211.                                                                                                 (year & 0x0f) + 2000,
  212.                                                                                         ((month >> 4) & 0x0f) * 10 +
  213.                                                                                                 (month & 0x0f),
  214.                                                                                         ((date >> 4) & 0x0f) * 10 +
  215.                                                                                                 (date & 0x0f)
  216.                                                                                         );
  217.                                 __lunarCalendarDisplay();

  219.                                 break;

  221.                         case NORMAL_CLOCK_INIT:
  222.                                 LCD_Clear(0);

  224.                                 LCD_PutSmallChar(24, 3, '/', 1);
  225.                                 LCD_PutSmallChar(42, 3, '/', 1);

  227.                                 LCD_PutZH16x16(64, 0, 12, 1);
  228.                                 LCD_PutZH16x16(80, 0, 13, 1);
  229.                                 LCD_PutZH16x16(96, 2, 20, 1);

  231.                                 LCD_PutBmp(48, 6, BMP_BUTTON_ID_HOME, 1);
  232.                                 LCD_PutBmp(48, 7, BMP_BUTTON_ID_LAMP, 1);

  234.                                 DS1337_Getc(RTC_HOUR, &h);
  235.                                 DS1337_Getc(RTC_MIN, &m);
  236.                                 DS1337_Getc(RTC_SEC, &s);

  238.                                 DS1337_Getc(RTC_MONTH, &month);
  239.                                 DS1337_Getc(RTC_DATE, &date);
  240.                                 DS1337_Getc(RTC_YEAR, &year);

  242.                                 DS1337_Getc(RTC_DAY, &d);

  244.                                 if((h < 6) || (h > 18))
  245.                                 {
  246.                                         LCD_PutBmp(0, 4, BMP_PIC_ID_NIGHT, 1);
  247.                                 }
  248.                                 else if((h >= 6) && (h < 10))
  249.                                 {
  250.                                         LCD_PutBmp(0, 4, BMP_PIC_ID_MORNING, 1);
  251.                                 }
  252.                                 else if((h >= 10) && (h < 14))
  253.                                 {
  254.                                         LCD_PutBmp(0, 4, BMP_PIC_ID_NOON, 1);
  255.                                 }
  256.                                 else
  257.                                 {
  258.                                         LCD_PutBmp(0, 4, BMP_PIC_ID_AFTERNOON, 1);
  259.                                 }
  260.                                 pStateMsg = &stateMsg[1];
  261.                                 pStateMsg->cmd = NORMAL_CLOCK_TIMEUPDATE;
  262.                                 OSQPost(pStateQ, (void *)pStateMsg);

  264.                                 pStateMsg = &stateMsg[2];
  265.                                 pStateMsg->cmd = NORMAL_CLOCK_DATEUPDATE;
  266.                                 OSQPost(pStateQ, (void *)pStateMsg);
  267.                                 break;
  268.                         case NORMAL_CLOCK_PICUPDATE:
  269.                                 LCD_PutBmp(0, 4, (INT8U)(INT32U)pStateMsg->pData, 1);
  270.                                 break;
  271.                         case STATE_EXIT:
  272.                                 return;
  273.                         default:
  274.                                 break;
  275.                         }
  276.                         break;
  277.                 case OS_ERR_TIMEOUT:
  278.                         {
  279.                                 INT8U tmpSec = s, tmpDate = date, tmpHour = h;
  280.                                 DS1337_Getc(RTC_HOUR,  &h);
  281.                                 DS1337_Getc(RTC_MIN,   &m);
  282.                                 DS1337_Getc(RTC_SEC,   &s);

  284.                                 DS1337_Getc(RTC_MONTH,  &month);
  285.                                 DS1337_Getc(RTC_DATE,   &date);
  286.                                 DS1337_Getc(RTC_YEAR,   &year);
  287.                                 if(s != tmpSec)
  288.                                 {
  289.                                         pStateMsg = &stateMsg[1];
  290.                                         pStateMsg->cmd = NORMAL_CLOCK_TIMEUPDATE;
  291.                                         OSQPost(pStateQ, (void *)pStateMsg);
  292.                                 }

  294.                                 if(date != tmpDate)
  295.                                 {
  296.                                         pStateMsg = &stateMsg[2];
  297.                                         pStateMsg->cmd = NORMAL_CLOCK_DATEUPDATE;
  298.                                         OSQPost(pStateQ, (void *)pStateMsg);
  299.                                 }

  301.                                 if((tmpHour != h) &&
  302.                                    ((h == 0x06) || (h == 0x10) || (h == 0x14) || (h == 0x18))
  303.                                    )
  304.                                 {
  305.                                         pStateMsg = &stateMsg[3];
  306.                                         pStateMsg->cmd = NORMAL_CLOCK_PICUPDATE;
  307.                                         switch(h)
  308.                                         {
  309.                                         case 0x06:
  310.                                                 pStateMsg->pData = (void *)BMP_PIC_ID_MORNING;
  311.                                                 break;
  312.                                         case 0x10:
  313.                                                 pStateMsg->pData = (void *)BMP_PIC_ID_NOON;
  314.                                                 break;
  315.                                         case 0x14:
  316.                                                 pStateMsg->pData = (void *)BMP_PIC_ID_AFTERNOON;
  317.                                                 break;
  318.                                         case 0x18:
  319.                                                 pStateMsg->pData = (void *)BMP_PIC_ID_NIGHT;
  320.                                                 break;
  321.                                         default:
  322.                                                 pStateMsg->pData = (void *)BMP_PIC_ID_MORNING;
  323.                                                 break;
  324.                                         }
  325.                                         OSQPost(pStateQ, (void *)pStateMsg);
  326.                                 }
  327.                         }
  328.                         break;
  329.                 default:
  330.                         OSTimeDly(10);
  331.                         break;
  332.                 }
  333.         }
  334. }

  336. static void __NormalClock_EventProcess(void *ptr)
  337. {
  338.         INT8U err, exitFlag = 1u;
  339.         stMSG *pmsg;
  340.         stStateMsg *pStateMsg = &stateMsg[0];
  341.         while(exitFlag)
  342.         {
  343.                 pmsg = (stMSG *)OSMboxPend(pMsgEvent, 0, &err);
  344.                 switch(pmsg->keyValue)
  345.                 {
  346.                 case KEY_VAL_LEFT:
  347.                         break;
  348.                 case KEY_VAL_RIGHT:
  349.                         break;
  350.                 case KEY_VAL_UP:
  351.                         pState = &Home;
  352.                         ((INT8U *)pState->pdata)[0] = 1;
  353.                         ((INT8U *)pState->pdata)[1] = 1;
  354.                         pStateMsg->cmd = STATE_EXIT;
  355.                         OSQPost(pStateQ, (void *)pStateMsg);
  356.                         return;
  357.                 case KEY_VAL_DOWN | KEY_VAL_LONG:
  358.                 case KEY_VAL_DOWN:
  359.                         FLASH_POWER? FLASH_POWER_OFF : FLASH_POWER_ON;
  360.                         break;
  361.                 default:
  362.                         __defaultEventProcess(&exitFlag, pmsg, ptr);
  363.                         break;
  364.                 }
  365.         }
  366. }

  368. void State_NormalClock(void *ptr)
  369. {
  370.         stStateMsg *pStateMsg = &stateMsg[0];
  371.         pTimeAction = __NormalClock_TimeAction;
  372.         pStateMsg->cmd = NORMAL_CLOCK_INIT;
  373.         OSQPost(pStateQ, (void *)pStateMsg);

  375.         __NormalClock_EventProcess(ptr);
  376. }
  377. //Home
  378. static void __Home_TimeAction(void)
  379. {
  380.         INT8U err, x = 0;
  381.         INT8U h = 0;
  382.         INT8U m = 0;
  383.         INT8U s = 0;
  384.         stStateMsg *pStateMsg;
  385.         INT8U iconIndex, dspIndex;
  386.         INT8U dspMaxIndex = HomeIconTotalNum > 4 ? 4 : HomeIconTotalNum;
  387.         while(1)
  388.         {
  389.                 pStateMsg = (stStateMsg *)OSQPend(pStateQ, 10, &err);
  390.                 switch(err)
  391.                 {
  392.                 case OS_ERR_NONE:
  393.                         switch(pStateMsg->cmd)
  394.                         {
  395.                         case HOME_INIT:
  396.                                 LCD_Clear(0);
  397.                                 LCD_PutBmp(0, 6, BMP_BUTTON_ID_ENTER, 1);
  398.                                 LCD_PutBmp(48, 6, BMP_BUTTON_ID_UP, 1);
  399.                                 LCD_PutBmp(48, 7, BMP_BUTTON_ID_DOWN, 1);
  400.                                 LCD_PutBmp(96, 6, BMP_BUTTON_ID_BACK, 1);

  402.                                 DS1337_Getc(RTC_HOUR,  &h);
  403.                                 DS1337_Getc(RTC_MIN,   &m);
  404.                                 DS1337_Getc(RTC_SEC,   &s);
  405.                                 dspIndex = ((INT8U *)pStateMsg->pData)[0];
  406.                                 iconIndex = ((INT8U *)pStateMsg->pData)[1];

  408.                                 pStateMsg = &stateMsg[1];
  409.                                 pStateMsg->cmd = HOME_ICONUPDATE;
  410.                                 pStateMsg->pData = (void *)&iconIndex;
  411.                                 OSQPost(pStateQ, (void *)pStateMsg);

  413.                                 pStateMsg = &stateMsg[2];
  414.                                 pStateMsg->cmd = HOME_TIMEUPDATE;
  415.                                 OSQPost(pStateQ, (void *)pStateMsg);

  417.                                 break;
  418.                         case HOME_ICONMOVELEFT:
  419.                                 iconIndex = (*(INT8U *)pStateMsg->pData);
  420.                                 if(iconIndex == HomeIconTotalNum)
  421.                                         dspIndex = dspMaxIndex;
  422.                                 else if(dspIndex > 1)
  423.                                         dspIndex--;
  424.                                 pStateMsg = &stateMsg[1];
  425.                                 pStateMsg->cmd = HOME_ICONUPDATE;
  426.                                 pStateMsg->pData = (void *)&iconIndex;
  427.                                 OSQPost(pStateQ, (void *)pStateMsg);
  428.                                 break;
  429.                         case HOME_ICONMOVERIGHT:
  430.                                 iconIndex = (*(INT8U *)pStateMsg->pData);
  431.                                 if(iconIndex == 1)
  432.                                         dspIndex = 1;
  433.                                 else if(dspIndex < dspMaxIndex)
  434.                                         dspIndex++;
  435.                                 pStateMsg = &stateMsg[1];
  436.                                 pStateMsg->cmd = HOME_ICONUPDATE;
  437.                                 pStateMsg->pData = (void *)&iconIndex;
  438.                                 OSQPost(pStateQ, (void *)pStateMsg);
  439.                                 break;
  440.                         case HOME_ICONUPDATE:
  441.                                 {
  442.                                         INT8U i, j;
  443.                                         LCD_PutMenuStr(0, 64, 0, &HomeIcon[iconIndex - 1]->str, 1);
  444.                                         i = iconIndex - dspIndex;
  445.                                         x = 0;
  446.                                         for(j = 1; j < dspMaxIndex + 1; j++)
  447.                                         {
  448.                                                 if(j == dspIndex)
  449.                                                         LCD_PutBmp(x, 2, HomeIcon[i]->iconID, 0);
  450.                                                 else
  451.                                                         LCD_PutBmp(x, 2, HomeIcon[i]->iconID, 1);
  452.                                                 i++;
  453.                                                 x += 32;
  454.                                         }
  455.                                 }
  456.                                 break;
  457.                         case HOME_TIMEUPDATE:
  458.                                 {
  459.                                         char strBuf[6], *str = strBuf;
  460.                                         *str = '0' + (h >> 4), str++;
  461.                                         *str = '0' + (h &0x0f), str++;
  462.                                         if(s % 2)
  463.                                                 *str = ':', str++;
  464.                                         else
  465.                                                 *str = ' ', str++;
  466.                                         *str = '0' + (m >> 4), str++;
  467.                                         *str = '0' + (m & 0x0f), str++;
  468.                                         *str = 0;
  469.                                         LCD_PutMiddleString(88, 0, strBuf, 1);
  470.                                 }
  471.                                 break;
  472.                         case STATE_EXIT:
  473.                                 ((INT8U *)Home.pdata)[0] = dspIndex;
  474.                                 return;
  475.                         default:
  476.                                 break;
  477.                         }
  478.                 case OS_ERR_TIMEOUT:
  479.                         {
  480.                                 INT8U tmpSec = s;
  481.                                 DS1337_Getc(RTC_HOUR,  &h);
  482.                                 DS1337_Getc(RTC_MIN,   &m);
  483.                                 DS1337_Getc(RTC_SEC,   &s);
  484.                                 if(s != tmpSec)
  485.                                 {
  486.                                         pStateMsg = &stateMsg[2];
  487.                                         pStateMsg->cmd = HOME_TIMEUPDATE;
  488.                                         OSQPost(pStateQ, (void *)pStateMsg);
  489.                                 }
  490.                         }
  491.                         break;
  492.                 default:
  493.                         OSTimeDly(10);
  494.                         break;
  495.                 }
  496.         }
  497. }
  498. static void __Home_EventProcess(void *ptr)
  499. {
  500.         INT8U err, exitFlag = 1u;
  501.         stMSG *pmsg;
  502.         stStateMsg *pStateMsg = &stateMsg[0];
  503.         INT8U iconIndex;
  504.         stStateInfo *pthisState = (stStateInfo *)ptr;

  506.         pTimeAction = __Home_TimeAction;
  507.         pStateMsg->cmd = HOME_INIT;
  508.         pStateMsg->pData = pthisState->pdata;
  509.         iconIndex = ((INT8U *)pthisState->pdata)[1];
  510.         OSQPost(pStateQ, (void *)pStateMsg);

  512.         while(exitFlag)
  513.         {
  514.                 pmsg = (stMSG *)OSMboxPend(pMsgEvent,
  515.                                                                    CONFIG_MENU_TIME_OUT * 100u,
  516.                                                                    &err);
  517.                 switch(err)
  518.                 {
  519.                 case OS_ERR_NONE:
  520.                         switch(pmsg->keyValue)
  521.                         {
  522.                         case KEY_VAL_LEFT:
  523.                                 if(iconIndex)
  524.                                 {
  525.                                         pState = HomeIcon[iconIndex - 1]->pstate;
  526.                                         pStateMsg->cmd = STATE_EXIT;
  527.                                         if(pState == &Menu)
  528.                                         {
  529.                                                 pMenuListEntry =
  530.                                                         (const stMenuList *)HomeIcon[iconIndex - 1]->data;
  531.                                                 ((INT8U *)pMenuListEntry->pdata)[0] = 1;
  532.                                                 ((INT8U *)pMenuListEntry->pdata)[1] = 1;
  533.                                         }
  534.                                         OSQPost(pStateQ, (void *)pStateMsg);
  535.                                         ((INT8U *)Home.pdata)[1] = iconIndex;
  536.                                         return;
  537.                                 }
  538.                                 else
  539.                                         break;
  540.                         case KEY_VAL_RIGHT:
  541.                                 pState = &NormalClock;
  542.                                 pStateMsg->cmd = STATE_EXIT;
  543.                                 OSQPost(pStateQ, (void *)pStateMsg);
  544.                                 return;
  545.                         case KEY_VAL_UP | KEY_VAL_LONG:
  546.                         case KEY_VAL_UP:
  547.                                 if(iconIndex <= 1)
  548.                                         iconIndex = HomeIconTotalNum;
  549.                                 else
  550.                                         iconIndex --;
  551.                                 pStateMsg->cmd = HOME_ICONMOVELEFT;
  552.                                 pStateMsg->pData = (void *)&iconIndex;
  553.                                 OSQPost(pStateQ, (void *)pStateMsg);
  554.                                 break;
  555.                         case KEY_VAL_DOWN | KEY_VAL_LONG:
  556.                         case KEY_VAL_DOWN:
  557.                                 iconIndex++;
  558.                                 if(iconIndex > HomeIconTotalNum)
  559.                                         iconIndex = 1;
  560.                                 pStateMsg->cmd = HOME_ICONMOVERIGHT;
  561.                                 pStateMsg->pData = (void *)&iconIndex;
  562.                                 OSQPost(pStateQ, (void *)pStateMsg);
  563.                                 break;
  564.                         default:
  565.                                 __defaultEventProcess(&exitFlag, pmsg, ptr);
  566.                                 break;
  567.                         }
  568.                         break;
  569.                 case OS_ERR_TIMEOUT:
  570.                         pState = &NormalClock;
  571.                         pStateMsg->cmd = STATE_EXIT;
  572.                         OSQPost(pStateQ, (void *)pStateMsg);
  573.                         return;
  574.                 default:
  575.                         OSTimeDly(10);
  576.                         break;
  577.                 }
  578.         }
  579. }

  581. void State_Home(void *ptr)
  582. {
  583.         __Home_EventProcess(ptr);
  584. }

  586. //Power off
  587. static void __PowerOff_TimeAction(void)
  588. {
  589.         INT8U err, x, count, sec;
  590.         stStateMsg *pStateMsg;
  591.         while(1)
  592.         {
  593.                 pStateMsg = (stStateMsg *)OSQPend(pStateQ, 50, &err);
  594.                 switch(err)
  595.                 {
  596.                 case OS_ERR_NONE:
  597.                         switch(pStateMsg->cmd)
  598.                         {
  599.                         case POWER_OFF_INIT:
  600.                                 LCD_Clear(0);
  601.                                 LED_ON;
  602.                                 x = 32;
  603.                                 LCD_PutZH16x16(x, 2, 53, 1), x += 16;
  604.                                 LCD_PutZH16x16(x, 2, 54, 1), x += 16;
  605.                                 LCD_PutZH16x16(x, 2, 55, 1), x += 16;
  606.                                 LCD_PutSmallString(x, 3, "...", 1);
  607.                                 sec = CONFIG_POWER_OFF_KEEP_TIME;
  608.                                 count = sec << 1;
  609.                                 pStateMsg = &stateMsg[1];
  610.                                 pStateMsg->cmd = POWER_OFF_TIMESECUPDATE;
  611.                                 OSQPost(pStateQ, (void *)pStateMsg);
  612.                                 break;
  613.                         case POWER_OFF_TIMESECUPDATE:
  614.                                 x = 56;
  615.                                 LCD_PutMiddleChar(x, 4, '0' + sec / 10, 0);
  616.                                 x += 8;
  617.                                 LCD_PutMiddleChar(x, 4, '0' + sec % 10, 0);
  618.                                 break;
  619.                         case STATE_EXIT:
  620.                                 LED_OFF;
  621.                                 return;
  622.                         default:
  623.                                 break;
  624.                         }
  625.                         break;
  626.                 case OS_ERR_TIMEOUT:
  627.                         if(count == 1)
  628.                         {
  629.                                 DIGITAL_POWER_OFF;
  630.                                 while(IO2PIN_bit.P2_25)
  631.                                 {
  632.                                         OSTimeDly(10);
  633.                                 }
  634.                         }
  635.                         else
  636.                         {
  637.                                 count--;
  638.                                 sec = count >> 1;
  639.                                 LED_POWER? LED_OFF : LED_ON;
  640.                                 pStateMsg = &stateMsg[2];
  641.                                 pStateMsg->cmd = POWER_OFF_TIMESECUPDATE;
  642.                                 OSQPost(pStateQ, (void *)pStateMsg);
  643.                         }
  644.                         break;
  645.                 default:
  646.                         OSTimeDly(10);
  647.                         break;
  648.                 }
  649.         }
  650. }
  651. static void __PowerOff_EventProcess(void *ptr)
  652. {
  653.         INT8U err;
  654.         stMSG *pmsg;
  655.         stStateMsg *pStateMsg = &stateMsg[0];
  656.         stStateInfo *plastState = (stStateInfo *)ptr;
  657.         plastState = (stStateInfo *)(*(INT32U *)plastState->pdata);
  658.         while(1)
  659.         {
  660.                 pmsg = (stMSG *)OSMboxPend(pMsgEvent, 51, &err);
  661.                 switch(err)
  662.                 {
  663.                 case OS_ERR_NONE:
  664.                         {
  665.                                 switch(pmsg->keyValue)
  666.                                 {
  667.                                 case KEY_VAL_UP | KEY_VAL_LONG:

  669.                                         break;
  670.                                 default:
  671.                                         goto POWEROFF_EXIT;
  672.                                         break;
  673.                                 }
  674.                         }
  675.                         break;
  676.                 case OS_ERR_TIMEOUT:
  677.                         {
  678. POWEROFF_EXIT:        if(plastState)
  679.                                 {
  680.                                         pState = plastState;
  681.                                 }
  682.                                 else
  683.                                 {
  684.                                         pState = &Home;//&NormalClock;
  685.                                 }
  686.                                 pStateMsg->cmd = STATE_EXIT;
  687.                                 OSQPost(pStateQ, (void *)pStateMsg);
  688.                                 return;
  689.                         }
  690.                         break;
  691.                 default:
  692.                         OSTimeDly(10);
  693.                         break;
  694.                 }
  695.         }
  696. }
  697. void State_PowerOff(void *ptr)
  698. {
  699.         stStateMsg *pStateMsg = &stateMsg[0];
  700.         pTimeAction = __PowerOff_TimeAction;
  701.         pStateMsg->cmd = POWER_OFF_INIT;
  702.         OSQPost(pStateQ, (void *)pStateMsg);

  704.         __PowerOff_EventProcess(ptr);
  705. }
  706. //Menu
  707. static void __Menu_TimeAction(void)
  708. {
  709.         INT8U err, y;
  710.         INT8U h = 0;
  711.         INT8U m = 0;
  712.         INT8U s = 0;
  713.         stStateMsg *pStateMsg;
  714.         const stMenuList *pthisMenuList = NULL;
  715.         const stMenuItem *pMenuItem;
  716.         INT8U itemIndex = 1, dspIndex = 1;
  717.         INT8U dspMaxIndex;
  718.         while(1)
  719.         {
  720.                 pStateMsg = (stStateMsg *)OSQPend(pStateQ, 50, &err);
  721.                 switch(err)
  722.                 {
  723.                 case OS_ERR_NONE:
  724.                         switch(pStateMsg->cmd)
  725.                         {
  726.                         case MENU_INIT:
  727.                                 LCD_Clear(0);
  728.                                 LCD_PutBmp(0, 6, BMP_BUTTON_ID_ENTER, 1);
  729.                                 LCD_PutBmp(48, 6, BMP_BUTTON_ID_UP, 1);
  730.                                 LCD_PutBmp(48, 7, BMP_BUTTON_ID_DOWN, 1);
  731.                                 LCD_PutBmp(96, 6, BMP_BUTTON_ID_BACK, 1);

  733.                                 DS1337_Getc(RTC_HOUR,  &h);
  734.                                 DS1337_Getc(RTC_MIN,   &m);
  735.                                 DS1337_Getc(RTC_SEC,   &s);

  737.                                 stateMsg[1].pData = pStateMsg->pData;
  738.                                 pStateMsg = &stateMsg[1];
  739.                                 pStateMsg->cmd = MENU_LISTUPDATE;
  740.                                 OSQPost(pStateQ, (void *)pStateMsg);


  743.                                 pStateMsg = &stateMsg[2];
  744.                                 pStateMsg->cmd = MENU_ITEMUPDATE;
  745.                                 OSQPost(pStateQ, (void *)pStateMsg);

  747.                                 pStateMsg = &stateMsg[3];
  748.                                 pStateMsg->cmd = MENU_TIMEUPDATE;
  749.                                 OSQPost(pStateQ, (void *)pStateMsg);

  751.                         case MENU_TIMEUPDATE:
  752.                                 {
  753.                                         char strBuf[6], *str = strBuf;
  754.                                         *str = '0' + (h >> 4), str++;
  755.                                         *str = '0' + (h &0x0f), str++;
  756.                                         if(s % 2)
  757.                                                 *str = ':', str++;
  758.                                         else
  759.                                                 *str = ' ', str++;
  760.                                         *str = '0' + (m >> 4), str++;
  761.                                         *str = '0' + (m & 0x0f), str++;
  762.                                         *str = 0;
  763.                                         LCD_PutMiddleString(88, 0, strBuf, 1);
  764.                                 }
  765.                                 break;
  766.                         case MENU_ITEMMOVEUP:

  768.                                 itemIndex = (*(INT8U *)pStateMsg->pData);
  769.                                 if(itemIndex == pthisMenuList->itemNum)
  770.                                         dspIndex = dspMaxIndex;
  771.                                 else if(dspIndex > 1)
  772.                                         dspIndex--;

  774.                                 pStateMsg = &stateMsg[2];
  775.                                 pStateMsg->cmd = MENU_ITEMUPDATE;
  776.                                 pStateMsg->pData = (void *)&itemIndex;
  777.                                 OSQPost(pStateQ, (void *)pStateMsg);
  778.                                 break;
  779.                         case MENU_ITEMMOVEDOWN:

  781.                                 itemIndex = (*(INT8U *)pStateMsg->pData);
  782.                                 if(itemIndex == 1)
  783.                                         dspIndex = 1;
  784.                                 else if(dspIndex < dspMaxIndex)
  785.                                         dspIndex++;

  787.                                 pStateMsg = &stateMsg[2];
  788.                                 pStateMsg->cmd = MENU_ITEMUPDATE;
  789.                                 pStateMsg->pData = (void *)&itemIndex;
  790.                                 OSQPost(pStateQ, (void *)pStateMsg);
  791.                                 break;
  792.                         case MENU_ITEMUPDATE:
  793.                                 {
  794.                                         INT8U i, j;
  795.                                         LCD_PutMenuStr(0, 64, 0, pthisMenuList->pname, 1);
  796.                                         i = itemIndex - dspIndex;
  797.                                         y = 2;
  798.                                         for(j = 1; j < dspMaxIndex + 1; j++)
  799.                                         {
  800.                                                 pMenuItem = pthisMenuList->pItem[i];
  801.                                                 if(j == dspIndex)
  802.                                                         LCD_PutMenuStr(0, 128, y, &pMenuItem->itemName, 0);
  803.                                                 else
  804.                                                         LCD_PutMenuStr(0, 128, y, &pMenuItem->itemName, 1);
  805.                                                 i++;
  806.                                                 y += 2;
  807.                                         }
  808.                                 }
  809.                                 break;
  810.                         case MENU_LISTUPDATE:
  811.                                 if(pthisMenuList)
  812.                                         ((INT8U *)pthisMenuList->pdata)[0] = dspIndex;

  814.                                 pthisMenuList=
  815.                                         (const stMenuList *)(*(INT32U *)pStateMsg->pData);
  816.                                 itemIndex = ((INT8U *)pthisMenuList->pdata)[1];
  817.                                 dspMaxIndex =
  818.                                         pthisMenuList->itemNum > 2 ? 2 : pthisMenuList->itemNum;
  819.                                 dspIndex = ((INT8U *)pthisMenuList->pdata)[0];

  821.                                 break;
  822.                         case STATE_EXIT:
  823.                                 ((INT8U *)pthisMenuList->pdata)[0] = dspIndex;
  824.                                 return;
  825.                         default:
  826.                                 break;
  827.                         }
  828.                 case OS_ERR_TIMEOUT:
  829.                         {
  830.                                 INT8U tmpSec = s;
  831.                                 DS1337_Getc(RTC_HOUR,  &h);
  832.                                 DS1337_Getc(RTC_MIN,   &m);
  833.                                 DS1337_Getc(RTC_SEC,   &s);
  834.                                 if(s != tmpSec)
  835.                                 {
  836.                                         pStateMsg = &stateMsg[3];
  837.                                         pStateMsg->cmd = MENU_TIMEUPDATE;
  838.                                         OSQPost(pStateQ, (void *)pStateMsg);
  839.                                 }
  840.                         }
  841.                         break;
  842.                 default:
  843.                         OSTimeDly(10);
  844.                         break;
  845.                 }
  846.         }
  847. }

  849. static void __Menu_EventProcess(void *ptr)
  850. {
  851.         INT8U err, exitFlag = 1u;
  852.         INT8U itemIndex;
  853.         stMSG *pmsg;
  854.         stStateMsg *pStateMsg = &stateMsg[0];
  855.         stStateInfo *pthisState = (stStateInfo *)ptr;
  856.         const stMenuList *pthisMenuList;
  857.         const stMenuItem *pMenuItem;

  859.         pthisMenuList = (const stMenuList *)(*((INT32U *)pthisState->stateMask));

  861.         itemIndex = ((INT8U *)pthisMenuList->pdata)[1];
  862.         pTimeAction = __Menu_TimeAction;
  863.         pStateMsg->cmd = MENU_INIT;
  864.         pStateMsg->pData = (void *)&pthisMenuList;
  865.         OSQPost(pStateQ, (void *)pStateMsg);

  867.         while(exitFlag)
  868.         {
  869.                 pmsg = (stMSG *)OSMboxPend(pMsgEvent,
  870.                                                                    CONFIG_MENU_TIME_OUT * 100u,
  871.                                                                    &err);
  872.                 switch(err)
  873.                 {
  874.                 case OS_ERR_NONE:
  875.                         {
  876.                                 switch(pmsg->keyValue)
  877.                                 {
  878.                                 case KEY_VAL_LEFT:
  879.                                         if(pthisMenuList->pItem[itemIndex - 1]->subItemNum)
  880.                                         {
  881.                                                 ((INT8U *)pthisMenuList->pdata)[1] = itemIndex;
  882.                                                 pMenuItem = pthisMenuList->pItem[itemIndex - 1];
  883.                                                 pthisMenuList = (const stMenuList *)(pMenuItem->pData);
  884.                                                 itemIndex = 1;
  885.                                                 ((INT8U *)pthisMenuList->pdata)[0] = 1;
  886.                                                 ((INT8U *)pthisMenuList->pdata)[1] = 1;

  888.                                                 pStateMsg = &stateMsg[0];
  889.                                                 pStateMsg->cmd = MENU_LISTUPDATE;
  890.                                                 pStateMsg->pData = (void *)&pthisMenuList;
  891.                                                 OSQPost(pStateQ, (void *)pStateMsg);

  893.                                                 pStateMsg = &stateMsg[2];
  894.                                                 pStateMsg->cmd = MENU_ITEMUPDATE;
  895.                                                 OSQPost(pStateQ, (void *)pStateMsg);

  897.                                                 break;
  898.                                         }
  899.                                         else
  900.                                         {
  901.                                                 pMenuItem = pthisMenuList->pItem[itemIndex - 1];
  902.                                                 pState = (const stStateInfo *)(pMenuItem->pData);

  904.                                                 pStateMsg = &stateMsg[0];
  905.                                                 pStateMsg->cmd = STATE_EXIT;
  906.                                                 OSQPost(pStateQ, (void *)pStateMsg);
  907.                                                 ((INT8U *)pthisMenuList->pdata)[1] = itemIndex;
  908.                                                 return;
  909.                                         }
  910.                                 case KEY_VAL_RIGHT:
  911.                                         if(pthisMenuList->pparentItemList)
  912.                                         {
  913.                                                 itemIndex = pthisMenuList->pparentItem->thisItemID + 1;
  914.                                                 pthisMenuList = pthisMenuList->pparentItemList;

  916.                                                 pStateMsg = &stateMsg[0];
  917.                                                 pStateMsg->cmd = MENU_LISTUPDATE;
  918.                                                 pStateMsg->pData = (void *)&pthisMenuList;
  919.                                                 OSQPost(pStateQ, (void *)pStateMsg);

  921.                                                 pStateMsg = &stateMsg[2];
  922.                                                 pStateMsg->cmd = MENU_ITEMUPDATE;
  923.                                                 OSQPost(pStateQ, (void *)pStateMsg);
  924.                                                 break;
  925.                                         }
  926.                                         else
  927.                                         {
  928.                                                 pState = &Home;

  930.                                                 ((INT8U *)pthisMenuList->pdata)[0] = 1;
  931.                                                 ((INT8U *)pthisMenuList->pdata)[1] = 1;

  933.                                                 pStateMsg = &stateMsg[0];
  934.                                                 pStateMsg->cmd = STATE_EXIT;
  935.                                                 OSQPost(pStateQ, (void *)pStateMsg);
  936.                                                 return;
  937.                                         }
  938.                                 case KEY_VAL_UP | KEY_VAL_LONG:
  939.                                 case KEY_VAL_UP:
  940.                                         if(itemIndex <= 1)
  941.                                                 itemIndex = pthisMenuList->itemNum;
  942.                                         else
  943.                                                 itemIndex--;

  945.                                         pStateMsg = &stateMsg[0];
  946.                                         pStateMsg->cmd = MENU_ITEMMOVEUP;
  947.                                         pStateMsg->pData = (void *)&itemIndex;
  948.                                         OSQPost(pStateQ, (void *)pStateMsg);
  949.                                         break;
  950.                                 case KEY_VAL_DOWN | KEY_VAL_LONG:
  951.                                 case KEY_VAL_DOWN:
  952.                                         itemIndex++;
  953.                                         if(itemIndex > pthisMenuList->itemNum)
  954.                                                 itemIndex = 1;

  956.                                         pStateMsg = &stateMsg[0];
  957.                                         pStateMsg->cmd = MENU_ITEMMOVEDOWN;
  958.                                         pStateMsg->pData = (void *)&itemIndex;
  959.                                         OSQPost(pStateQ, (void *)pStateMsg);
  960.                                         break;
  961.                                 default:
  962.                                         __defaultEventProcess(&exitFlag, pmsg, ptr);
  963.                                         break;
  964.                                 }
  965.                         }
  966.                         break;
  967.                 case OS_ERR_TIMEOUT:
  968.                         pState = &NormalClock;

  970.                         pStateMsg = &stateMsg[0];
  971.                         pStateMsg->cmd = STATE_EXIT;
  972.                         OSQPost(pStateQ, (void *)pStateMsg);
  973.                         return;
  974.                 default:
  975.                         OSTimeDly(10);
  976.                         break;
  977.                 }
  978.         }
  979. }
  980. void State_Menu(void *ptr)
  981. {
  982.         __Menu_EventProcess(ptr);
  983. }

  985. //Set date
  986. static void __SetDate_TimeAction(void)
  987. {
  988.         INT8U err;
  989.         stStateMsg *pStateMsg;
  990.         while(1)
  991.         {
  992.                 pStateMsg = (stStateMsg *)OSQPend(pStateQ, 0, &err);
  993.                 switch(err)
  994.                 {
  995.                 case OS_ERR_NONE:
  996.                         switch(pStateMsg->cmd)
  997.                         {
  998.                         case SETDATE_INIT:
  999.                                 LCD_Clear(0);
  1000.                                 LCD_PutBmp(0, 6, BMP_BUTTON_ID_ENTER, 1);
  1001.                                 LCD_PutBmp(48, 6, BMP_BUTTON_ID_UP, 1);
  1002.                                 LCD_PutBmp(48, 7, BMP_BUTTON_ID_DOWN, 1);
  1003.                                 LCD_PutBmp(96, 6, BMP_BUTTON_ID_BACK, 1);
  1004.                                 break;
  1005.                         case STATE_EXIT:
  1006.                                 return;
  1007.                         default:
  1008.                                 break;
  1009.                         }
  1010.                         break;
  1011.                 case OS_ERR_TIMEOUT:
  1012.                 default:
  1013.                         OSTimeDly(10);
  1014.                         break;
  1015.                 }
  1016.         }
  1017. }
  1018. static void __SetDate_EventProcess(void *ptr)
  1019. {
  1020.         INT8U err, exitFlag = 1u;
  1021.         stMSG *pmsg;
  1022.         stStateMsg *pStateMsg = &stateMsg[0];
  1023.         while(exitFlag)
  1024.         {
  1025.                 pmsg = (stMSG *)OSMboxPend(pMsgEvent,
  1026.                                                                    CONFIG_MENU_TIME_OUT * 100u,
  1027.                                                                    &err);
  1028.                 switch(err)
  1029.                 {
  1030.                 case OS_ERR_NONE:
  1031.                         {
  1032.                                 switch(pmsg->keyValue)
  1033.                                 {
  1034.                                 case KEY_VAL_LEFT:
  1035.                                         break;
  1036.                                 case KEY_VAL_RIGHT:
  1037.                                         *(INT32U *)pState->stateMask = (INT32U)pState->pdata;
  1038.                                         pState = &Menu;
  1039.                                         pStateMsg = &stateMsg[0];
  1040.                                         pStateMsg->cmd = STATE_EXIT;
  1041.                                         OSQPost(pStateQ, (void *)pStateMsg);
  1042.                                         return;
  1043.                                 case KEY_VAL_UP | KEY_VAL_LONG:
  1044.                                 case KEY_VAL_UP:
  1045.                                         break;
  1046.                                 case KEY_VAL_DOWN | KEY_VAL_LONG:
  1047.                                 case KEY_VAL_DOWN:
  1048.                                         break;
  1049.                                 default:
  1050.                                         __defaultEventProcess(&exitFlag, pmsg, ptr);
  1051.                                         break;
  1052.                                 }
  1053.                         }
  1054.                         break;
  1055.                 case OS_ERR_TIMEOUT:
  1056.                         pState = &NormalClock;

  1058.                         pStateMsg = &stateMsg[0];
  1059.                         pStateMsg->cmd = STATE_EXIT;
  1060.                         OSQPost(pStateQ, (void *)pStateMsg);
  1061.                         return;
  1062.                 default:
  1063.                         OSTimeDly(10);
  1064.                         break;
  1065.                 }
  1066.         }
  1067. }
  1068. void State_SetDate(void *ptr)
  1069. {
  1070.         stStateMsg *pStateMsg = &stateMsg[0];
  1071.         pTimeAction = __SetDate_TimeAction;
  1072.         pStateMsg->cmd = SETDATE_INIT;
  1073.         OSQPost(pStateQ, (void *)pStateMsg);

  1075.         __SetDate_EventProcess(ptr);
  1076. }
  1077. //Common function
  1078. static void __defaultEventProcess(INT8U *pexitFlag, stMSG *pmsg, void *ptr)
  1079. {
  1080.         stStateMsg *pStateMsg = &stateMsg[0];
  1081.         switch(pmsg->keyValue)
  1082.         {
  1083.                 case KEY_VAL_UP | KEY_VAL_LONG:
  1084.                         *pexitFlag = 0;
  1085.                         *(INT32U *)PowerOff.pdata = (INT32U)ptr;
  1086.                         pState = &PowerOff;
  1087.                         pStateMsg->cmd = STATE_EXIT;
  1088.                         OSQPost(pStateQ, (void *)pStateMsg);
  1089.                         break;
  1090.         }
  1091. }
  1092. void State_RunMachine(void)
  1093. {
  1094.         pState->pfun((void *)pState);
  1095. }

  1097. void State_TimeAction(void)
  1098. {
  1099.         pTimeAction();
  1100. }
复制代码


  1. #ifndef STATE_H_
  2. #define STATE_H_
  3. #include "Interrupt.h"
  4. #include "ucos_ii.h"
  5. #include "Task.h"
  6. #include "Config.h"
  7. #include "Menu.h"
  8. struct ST_STATE_INFO;

  10. #define NORMAL_CLOCK_INIT                0u
  11. #define NORMAL_CLOCK_TIMEUPDATE        1u
  12. #define NORMAL_CLOCK_DATEUPDATE        2u
  13. #define NORMAL_CLOCK_PICUPDATE        3u

  15. #define HOME_INIT                                0u
  16. #define HOME_ICONUPDATE                        1u
  17. #define HOME_ICONMOVELEFT                2u
  18. #define HOME_ICONMOVERIGHT                3u
  19. #define HOME_TIMEUPDATE                        4u

  21. #define POWER_OFF_INIT                        0u
  22. #define POWER_OFF_TIMESECUPDATE        1u

  24. #define MENU_INIT                                0u
  25. #define MENU_ITEMUPDATE                        1u
  26. #define MENU_ITEMMOVEUP                        2u
  27. #define MENU_ITEMMOVEDOWN                3u
  28. #define MENU_TIMEUPDATE                        4u
  29. #define MENU_LISTUPDATE                        5u

  31. #define SETDATE_INIT                        0u

  33. #define STATE_EXIT                                10u
  34. #define STATE_MSG_SIZE                        5u

  36. typedef void (* tStateFun)(void *ptr);
  37. #define STATE_FUN tStateFun

  39. typedef struct {
  40.         INT8U cmd;
  41.         void *pData;
  42. }stStateMsg;

  44. typedef struct ST_STATE_INFO{
  45.         INT32U stateMask;
  46.         STATE_FUN pfun;
  47.         void *pdata;
  48. }stStateInfo;

  50. extern OS_EVENT *pStateQ;
  51. extern void *StateMsg[STATE_MSG_SIZE];
  52. extern const stStateInfo *pState;

  54. extern const stStateInfo NormalClock;
  55. extern const stStateInfo Home;
  56. extern const stStateInfo PowerOff;
  57. extern const stStateInfo Menu;

  59. extern const stStateInfo SetDate;

  61. extern void State_RunMachine(void);
  62. extern void State_TimeAction(void);
  63. #endif /* STATE_H_ */
复制代码




作者: coolby9458    时间: 2017-12-16 18:48
不错。LPC2214. M0+。 CAN,usb。
作者: vlivli    时间: 2019-10-30 10:19
源文件能下载吗？
作者: 1679079206    时间: 2020-3-18 13:42
好东西，原理图能分享下吗？



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1