请选择 进入手机版 | 继续访问电脑版

EDABOSS电子论坛

 找回密码
 立即注册
搜索
热搜: 活动 交友 discuz
查看: 892|回复: 0

[资源共享] LPC2214主控ucos ii下液晶菜单的设计

[复制链接]

4

主题

1

回帖

10

E币

技术员

Rank: 2

积分
9
发表于 2017-3-29 10:20:36 | 显示全部楼层 |阅读模式
主控芯片采用的是LPC2214单片机.

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

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

022707w8scnkklkvl99vkm.png

022715nmv8xonve55olgme.png


其实原理也很简单没啥技术含量,纯属娱乐,就当做对ucos ii的学习了。
  1. #include "Menu.h"
  2. //Common
  3. //extern const stStateInfo NormalClock;
  4. const stMenuList *pMenuListEntry = NULL;

  5. //Home

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

  56. const stHomeIcon *HomeIcon[] = {
  57.         &clockIcon,
  58.     &calendarIcon,
  59.         &gameIcon,
  60.         &settingIcon,
  61.         &systemIcon,
  62. };

  63. const INT8U HomeIconTotalNum = sizeof(HomeIcon) / sizeof(stHomeIcon *);
  64. //Set menu
  65. static INT8U menuSetInputData[2] = {1, 1};
  66. #define MENU_SET_ITEM_ID                        0u

  67. #define MENU_SET_TIME_ITEM_ID                MENU_SET_ITEM_ID + 0u
  68. static const char menuSetTimeStr[] = {
  69.         MENU_ZH_CODE_START, 43,
  70.         MENU_ZH_CODE_START, 56,
  71.         MENU_ZH_CODE_START, 48,
  72.         MENU_ZH_CODE_START, 49
  73. };
  74. const stMenuItem MenuSetTime = {
  75.         0u,
  76.         MENU_SET_TIME_ITEM_ID,
  77.         {menuSetTimeStr, sizeof(menuSetTimeStr)},
  78.         &NormalClock,
  79. };

  80. #define MENU_SET_DATE_ITEM_ID                MENU_SET_TIME_ITEM_ID + 1u
  81. static const char menuSetDateStr[] = {
  82.         MENU_ZH_CODE_START, 0,
  83.         MENU_ZH_CODE_START, 13,
  84.         MENU_ZH_CODE_START, 48,
  85.         MENU_ZH_CODE_START, 49
  86. };
  87. const stMenuItem MenuSetDate = {
  88.         0u,
  89.         MENU_SET_DATE_ITEM_ID,
  90.         {menuSetDateStr, sizeof(menuSetDateStr)},
  91.         &SetDate,
  92. };

  93. #define MENU_SYSTEM_SET_ITEM_ID                MENU_SET_DATE_ITEM_ID + 1u
  94. static const char menuSystemSetStr[] = {
  95.         MENU_ZH_CODE_START, 50,
  96.         MENU_ZH_CODE_START, 51,
  97.         MENU_ZH_CODE_START, 48,
  98.         MENU_ZH_CODE_START, 49
  99. };
  100. const stMenuItem MenuSystemSet = {
  101.         3u,
  102.         MENU_SYSTEM_SET_ITEM_ID,
  103.         {menuSystemSetStr, sizeof(menuSystemSetStr)},
  104.         &MenuSystemSetList,
  105. };

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

  135. #define MENU_MENU_OVERTIME_ITEM_ID                MENU_BACK_LIGHT_TIME_ITEM_ID + 0u
  136. static const char menuOvertimeStr[] = {
  137.         MENU_ZH_CODE_START, 59,
  138.         MENU_ZH_CODE_START, 60,
  139.         MENU_ZH_CODE_START, 61,
  140.         MENU_ZH_CODE_START, 43,
  141.         MENU_ZH_CODE_START, 43,
  142.         MENU_ZH_CODE_START, 56
  143. };
  144. const stMenuItem MenuOvertime = {
  145.         0u,
  146.         MENU_MENU_OVERTIME_ITEM_ID,
  147.         {menuOvertimeStr, sizeof(menuOvertimeStr)},
  148.         &NormalClock,
  149. };

  150. #define MENU_LCD_CONTRAST_ITEM_ID                MENU_MENU_OVERTIME_ITEM_ID + 0u
  151. static const char menuLcdContrastStr[] = {
  152.         'L',
  153.         'C',
  154.         'D',
  155.         MENU_ZH_CODE_START, 64,
  156.         MENU_ZH_CODE_START, 65,
  157.         MENU_ZH_CODE_START, 66
  158. };
  159. const stMenuItem MenuLcdContrast = {
  160.         0u,
  161.         MENU_LCD_CONTRAST_ITEM_ID,
  162.         {menuLcdContrastStr, sizeof(menuLcdContrastStr)},
  163.         &NormalClock,
  164. };

  165. const stMenuItem *menuSystemSetListGroup[] = {
  166.         &MenuBackLightTime,
  167.         &MenuOvertime,
  168.         &MenuLcdContrast,
  169. };
  170. const stMenuList MenuSystemSetList = {
  171.         sizeof(menuSystemSetListGroup) / sizeof(stMenuItem *),
  172.         menuSystemSetInputData,
  173.         &MenuSystemSet.itemName,
  174.         &MenuSystemSet,
  175.         &MenuSetList,
  176.         menuSystemSetListGroup,
  177. };
复制代码

  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

  7. #define HOME_ICON_ID_TYPE        INT8U

  8. struct ST_MENU_ITEM;
  9. struct ST_MENU_ITEM_STR;
  10. struct ST_MENU_LIST;

  11. typedef struct ST_MENU_ITEM_STR{
  12.         const char *pstr;
  13.         INT8U len;
  14. }stMenuItemStr;

  15. typedef struct ST_MENU_LIST {
  16.         INT8U itemNum;
  17.         INT8U *pdata;
  18.         const stMenuItemStr *pname;
  19.         const struct ST_MENU_ITEM *pparentItem;
  20.         const struct ST_MENU_LIST *pparentItemList;
  21.         const struct ST_MENU_ITEM **pItem;
  22. }stMenuList;

  23. typedef struct ST_MENU_ITEM {
  24.         INT8U subItemNum;
  25.         INT8U thisItemID;
  26.         stMenuItemStr itemName;
  27.         const void *pData;
  28. }stMenuItem;

  29. typedef struct {
  30.         const HOME_ICON_ID_TYPE iconID;
  31.         const stMenuItemStr str;
  32.         const struct ST_STATE_INFO *pstate;
  33.         INT32U data;
  34. }stHomeIcon;

  35. extern const stMenuList MenuSetList;
  36. extern const stMenuList MenuSystemSetList;
  37. extern const stMenuList *pMenuListEntry;

  38. extern const stHomeIcon *HomeIcon[];
  39. extern const INT8U HomeIconTotalNum;
  40. #endif /* MENU_H_ */
复制代码

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

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

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

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

  138.         x = 64;
  139.         LCD_PutZH16x16(x, 2, lunaCalendarData.tianGan + 20, 1);
  140.         x += 16;
  141.         LCD_PutZH16x16(x, 2, lunaCalendarData.diZhi + 30, 1);
  142. }

  143. static void __NormalClock_TimeAction(void)
  144. {
  145.         INT8U err, x = 0;
  146.         INT8U h = 0;
  147.         INT8U m = 0;
  148.         INT8U s = 0;
  149.         INT8U d = 0;
  150.         INT8U month = 0;
  151.         INT8U date = 0;
  152.         INT8U year = 0;

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

  176.                                 break;
  177.                         case NORMAL_CLOCK_DATEUPDATE:
  178.                                 x = 0;
  179.                                 LCD_PutSmallChar(x, 3, '2', 1);
  180.                                 x += 6;
  181.                                 LCD_PutSmallChar(x, 3, '0', 1);
  182.                                 x += 6;
  183.                                 LCD_PutSmallChar(x, 3, '0' + ((year >> 4) & 0x0f), 1);
  184.                                 x += 6;
  185.                                 LCD_PutSmallChar(x, 3, '0' + (year & 0x0f), 1);

  186.                                 x += 12;
  187.                                 LCD_PutSmallChar(x, 3, '0' + ((month >> 4) & 0x0f), 1);
  188.                                 x += 6;
  189.                                 LCD_PutSmallChar(x, 3, '0' + (month & 0x0f), 1);

  190.                                 x += 12;
  191.                                 LCD_PutSmallChar(x, 3, '0' + ((date >> 4) & 0x0f), 1);
  192.                                 x += 6;
  193.                                 LCD_PutSmallChar(x, 3, '0' + (date & 0x0f), 1);

  194.                                 if(d == 7)
  195.                                         LCD_PutZH16x16(96, 0, 0, 1);
  196.                                 else
  197.                                         LCD_PutZH16x16(96, 0, d, 1);

  198.                                 solaCalendarToLunarCalendar(
  199.                                                                                         ((year >> 4) & 0x0f) * 10 +
  200.                                                                                                 (year & 0x0f) + 2000,
  201.                                                                                         ((month >> 4) & 0x0f) * 10 +
  202.                                                                                                 (month & 0x0f),
  203.                                                                                         ((date >> 4) & 0x0f) * 10 +
  204.                                                                                                 (date & 0x0f)
  205.                                                                                         );
  206.                                 __lunarCalendarDisplay();

  207.                                 break;

  208.                         case NORMAL_CLOCK_INIT:
  209.                                 LCD_Clear(0);

  210.                                 LCD_PutSmallChar(24, 3, '/', 1);
  211.                                 LCD_PutSmallChar(42, 3, '/', 1);

  212.                                 LCD_PutZH16x16(64, 0, 12, 1);
  213.                                 LCD_PutZH16x16(80, 0, 13, 1);
  214.                                 LCD_PutZH16x16(96, 2, 20, 1);

  215.                                 LCD_PutBmp(48, 6, BMP_BUTTON_ID_HOME, 1);
  216.                                 LCD_PutBmp(48, 7, BMP_BUTTON_ID_LAMP, 1);

  217.                                 DS1337_Getc(RTC_HOUR, &h);
  218.                                 DS1337_Getc(RTC_MIN, &m);
  219.                                 DS1337_Getc(RTC_SEC, &s);

  220.                                 DS1337_Getc(RTC_MONTH, &month);
  221.                                 DS1337_Getc(RTC_DATE, &date);
  222.                                 DS1337_Getc(RTC_YEAR, &year);

  223.                                 DS1337_Getc(RTC_DAY, &d);

  224.                                 if((h < 6) || (h > 18))
  225.                                 {
  226.                                         LCD_PutBmp(0, 4, BMP_PIC_ID_NIGHT, 1);
  227.                                 }
  228.                                 else if((h >= 6) && (h < 10))
  229.                                 {
  230.                                         LCD_PutBmp(0, 4, BMP_PIC_ID_MORNING, 1);
  231.                                 }
  232.                                 else if((h >= 10) && (h < 14))
  233.                                 {
  234.                                         LCD_PutBmp(0, 4, BMP_PIC_ID_NOON, 1);
  235.                                 }
  236.                                 else
  237.                                 {
  238.                                         LCD_PutBmp(0, 4, BMP_PIC_ID_AFTERNOON, 1);
  239.                                 }
  240.                                 pStateMsg = &stateMsg[1];
  241.                                 pStateMsg->cmd = NORMAL_CLOCK_TIMEUPDATE;
  242.                                 OSQPost(pStateQ, (void *)pStateMsg);

  243.                                 pStateMsg = &stateMsg[2];
  244.                                 pStateMsg->cmd = NORMAL_CLOCK_DATEUPDATE;
  245.                                 OSQPost(pStateQ, (void *)pStateMsg);
  246.                                 break;
  247.                         case NORMAL_CLOCK_PICUPDATE:
  248.                                 LCD_PutBmp(0, 4, (INT8U)(INT32U)pStateMsg->pData, 1);
  249.                                 break;
  250.                         case STATE_EXIT:
  251.                                 return;
  252.                         default:
  253.                                 break;
  254.                         }
  255.                         break;
  256.                 case OS_ERR_TIMEOUT:
  257.                         {
  258.                                 INT8U tmpSec = s, tmpDate = date, tmpHour = h;
  259.                                 DS1337_Getc(RTC_HOUR,  &h);
  260.                                 DS1337_Getc(RTC_MIN,   &m);
  261.                                 DS1337_Getc(RTC_SEC,   &s);

  262.                                 DS1337_Getc(RTC_MONTH,  &month);
  263.                                 DS1337_Getc(RTC_DATE,   &date);
  264.                                 DS1337_Getc(RTC_YEAR,   &year);
  265.                                 if(s != tmpSec)
  266.                                 {
  267.                                         pStateMsg = &stateMsg[1];
  268.                                         pStateMsg->cmd = NORMAL_CLOCK_TIMEUPDATE;
  269.                                         OSQPost(pStateQ, (void *)pStateMsg);
  270.                                 }

  271.                                 if(date != tmpDate)
  272.                                 {
  273.                                         pStateMsg = &stateMsg[2];
  274.                                         pStateMsg->cmd = NORMAL_CLOCK_DATEUPDATE;
  275.                                         OSQPost(pStateQ, (void *)pStateMsg);
  276.                                 }

  277.                                 if((tmpHour != h) &&
  278.                                    ((h == 0x06) || (h == 0x10) || (h == 0x14) || (h == 0x18))
  279.                                    )
  280.                                 {
  281.                                         pStateMsg = &stateMsg[3];
  282.                                         pStateMsg->cmd = NORMAL_CLOCK_PICUPDATE;
  283.                                         switch(h)
  284.                                         {
  285.                                         case 0x06:
  286.                                                 pStateMsg->pData = (void *)BMP_PIC_ID_MORNING;
  287.                                                 break;
  288.                                         case 0x10:
  289.                                                 pStateMsg->pData = (void *)BMP_PIC_ID_NOON;
  290.                                                 break;
  291.                                         case 0x14:
  292.                                                 pStateMsg->pData = (void *)BMP_PIC_ID_AFTERNOON;
  293.                                                 break;
  294.                                         case 0x18:
  295.                                                 pStateMsg->pData = (void *)BMP_PIC_ID_NIGHT;
  296.                                                 break;
  297.                                         default:
  298.                                                 pStateMsg->pData = (void *)BMP_PIC_ID_MORNING;
  299.                                                 break;
  300.                                         }
  301.                                         OSQPost(pStateQ, (void *)pStateMsg);
  302.                                 }
  303.                         }
  304.                         break;
  305.                 default:
  306.                         OSTimeDly(10);
  307.                         break;
  308.                 }
  309.         }
  310. }

  311. static void __NormalClock_EventProcess(void *ptr)
  312. {
  313.         INT8U err, exitFlag = 1u;
  314.         stMSG *pmsg;
  315.         stStateMsg *pStateMsg = &stateMsg[0];
  316.         while(exitFlag)
  317.         {
  318.                 pmsg = (stMSG *)OSMboxPend(pMsgEvent, 0, &err);
  319.                 switch(pmsg->keyValue)
  320.                 {
  321.                 case KEY_VAL_LEFT:
  322.                         break;
  323.                 case KEY_VAL_RIGHT:
  324.                         break;
  325.                 case KEY_VAL_UP:
  326.                         pState = &Home;
  327.                         ((INT8U *)pState->pdata)[0] = 1;
  328.                         ((INT8U *)pState->pdata)[1] = 1;
  329.                         pStateMsg->cmd = STATE_EXIT;
  330.                         OSQPost(pStateQ, (void *)pStateMsg);
  331.                         return;
  332.                 case KEY_VAL_DOWN | KEY_VAL_LONG:
  333.                 case KEY_VAL_DOWN:
  334.                         FLASH_POWER? FLASH_POWER_OFF : FLASH_POWER_ON;
  335.                         break;
  336.                 default:
  337.                         __defaultEventProcess(&exitFlag, pmsg, ptr);
  338.                         break;
  339.                 }
  340.         }
  341. }

  342. void State_NormalClock(void *ptr)
  343. {
  344.         stStateMsg *pStateMsg = &stateMsg[0];
  345.         pTimeAction = __NormalClock_TimeAction;
  346.         pStateMsg->cmd = NORMAL_CLOCK_INIT;
  347.         OSQPost(pStateQ, (void *)pStateMsg);

  348.         __NormalClock_EventProcess(ptr);
  349. }
  350. //Home
  351. static void __Home_TimeAction(void)
  352. {
  353.         INT8U err, x = 0;
  354.         INT8U h = 0;
  355.         INT8U m = 0;
  356.         INT8U s = 0;
  357.         stStateMsg *pStateMsg;
  358.         INT8U iconIndex, dspIndex;
  359.         INT8U dspMaxIndex = HomeIconTotalNum > 4 ? 4 : HomeIconTotalNum;
  360.         while(1)
  361.         {
  362.                 pStateMsg = (stStateMsg *)OSQPend(pStateQ, 10, &err);
  363.                 switch(err)
  364.                 {
  365.                 case OS_ERR_NONE:
  366.                         switch(pStateMsg->cmd)
  367.                         {
  368.                         case HOME_INIT:
  369.                                 LCD_Clear(0);
  370.                                 LCD_PutBmp(0, 6, BMP_BUTTON_ID_ENTER, 1);
  371.                                 LCD_PutBmp(48, 6, BMP_BUTTON_ID_UP, 1);
  372.                                 LCD_PutBmp(48, 7, BMP_BUTTON_ID_DOWN, 1);
  373.                                 LCD_PutBmp(96, 6, BMP_BUTTON_ID_BACK, 1);

  374.                                 DS1337_Getc(RTC_HOUR,  &h);
  375.                                 DS1337_Getc(RTC_MIN,   &m);
  376.                                 DS1337_Getc(RTC_SEC,   &s);
  377.                                 dspIndex = ((INT8U *)pStateMsg->pData)[0];
  378.                                 iconIndex = ((INT8U *)pStateMsg->pData)[1];

  379.                                 pStateMsg = &stateMsg[1];
  380.                                 pStateMsg->cmd = HOME_ICONUPDATE;
  381.                                 pStateMsg->pData = (void *)&iconIndex;
  382.                                 OSQPost(pStateQ, (void *)pStateMsg);

  383.                                 pStateMsg = &stateMsg[2];
  384.                                 pStateMsg->cmd = HOME_TIMEUPDATE;
  385.                                 OSQPost(pStateQ, (void *)pStateMsg);

  386.                                 break;
  387.                         case HOME_ICONMOVELEFT:
  388.                                 iconIndex = (*(INT8U *)pStateMsg->pData);
  389.                                 if(iconIndex == HomeIconTotalNum)
  390.                                         dspIndex = dspMaxIndex;
  391.                                 else if(dspIndex > 1)
  392.                                         dspIndex--;
  393.                                 pStateMsg = &stateMsg[1];
  394.                                 pStateMsg->cmd = HOME_ICONUPDATE;
  395.                                 pStateMsg->pData = (void *)&iconIndex;
  396.                                 OSQPost(pStateQ, (void *)pStateMsg);
  397.                                 break;
  398.                         case HOME_ICONMOVERIGHT:
  399.                                 iconIndex = (*(INT8U *)pStateMsg->pData);
  400.                                 if(iconIndex == 1)
  401.                                         dspIndex = 1;
  402.                                 else if(dspIndex < dspMaxIndex)
  403.                                         dspIndex++;
  404.                                 pStateMsg = &stateMsg[1];
  405.                                 pStateMsg->cmd = HOME_ICONUPDATE;
  406.                                 pStateMsg->pData = (void *)&iconIndex;
  407.                                 OSQPost(pStateQ, (void *)pStateMsg);
  408.                                 break;
  409.                         case HOME_ICONUPDATE:
  410.                                 {
  411.                                         INT8U i, j;
  412.                                         LCD_PutMenuStr(0, 64, 0, &HomeIcon[iconIndex - 1]->str, 1);
  413.                                         i = iconIndex - dspIndex;
  414.                                         x = 0;
  415.                                         for(j = 1; j < dspMaxIndex + 1; j++)
  416.                                         {
  417.                                                 if(j == dspIndex)
  418.                                                         LCD_PutBmp(x, 2, HomeIcon[i]->iconID, 0);
  419.                                                 else
  420.                                                         LCD_PutBmp(x, 2, HomeIcon[i]->iconID, 1);
  421.                                                 i++;
  422.                                                 x += 32;
  423.                                         }
  424.                                 }
  425.                                 break;
  426.                         case HOME_TIMEUPDATE:
  427.                                 {
  428.                                         char strBuf[6], *str = strBuf;
  429.                                         *str = '0' + (h >> 4), str++;
  430.                                         *str = '0' + (h &0x0f), str++;
  431.                                         if(s % 2)
  432.                                                 *str = ':', str++;
  433.                                         else
  434.                                                 *str = ' ', str++;
  435.                                         *str = '0' + (m >> 4), str++;
  436.                                         *str = '0' + (m & 0x0f), str++;
  437.                                         *str = 0;
  438.                                         LCD_PutMiddleString(88, 0, strBuf, 1);
  439.                                 }
  440.                                 break;
  441.                         case STATE_EXIT:
  442.                                 ((INT8U *)Home.pdata)[0] = dspIndex;
  443.                                 return;
  444.                         default:
  445.                                 break;
  446.                         }
  447.                 case OS_ERR_TIMEOUT:
  448.                         {
  449.                                 INT8U tmpSec = s;
  450.                                 DS1337_Getc(RTC_HOUR,  &h);
  451.                                 DS1337_Getc(RTC_MIN,   &m);
  452.                                 DS1337_Getc(RTC_SEC,   &s);
  453.                                 if(s != tmpSec)
  454.                                 {
  455.                                         pStateMsg = &stateMsg[2];
  456.                                         pStateMsg->cmd = HOME_TIMEUPDATE;
  457.                                         OSQPost(pStateQ, (void *)pStateMsg);
  458.                                 }
  459.                         }
  460.                         break;
  461.                 default:
  462.                         OSTimeDly(10);
  463.                         break;
  464.                 }
  465.         }
  466. }
  467. static void __Home_EventProcess(void *ptr)
  468. {
  469.         INT8U err, exitFlag = 1u;
  470.         stMSG *pmsg;
  471.         stStateMsg *pStateMsg = &stateMsg[0];
  472.         INT8U iconIndex;
  473.         stStateInfo *pthisState = (stStateInfo *)ptr;

  474.         pTimeAction = __Home_TimeAction;
  475.         pStateMsg->cmd = HOME_INIT;
  476.         pStateMsg->pData = pthisState->pdata;
  477.         iconIndex = ((INT8U *)pthisState->pdata)[1];
  478.         OSQPost(pStateQ, (void *)pStateMsg);

  479.         while(exitFlag)
  480.         {
  481.                 pmsg = (stMSG *)OSMboxPend(pMsgEvent,
  482.                                                                    CONFIG_MENU_TIME_OUT * 100u,
  483.                                                                    &err);
  484.                 switch(err)
  485.                 {
  486.                 case OS_ERR_NONE:
  487.                         switch(pmsg->keyValue)
  488.                         {
  489.                         case KEY_VAL_LEFT:
  490.                                 if(iconIndex)
  491.                                 {
  492.                                         pState = HomeIcon[iconIndex - 1]->pstate;
  493.                                         pStateMsg->cmd = STATE_EXIT;
  494.                                         if(pState == &Menu)
  495.                                         {
  496.                                                 pMenuListEntry =
  497.                                                         (const stMenuList *)HomeIcon[iconIndex - 1]->data;
  498.                                                 ((INT8U *)pMenuListEntry->pdata)[0] = 1;
  499.                                                 ((INT8U *)pMenuListEntry->pdata)[1] = 1;
  500.                                         }
  501.                                         OSQPost(pStateQ, (void *)pStateMsg);
  502.                                         ((INT8U *)Home.pdata)[1] = iconIndex;
  503.                                         return;
  504.                                 }
  505.                                 else
  506.                                         break;
  507.                         case KEY_VAL_RIGHT:
  508.                                 pState = &NormalClock;
  509.                                 pStateMsg->cmd = STATE_EXIT;
  510.                                 OSQPost(pStateQ, (void *)pStateMsg);
  511.                                 return;
  512.                         case KEY_VAL_UP | KEY_VAL_LONG:
  513.                         case KEY_VAL_UP:
  514.                                 if(iconIndex <= 1)
  515.                                         iconIndex = HomeIconTotalNum;
  516.                                 else
  517.                                         iconIndex --;
  518.                                 pStateMsg->cmd = HOME_ICONMOVELEFT;
  519.                                 pStateMsg->pData = (void *)&iconIndex;
  520.                                 OSQPost(pStateQ, (void *)pStateMsg);
  521.                                 break;
  522.                         case KEY_VAL_DOWN | KEY_VAL_LONG:
  523.                         case KEY_VAL_DOWN:
  524.                                 iconIndex++;
  525.                                 if(iconIndex > HomeIconTotalNum)
  526.                                         iconIndex = 1;
  527.                                 pStateMsg->cmd = HOME_ICONMOVERIGHT;
  528.                                 pStateMsg->pData = (void *)&iconIndex;
  529.                                 OSQPost(pStateQ, (void *)pStateMsg);
  530.                                 break;
  531.                         default:
  532.                                 __defaultEventProcess(&exitFlag, pmsg, ptr);
  533.                                 break;
  534.                         }
  535.                         break;
  536.                 case OS_ERR_TIMEOUT:
  537.                         pState = &NormalClock;
  538.                         pStateMsg->cmd = STATE_EXIT;
  539.                         OSQPost(pStateQ, (void *)pStateMsg);
  540.                         return;
  541.                 default:
  542.                         OSTimeDly(10);
  543.                         break;
  544.                 }
  545.         }
  546. }

  547. void State_Home(void *ptr)
  548. {
  549.         __Home_EventProcess(ptr);
  550. }

  551. //Power off
  552. static void __PowerOff_TimeAction(void)
  553. {
  554.         INT8U err, x, count, sec;
  555.         stStateMsg *pStateMsg;
  556.         while(1)
  557.         {
  558.                 pStateMsg = (stStateMsg *)OSQPend(pStateQ, 50, &err);
  559.                 switch(err)
  560.                 {
  561.                 case OS_ERR_NONE:
  562.                         switch(pStateMsg->cmd)
  563.                         {
  564.                         case POWER_OFF_INIT:
  565.                                 LCD_Clear(0);
  566.                                 LED_ON;
  567.                                 x = 32;
  568.                                 LCD_PutZH16x16(x, 2, 53, 1), x += 16;
  569.                                 LCD_PutZH16x16(x, 2, 54, 1), x += 16;
  570.                                 LCD_PutZH16x16(x, 2, 55, 1), x += 16;
  571.                                 LCD_PutSmallString(x, 3, "...", 1);
  572.                                 sec = CONFIG_POWER_OFF_KEEP_TIME;
  573.                                 count = sec << 1;
  574.                                 pStateMsg = &stateMsg[1];
  575.                                 pStateMsg->cmd = POWER_OFF_TIMESECUPDATE;
  576.                                 OSQPost(pStateQ, (void *)pStateMsg);
  577.                                 break;
  578.                         case POWER_OFF_TIMESECUPDATE:
  579.                                 x = 56;
  580.                                 LCD_PutMiddleChar(x, 4, '0' + sec / 10, 0);
  581.                                 x += 8;
  582.                                 LCD_PutMiddleChar(x, 4, '0' + sec % 10, 0);
  583.                                 break;
  584.                         case STATE_EXIT:
  585.                                 LED_OFF;
  586.                                 return;
  587.                         default:
  588.                                 break;
  589.                         }
  590.                         break;
  591.                 case OS_ERR_TIMEOUT:
  592.                         if(count == 1)
  593.                         {
  594.                                 DIGITAL_POWER_OFF;
  595.                                 while(IO2PIN_bit.P2_25)
  596.                                 {
  597.                                         OSTimeDly(10);
  598.                                 }
  599.                         }
  600.                         else
  601.                         {
  602.                                 count--;
  603.                                 sec = count >> 1;
  604.                                 LED_POWER? LED_OFF : LED_ON;
  605.                                 pStateMsg = &stateMsg[2];
  606.                                 pStateMsg->cmd = POWER_OFF_TIMESECUPDATE;
  607.                                 OSQPost(pStateQ, (void *)pStateMsg);
  608.                         }
  609.                         break;
  610.                 default:
  611.                         OSTimeDly(10);
  612.                         break;
  613.                 }
  614.         }
  615. }
  616. static void __PowerOff_EventProcess(void *ptr)
  617. {
  618.         INT8U err;
  619.         stMSG *pmsg;
  620.         stStateMsg *pStateMsg = &stateMsg[0];
  621.         stStateInfo *plastState = (stStateInfo *)ptr;
  622.         plastState = (stStateInfo *)(*(INT32U *)plastState->pdata);
  623.         while(1)
  624.         {
  625.                 pmsg = (stMSG *)OSMboxPend(pMsgEvent, 51, &err);
  626.                 switch(err)
  627.                 {
  628.                 case OS_ERR_NONE:
  629.                         {
  630.                                 switch(pmsg->keyValue)
  631.                                 {
  632.                                 case KEY_VAL_UP | KEY_VAL_LONG:

  633.                                         break;
  634.                                 default:
  635.                                         goto POWEROFF_EXIT;
  636.                                         break;
  637.                                 }
  638.                         }
  639.                         break;
  640.                 case OS_ERR_TIMEOUT:
  641.                         {
  642. POWEROFF_EXIT:        if(plastState)
  643.                                 {
  644.                                         pState = plastState;
  645.                                 }
  646.                                 else
  647.                                 {
  648.                                         pState = &Home;//&NormalClock;
  649.                                 }
  650.                                 pStateMsg->cmd = STATE_EXIT;
  651.                                 OSQPost(pStateQ, (void *)pStateMsg);
  652.                                 return;
  653.                         }
  654.                         break;
  655.                 default:
  656.                         OSTimeDly(10);
  657.                         break;
  658.                 }
  659.         }
  660. }
  661. void State_PowerOff(void *ptr)
  662. {
  663.         stStateMsg *pStateMsg = &stateMsg[0];
  664.         pTimeAction = __PowerOff_TimeAction;
  665.         pStateMsg->cmd = POWER_OFF_INIT;
  666.         OSQPost(pStateQ, (void *)pStateMsg);

  667.         __PowerOff_EventProcess(ptr);
  668. }
  669. //Menu
  670. static void __Menu_TimeAction(void)
  671. {
  672.         INT8U err, y;
  673.         INT8U h = 0;
  674.         INT8U m = 0;
  675.         INT8U s = 0;
  676.         stStateMsg *pStateMsg;
  677.         const stMenuList *pthisMenuList = NULL;
  678.         const stMenuItem *pMenuItem;
  679.         INT8U itemIndex = 1, dspIndex = 1;
  680.         INT8U dspMaxIndex;
  681.         while(1)
  682.         {
  683.                 pStateMsg = (stStateMsg *)OSQPend(pStateQ, 50, &err);
  684.                 switch(err)
  685.                 {
  686.                 case OS_ERR_NONE:
  687.                         switch(pStateMsg->cmd)
  688.                         {
  689.                         case MENU_INIT:
  690.                                 LCD_Clear(0);
  691.                                 LCD_PutBmp(0, 6, BMP_BUTTON_ID_ENTER, 1);
  692.                                 LCD_PutBmp(48, 6, BMP_BUTTON_ID_UP, 1);
  693.                                 LCD_PutBmp(48, 7, BMP_BUTTON_ID_DOWN, 1);
  694.                                 LCD_PutBmp(96, 6, BMP_BUTTON_ID_BACK, 1);

  695.                                 DS1337_Getc(RTC_HOUR,  &h);
  696.                                 DS1337_Getc(RTC_MIN,   &m);
  697.                                 DS1337_Getc(RTC_SEC,   &s);

  698.                                 stateMsg[1].pData = pStateMsg->pData;
  699.                                 pStateMsg = &stateMsg[1];
  700.                                 pStateMsg->cmd = MENU_LISTUPDATE;
  701.                                 OSQPost(pStateQ, (void *)pStateMsg);


  702.                                 pStateMsg = &stateMsg[2];
  703.                                 pStateMsg->cmd = MENU_ITEMUPDATE;
  704.                                 OSQPost(pStateQ, (void *)pStateMsg);

  705.                                 pStateMsg = &stateMsg[3];
  706.                                 pStateMsg->cmd = MENU_TIMEUPDATE;
  707.                                 OSQPost(pStateQ, (void *)pStateMsg);

  708.                         case MENU_TIMEUPDATE:
  709.                                 {
  710.                                         char strBuf[6], *str = strBuf;
  711.                                         *str = '0' + (h >> 4), str++;
  712.                                         *str = '0' + (h &0x0f), str++;
  713.                                         if(s % 2)
  714.                                                 *str = ':', str++;
  715.                                         else
  716.                                                 *str = ' ', str++;
  717.                                         *str = '0' + (m >> 4), str++;
  718.                                         *str = '0' + (m & 0x0f), str++;
  719.                                         *str = 0;
  720.                                         LCD_PutMiddleString(88, 0, strBuf, 1);
  721.                                 }
  722.                                 break;
  723.                         case MENU_ITEMMOVEUP:

  724.                                 itemIndex = (*(INT8U *)pStateMsg->pData);
  725.                                 if(itemIndex == pthisMenuList->itemNum)
  726.                                         dspIndex = dspMaxIndex;
  727.                                 else if(dspIndex > 1)
  728.                                         dspIndex--;

  729.                                 pStateMsg = &stateMsg[2];
  730.                                 pStateMsg->cmd = MENU_ITEMUPDATE;
  731.                                 pStateMsg->pData = (void *)&itemIndex;
  732.                                 OSQPost(pStateQ, (void *)pStateMsg);
  733.                                 break;
  734.                         case MENU_ITEMMOVEDOWN:

  735.                                 itemIndex = (*(INT8U *)pStateMsg->pData);
  736.                                 if(itemIndex == 1)
  737.                                         dspIndex = 1;
  738.                                 else if(dspIndex < dspMaxIndex)
  739.                                         dspIndex++;

  740.                                 pStateMsg = &stateMsg[2];
  741.                                 pStateMsg->cmd = MENU_ITEMUPDATE;
  742.                                 pStateMsg->pData = (void *)&itemIndex;
  743.                                 OSQPost(pStateQ, (void *)pStateMsg);
  744.                                 break;
  745.                         case MENU_ITEMUPDATE:
  746.                                 {
  747.                                         INT8U i, j;
  748.                                         LCD_PutMenuStr(0, 64, 0, pthisMenuList->pname, 1);
  749.                                         i = itemIndex - dspIndex;
  750.                                         y = 2;
  751.                                         for(j = 1; j < dspMaxIndex + 1; j++)
  752.                                         {
  753.                                                 pMenuItem = pthisMenuList->pItem[i];
  754.                                                 if(j == dspIndex)
  755.                                                         LCD_PutMenuStr(0, 128, y, &pMenuItem->itemName, 0);
  756.                                                 else
  757.                                                         LCD_PutMenuStr(0, 128, y, &pMenuItem->itemName, 1);
  758.                                                 i++;
  759.                                                 y += 2;
  760.                                         }
  761.                                 }
  762.                                 break;
  763.                         case MENU_LISTUPDATE:
  764.                                 if(pthisMenuList)
  765.                                         ((INT8U *)pthisMenuList->pdata)[0] = dspIndex;

  766.                                 pthisMenuList=
  767.                                         (const stMenuList *)(*(INT32U *)pStateMsg->pData);
  768.                                 itemIndex = ((INT8U *)pthisMenuList->pdata)[1];
  769.                                 dspMaxIndex =
  770.                                         pthisMenuList->itemNum > 2 ? 2 : pthisMenuList->itemNum;
  771.                                 dspIndex = ((INT8U *)pthisMenuList->pdata)[0];

  772.                                 break;
  773.                         case STATE_EXIT:
  774.                                 ((INT8U *)pthisMenuList->pdata)[0] = dspIndex;
  775.                                 return;
  776.                         default:
  777.                                 break;
  778.                         }
  779.                 case OS_ERR_TIMEOUT:
  780.                         {
  781.                                 INT8U tmpSec = s;
  782.                                 DS1337_Getc(RTC_HOUR,  &h);
  783.                                 DS1337_Getc(RTC_MIN,   &m);
  784.                                 DS1337_Getc(RTC_SEC,   &s);
  785.                                 if(s != tmpSec)
  786.                                 {
  787.                                         pStateMsg = &stateMsg[3];
  788.                                         pStateMsg->cmd = MENU_TIMEUPDATE;
  789.                                         OSQPost(pStateQ, (void *)pStateMsg);
  790.                                 }
  791.                         }
  792.                         break;
  793.                 default:
  794.                         OSTimeDly(10);
  795.                         break;
  796.                 }
  797.         }
  798. }

  799. static void __Menu_EventProcess(void *ptr)
  800. {
  801.         INT8U err, exitFlag = 1u;
  802.         INT8U itemIndex;
  803.         stMSG *pmsg;
  804.         stStateMsg *pStateMsg = &stateMsg[0];
  805.         stStateInfo *pthisState = (stStateInfo *)ptr;
  806.         const stMenuList *pthisMenuList;
  807.         const stMenuItem *pMenuItem;

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

  809.         itemIndex = ((INT8U *)pthisMenuList->pdata)[1];
  810.         pTimeAction = __Menu_TimeAction;
  811.         pStateMsg->cmd = MENU_INIT;
  812.         pStateMsg->pData = (void *)&pthisMenuList;
  813.         OSQPost(pStateQ, (void *)pStateMsg);

  814.         while(exitFlag)
  815.         {
  816.                 pmsg = (stMSG *)OSMboxPend(pMsgEvent,
  817.                                                                    CONFIG_MENU_TIME_OUT * 100u,
  818.                                                                    &err);
  819.                 switch(err)
  820.                 {
  821.                 case OS_ERR_NONE:
  822.                         {
  823.                                 switch(pmsg->keyValue)
  824.                                 {
  825.                                 case KEY_VAL_LEFT:
  826.                                         if(pthisMenuList->pItem[itemIndex - 1]->subItemNum)
  827.                                         {
  828.                                                 ((INT8U *)pthisMenuList->pdata)[1] = itemIndex;
  829.                                                 pMenuItem = pthisMenuList->pItem[itemIndex - 1];
  830.                                                 pthisMenuList = (const stMenuList *)(pMenuItem->pData);
  831.                                                 itemIndex = 1;
  832.                                                 ((INT8U *)pthisMenuList->pdata)[0] = 1;
  833.                                                 ((INT8U *)pthisMenuList->pdata)[1] = 1;

  834.                                                 pStateMsg = &stateMsg[0];
  835.                                                 pStateMsg->cmd = MENU_LISTUPDATE;
  836.                                                 pStateMsg->pData = (void *)&pthisMenuList;
  837.                                                 OSQPost(pStateQ, (void *)pStateMsg);

  838.                                                 pStateMsg = &stateMsg[2];
  839.                                                 pStateMsg->cmd = MENU_ITEMUPDATE;
  840.                                                 OSQPost(pStateQ, (void *)pStateMsg);

  841.                                                 break;
  842.                                         }
  843.                                         else
  844.                                         {
  845.                                                 pMenuItem = pthisMenuList->pItem[itemIndex - 1];
  846.                                                 pState = (const stStateInfo *)(pMenuItem->pData);

  847.                                                 pStateMsg = &stateMsg[0];
  848.                                                 pStateMsg->cmd = STATE_EXIT;
  849.                                                 OSQPost(pStateQ, (void *)pStateMsg);
  850.                                                 ((INT8U *)pthisMenuList->pdata)[1] = itemIndex;
  851.                                                 return;
  852.                                         }
  853.                                 case KEY_VAL_RIGHT:
  854.                                         if(pthisMenuList->pparentItemList)
  855.                                         {
  856.                                                 itemIndex = pthisMenuList->pparentItem->thisItemID + 1;
  857.                                                 pthisMenuList = pthisMenuList->pparentItemList;

  858.                                                 pStateMsg = &stateMsg[0];
  859.                                                 pStateMsg->cmd = MENU_LISTUPDATE;
  860.                                                 pStateMsg->pData = (void *)&pthisMenuList;
  861.                                                 OSQPost(pStateQ, (void *)pStateMsg);

  862.                                                 pStateMsg = &stateMsg[2];
  863.                                                 pStateMsg->cmd = MENU_ITEMUPDATE;
  864.                                                 OSQPost(pStateQ, (void *)pStateMsg);
  865.                                                 break;
  866.                                         }
  867.                                         else
  868.                                         {
  869.                                                 pState = &Home;

  870.                                                 ((INT8U *)pthisMenuList->pdata)[0] = 1;
  871.                                                 ((INT8U *)pthisMenuList->pdata)[1] = 1;

  872.                                                 pStateMsg = &stateMsg[0];
  873.                                                 pStateMsg->cmd = STATE_EXIT;
  874.                                                 OSQPost(pStateQ, (void *)pStateMsg);
  875.                                                 return;
  876.                                         }
  877.                                 case KEY_VAL_UP | KEY_VAL_LONG:
  878.                                 case KEY_VAL_UP:
  879.                                         if(itemIndex <= 1)
  880.                                                 itemIndex = pthisMenuList->itemNum;
  881.                                         else
  882.                                                 itemIndex--;

  883.                                         pStateMsg = &stateMsg[0];
  884.                                         pStateMsg->cmd = MENU_ITEMMOVEUP;
  885.                                         pStateMsg->pData = (void *)&itemIndex;
  886.                                         OSQPost(pStateQ, (void *)pStateMsg);
  887.                                         break;
  888.                                 case KEY_VAL_DOWN | KEY_VAL_LONG:
  889.                                 case KEY_VAL_DOWN:
  890.                                         itemIndex++;
  891.                                         if(itemIndex > pthisMenuList->itemNum)
  892.                                                 itemIndex = 1;

  893.                                         pStateMsg = &stateMsg[0];
  894.                                         pStateMsg->cmd = MENU_ITEMMOVEDOWN;
  895.                                         pStateMsg->pData = (void *)&itemIndex;
  896.                                         OSQPost(pStateQ, (void *)pStateMsg);
  897.                                         break;
  898.                                 default:
  899.                                         __defaultEventProcess(&exitFlag, pmsg, ptr);
  900.                                         break;
  901.                                 }
  902.                         }
  903.                         break;
  904.                 case OS_ERR_TIMEOUT:
  905.                         pState = &NormalClock;

  906.                         pStateMsg = &stateMsg[0];
  907.                         pStateMsg->cmd = STATE_EXIT;
  908.                         OSQPost(pStateQ, (void *)pStateMsg);
  909.                         return;
  910.                 default:
  911.                         OSTimeDly(10);
  912.                         break;
  913.                 }
  914.         }
  915. }
  916. void State_Menu(void *ptr)
  917. {
  918.         __Menu_EventProcess(ptr);
  919. }

  920. //Set date
  921. static void __SetDate_TimeAction(void)
  922. {
  923.         INT8U err;
  924.         stStateMsg *pStateMsg;
  925.         while(1)
  926.         {
  927.                 pStateMsg = (stStateMsg *)OSQPend(pStateQ, 0, &err);
  928.                 switch(err)
  929.                 {
  930.                 case OS_ERR_NONE:
  931.                         switch(pStateMsg->cmd)
  932.                         {
  933.                         case SETDATE_INIT:
  934.                                 LCD_Clear(0);
  935.                                 LCD_PutBmp(0, 6, BMP_BUTTON_ID_ENTER, 1);
  936.                                 LCD_PutBmp(48, 6, BMP_BUTTON_ID_UP, 1);
  937.                                 LCD_PutBmp(48, 7, BMP_BUTTON_ID_DOWN, 1);
  938.                                 LCD_PutBmp(96, 6, BMP_BUTTON_ID_BACK, 1);
  939.                                 break;
  940.                         case STATE_EXIT:
  941.                                 return;
  942.                         default:
  943.                                 break;
  944.                         }
  945.                         break;
  946.                 case OS_ERR_TIMEOUT:
  947.                 default:
  948.                         OSTimeDly(10);
  949.                         break;
  950.                 }
  951.         }
  952. }
  953. static void __SetDate_EventProcess(void *ptr)
  954. {
  955.         INT8U err, exitFlag = 1u;
  956.         stMSG *pmsg;
  957.         stStateMsg *pStateMsg = &stateMsg[0];
  958.         while(exitFlag)
  959.         {
  960.                 pmsg = (stMSG *)OSMboxPend(pMsgEvent,
  961.                                                                    CONFIG_MENU_TIME_OUT * 100u,
  962.                                                                    &err);
  963.                 switch(err)
  964.                 {
  965.                 case OS_ERR_NONE:
  966.                         {
  967.                                 switch(pmsg->keyValue)
  968.                                 {
  969.                                 case KEY_VAL_LEFT:
  970.                                         break;
  971.                                 case KEY_VAL_RIGHT:
  972.                                         *(INT32U *)pState->stateMask = (INT32U)pState->pdata;
  973.                                         pState = &Menu;
  974.                                         pStateMsg = &stateMsg[0];
  975.                                         pStateMsg->cmd = STATE_EXIT;
  976.                                         OSQPost(pStateQ, (void *)pStateMsg);
  977.                                         return;
  978.                                 case KEY_VAL_UP | KEY_VAL_LONG:
  979.                                 case KEY_VAL_UP:
  980.                                         break;
  981.                                 case KEY_VAL_DOWN | KEY_VAL_LONG:
  982.                                 case KEY_VAL_DOWN:
  983.                                         break;
  984.                                 default:
  985.                                         __defaultEventProcess(&exitFlag, pmsg, ptr);
  986.                                         break;
  987.                                 }
  988.                         }
  989.                         break;
  990.                 case OS_ERR_TIMEOUT:
  991.                         pState = &NormalClock;

  992.                         pStateMsg = &stateMsg[0];
  993.                         pStateMsg->cmd = STATE_EXIT;
  994.                         OSQPost(pStateQ, (void *)pStateMsg);
  995.                         return;
  996.                 default:
  997.                         OSTimeDly(10);
  998.                         break;
  999.                 }
  1000.         }
  1001. }
  1002. void State_SetDate(void *ptr)
  1003. {
  1004.         stStateMsg *pStateMsg = &stateMsg[0];
  1005.         pTimeAction = __SetDate_TimeAction;
  1006.         pStateMsg->cmd = SETDATE_INIT;
  1007.         OSQPost(pStateQ, (void *)pStateMsg);

  1008.         __SetDate_EventProcess(ptr);
  1009. }
  1010. //Common function
  1011. static void __defaultEventProcess(INT8U *pexitFlag, stMSG *pmsg, void *ptr)
  1012. {
  1013.         stStateMsg *pStateMsg = &stateMsg[0];
  1014.         switch(pmsg->keyValue)
  1015.         {
  1016.                 case KEY_VAL_UP | KEY_VAL_LONG:
  1017.                         *pexitFlag = 0;
  1018.                         *(INT32U *)PowerOff.pdata = (INT32U)ptr;
  1019.                         pState = &PowerOff;
  1020.                         pStateMsg->cmd = STATE_EXIT;
  1021.                         OSQPost(pStateQ, (void *)pStateMsg);
  1022.                         break;
  1023.         }
  1024. }
  1025. void State_RunMachine(void)
  1026. {
  1027.         pState->pfun((void *)pState);
  1028. }

  1029. void State_TimeAction(void)
  1030. {
  1031.         pTimeAction();
  1032. }
复制代码

  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;

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

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

  18. #define POWER_OFF_INIT                        0u
  19. #define POWER_OFF_TIMESECUPDATE        1u

  20. #define MENU_INIT                                0u
  21. #define MENU_ITEMUPDATE                        1u
  22. #define MENU_ITEMMOVEUP                        2u
  23. #define MENU_ITEMMOVEDOWN                3u
  24. #define MENU_TIMEUPDATE                        4u
  25. #define MENU_LISTUPDATE                        5u

  26. #define SETDATE_INIT                        0u

  27. #define STATE_EXIT                                10u
  28. #define STATE_MSG_SIZE                        5u

  29. typedef void (* tStateFun)(void *ptr);
  30. #define STATE_FUN tStateFun

  31. typedef struct {
  32.         INT8U cmd;
  33.         void *pData;
  34. }stStateMsg;

  35. typedef struct ST_STATE_INFO{
  36.         INT32U stateMask;
  37.         STATE_FUN pfun;
  38.         void *pdata;
  39. }stStateInfo;

  40. extern OS_EVENT *pStateQ;
  41. extern void *StateMsg[STATE_MSG_SIZE];
  42. extern const stStateInfo *pState;

  43. extern const stStateInfo NormalClock;
  44. extern const stStateInfo Home;
  45. extern const stStateInfo PowerOff;
  46. extern const stStateInfo Menu;

  47. extern const stStateInfo SetDate;

  48. extern void State_RunMachine(void);
  49. extern void State_TimeAction(void);
  50. #endif /* STATE_H_ */
复制代码



积分规则
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

Archiver|手机版|小黑屋|EDABOSS电子论坛

GMT+8, 2024-3-29 18:52 , Processed in 0.043620 second(s), 23 queries .

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表