ucos ii下液晶菜单的设计

最近公司里的废弃电路板比较多就是拿回来自己折腾玩了，
以前大学的时候用51做过数字万年历，但是51那可怜的资源真是设计起来麻烦的要死，现在在ARM7
上搞，简直很随意了。
其实原理也很简单没啥技术含量，纯属娱乐，就当做对ucos ii的学习了。

1. #include "Menu.h"
   
2. //Common
   
3. //extern const stStateInfo NormalClock;
   
4. const stMenuList *pMenuListEntry = NULL;
   
5. 
   
6. //Home
   
7. 
   
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. };
    
58. 
    
59. const stHomeIcon *HomeIcon[] = {
    
60.         &clockIcon,
    
61.     &calendarIcon,
    
62.         &gameIcon,
    
63.         &settingIcon,
    
64.         &systemIcon,
    
65. };
    
66. 
    
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
    
71. 
    
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. };
    
85. 
    
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. };
    
99. 
    
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. };
     
113. 
     
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. };
     
143. 
     
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. };
     
159. 
     
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. };
     
175. 
     
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. };
     
189. 
     
190. 
     
191. 
     
192. 
     
193. 
     

复制代码

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. 
   
8. #define HOME_ICON_ID_TYPE        INT8U
   
9. 
   
10. struct ST_MENU_ITEM;
    
11. struct ST_MENU_ITEM_STR;
    
12. struct ST_MENU_LIST;
    
13. 
    
14. typedef struct ST_MENU_ITEM_STR{
    
15.         const char *pstr;
    
16.         INT8U len;
    
17. }stMenuItemStr;
    
18. 
    
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;
    
27. 
    
28. typedef struct ST_MENU_ITEM {
    
29.         INT8U subItemNum;
    
30.         INT8U thisItemID;
    
31.         stMenuItemStr itemName;
    
32.         const void *pData;
    
33. }stMenuItem;
    
34. 
    
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;
    
41. 
    
42. extern const stMenuList MenuSetList;
    
43. extern const stMenuList MenuSystemSetList;
    
44. extern const stMenuList *pMenuListEntry;
    
45. 
    
46. extern const stHomeIcon *HomeIcon[];
    
47. extern const INT8U HomeIconTotalNum;
    
48. #endif /* MENU_H_ */

复制代码

1. #include "State.h"
   
2. #include "CalendarCalculated.h"
   
3. 
   
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. };
    
19. 
    
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);
    
49. 
    
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.         }
     
141. 
     
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. }
     
147. 
     
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;
     
158. 
     
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);
     
182. 
     
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);
     
193. 
     
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);
     
198. 
     
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);
     
203. 
     
204.                                 if(d == 7)
     
205.                                         LCD_PutZH16x16(96, 0, 0, 1);
     
206.                                 else
     
207.                                         LCD_PutZH16x16(96, 0, d, 1);
     
208. 
     
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();
     
218. 
     
219.                                 break;
     
220. 
     
221.                         case NORMAL_CLOCK_INIT:
     
222.                                 LCD_Clear(0);
     
223. 
     
224.                                 LCD_PutSmallChar(24, 3, '/', 1);
     
225.                                 LCD_PutSmallChar(42, 3, '/', 1);
     
226. 
     
227.                                 LCD_PutZH16x16(64, 0, 12, 1);
     
228.                                 LCD_PutZH16x16(80, 0, 13, 1);
     
229.                                 LCD_PutZH16x16(96, 2, 20, 1);
     
230. 
     
231.                                 LCD_PutBmp(48, 6, BMP_BUTTON_ID_HOME, 1);
     
232.                                 LCD_PutBmp(48, 7, BMP_BUTTON_ID_LAMP, 1);
     
233. 
     
234.                                 DS1337_Getc(RTC_HOUR, &h);
     
235.                                 DS1337_Getc(RTC_MIN, &m);
     
236.                                 DS1337_Getc(RTC_SEC, &s);
     
237. 
     
238.                                 DS1337_Getc(RTC_MONTH, &month);
     
239.                                 DS1337_Getc(RTC_DATE, &date);
     
240.                                 DS1337_Getc(RTC_YEAR, &year);
     
241. 
     
242.                                 DS1337_Getc(RTC_DAY, &d);
     
243. 
     
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);
     
263. 
     
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);
     
283. 
     
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.                                 }
     
293. 
     
294.                                 if(date ！= tmpDate)
     
295.                                 {
     
296.                                         pStateMsg = &stateMsg[2];
     
297.                                         pStateMsg->cmd = NORMAL_CLOCK_DATEUPDATE;
     
298.                                         OSQPost(pStateQ, (void *)pStateMsg);
     
299.                                 }
     
300. 
     
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. }
     
335. 
     
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. }
     
367. 
     
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);
     
374. 
     
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);
     
401. 
     
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];
     
407. 
     
408.                                 pStateMsg = &stateMsg[1];
     
409.                                 pStateMsg->cmd = HOME_ICONUPDATE;
     
410.                                 pStateMsg->pData = (void *)&iconIndex;
     
411.                                 OSQPost(pStateQ, (void *)pStateMsg);
     
412. 
     
413.                                 pStateMsg = &stateMsg[2];
     
414.                                 pStateMsg->cmd = HOME_TIMEUPDATE;
     
415.                                 OSQPost(pStateQ, (void *)pStateMsg);
     
416. 
     
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.                        &nbs