设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › ARM7/9/11 Cortex-A/R › MiniARM2300电脑自动打铃器设计与实现ucos操作系统
返回列表 发新帖
查看: 3701|回复: 0
打印 上一主题 下一主题
收起左侧

MiniARM2300电脑自动打铃器设计与实现ucos操作系统

[复制链接]
跳转到指定楼层
楼主
ID:140253 发表于 2018-3-12 19:06 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
采用ucos，有详细的说明，经典的ucos操作系统实例详解


单片机源程序如下:
  1. /****************************************Copyright (c)****************************************************
  2. **                            Guangzhou ZHIYUAN electronics Co.,LTD.
  3. **                                      
  4. **
  5. **--------------File Info---------------------------------------------------------------------------------
  6. ** File name:           main.c
  7. ** Last modified Date:  2007-09-01
  8. ** Last Version:        1.0
  9. ** Descriptions:        The main() function example template
  10. **
  11. **--------------------------------------------------------------------------------------------------------
  12. ** Created by:          Zhenghongtao
  13. ** Created date:        2007-09-01
  14. ** Version:             1.0
  15. ** Descriptions:        The original version
  16. **
  17. **--------------------------------------------------------------------------------------------------------
  18. ** Modified by:
  19. ** Modified date:
  20. ** Version:
  21. ** Descriptions:
  22. **
  23. *********************************************************************************************************/
  24. #include "config.h"                                                     /*  系统头文件                  */
  25. #include "i2c.h"

  27. #define TASKKEY_ID              12                                      /*  定义键盘任务的ID            */
  28. #define TASKKEY_PRIO            TASKKEY_ID                              /*  定义键盘任务的优先级        */
  29. #define TASKKEY_STACK_SIZE      512                                     /*  定义键盘任务堆栈大小        */

  31. #define TASKDISP_ID             13                                      /*  定义显示任务的ID            */
  32. #define TASKDISP_PRIO           TASKDISP_ID                             /*  定义显示任务的优先级        */
  33. #define TASKDISP_STACK_SIZE     512                                     /*  定义显示任务堆栈大小        */

  35. #define TASKCTRL_ID             6                                       /*  定义控制任务的ID            */
  36. #define TASKCTRL_PRIO           TASKCTRL_ID                             /*  定义控制任务的优先级        */
  37. #define TASKCTRL_STACK_SIZE     512                                     /*  定义控制任务堆栈大小        */

  39. OS_STK        TaskKeyStk[TASKKEY_STACK_SIZE];                                 /*  定义键盘任务的堆栈          */
  40. OS_STK        TaskDispStk[TASKDISP_STACK_SIZE];                               /*  定义显示任务的堆栈          */
  41. OS_STK        TaskCtrlStk[TASKCTRL_STACK_SIZE];                               /*  定义控制任务的堆栈          */


  44. void TaskKey(void *pdata);                                              /*  TaskKey  键盘任务           */
  45. void TaskDisp(void *pdata);                                             /*  TaskDisp 显示任务           */
  46. void TaskCtrl(void *pdata);                                             /*  TaskCtrl 控制任务           */

  48. void ToDispBuf(void);
  49. void FromDispBuf(void);
  50. void GetTime(void);
  51. void SetTime(void);
  52. void RTC_Exception(void);

  54. OS_EVENT       *GmboxRingCtrl;

  56. unsigned int    GuiMode   = 0;                                          /*  模式                        */
  57. unsigned int    GuiCursor = 8;                                          /*  光标                        */
  58. unsigned int    GuiIndex  = 0;                                          /*  索引                        */
  59. unsigned int    GuiItem   = 0;                                          /*  条目                        */

  61. /*********************************************************************************************************
  62.   时钟结构定义
  63. *********************************************************************************************************/
  64. struct time {
  65.     unsigned char       ucHour;                                         /*  时                          */
  66.     unsigned char       ucMin;                                          /*  分                          */
  67.     unsigned char       ucSec;                                          /*  秒                          */
  68.     unsigned char       ucWeek;                                         /*  星期                        */
  69.     unsigned short      usYear;                                         /*  年                          */
  70.     unsigned char       ucMon;                                          /*  月                          */
  71.     unsigned char       ucDay;                                          /*  日                          */
  72. };
  73. typedef struct time     TIME;
  74. typedef TIME           *PTIME;
  75. /*********************************************************************************************************
  76.   闹钟结构定义
  77. *********************************************************************************************************/
  78. struct alarm {
  79.     unsigned char       ucHour;                                         /*  时                          */
  80.     unsigned char       ucMin;                                          /*  分                          */
  81.     unsigned char       ucSec;                                          /*  秒                          */
  82.     unsigned char       ucEnable;                                       /*  闹钟使能控制                */
  83.     struct {
  84.         unsigned short  usLevel;                                        /*  输出电平控制                */
  85.         unsigned short  usTime;                                         /*  输出时间控制                */
  86.     } c[4];                                                             /*  4路输出控制                 */
  87. };
  88. typedef struct alarm    ALARM;
  89. typedef ALARM          *PALARM;

  91. #define MAX_ALARM 4                                                     /*  最大闹钟个数                */

  93. unsigned char       GucTimeDispBuf[2][8];                               /*  时钟显示缓冲区              */
  94. unsigned char       GucAlarmDispBuf[MAX_ALARM][6][8];                   /*  闹钟显示缓冲区              */

  96. TIME                GtimeCurrentTime;                                   /*  当前时间                    */
  97. ALARM               GalarmRingTime[MAX_ALARM];                          /*  闹钟时间                    */

  99. #define LED0    (1u<<18)
  100. #define LED1    (1u<<19)
  101. #define LED2    (1u<<20)
  102. #define LED3    (1u<<21)

  104. /*********************************************************************************************************
  105.   时钟模式下，下一个光标索引表
  106. *********************************************************************************************************/
  107. const unsigned char GucTimeNextCursor[2][9] = {
  108.     {7,0,1,2,3,4,7,5,7},
  109.     {5,0,1,2,3,4,5,5,5}
  110. };
  111. /*********************************************************************************************************
  112.   时钟模式下，上一个光标索引表
  113. *********************************************************************************************************/
  114. const unsigned char GucTimePreCursor[2][9] = {
  115.     {1,2,3,4,5,7,7,0,7},
  116.     {1,2,3,4,5,0,5,5,5}
  117. };
  118. /*********************************************************************************************************
  119.   时钟模式下，最大值限定表
  120. *********************************************************************************************************/
  121. const unsigned char GucTimeMaxTable[2][8] = {
  122.     {0x09,0x05,0x09,0x05,0x09,0x02,0x1f,0x06},
  123.     {0x09,0x03,0x09,0x01,0x09,0x09,0x1f,0x1f}
  124. };
  125. /*********************************************************************************************************
  126.   闹钟模式下，下一个光标索引表
  127. *********************************************************************************************************/
  128. const unsigned char GucAlarmNextCursor[6][9] = {
  129.     {5,0,1,2,3,4,5,5,5},
  130.     {7,0,1,2,3,4,5,6,7},
  131.     {4,0,1,2,3,4,4,4,4},
  132.     {4,0,1,2,3,4,4,4,4},
  133.     {4,0,1,2,3,4,4,4,4},
  134.     {4,0,1,2,3,4,4,4,4}
  135. };
  136. /*********************************************************************************************************
  137.   闹钟模式下，上一个光标索引表
  138. *********************************************************************************************************/
  139. const unsigned char GucAlarmPreCursor[6][9] = {
  140.     {1,2,3,4,5,0,5,5,5},
  141.     {1,2,3,4,5,6,7,0,7},
  142.     {1,2,3,4,0,4,4,4,4},
  143.     {1,2,3,4,0,4,4,4,4},
  144.     {1,2,3,4,0,4,4,4,4},
  145.     {1,2,3,4,0,4,4,4,4}
  146. };
  147. /*********************************************************************************************************
  148.   闹钟模式下，最大值限定表
  149. *********************************************************************************************************/
  150. const unsigned char GucAlarmMaxTable[6][8] = {
  151.     {0x09,0x05,0x09,0x05,0x09,0x02,0x1f,0x1f},
  152.     {0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01},
  153.     {0x09,0x09,0x09,0x09,0x01,0x1f,0x1f,0x1f},
  154.     {0x09,0x09,0x09,0x09,0x01,0x1f,0x1f,0x1f},
  155.     {0x09,0x09,0x09,0x09,0x01,0x1f,0x1f,0x1f},
  156.     {0x09,0x09,0x09,0x09,0x01,0x1f,0x1f,0x1f}
  157. };

  159. /*********************************************************************************************************
  160. ** Function name:           main
  161. **
  162. ** Descriptions:            主函数
  163. **
  164. ** input parameters:
  165. ** output parameters:
  166. **
  167. ** Returned value           
  168. **
  169. **
  170. ** Created by:
  171. ** Created Date:
  172. **--------------------------------------------------------------------------------------------------------
  173. ** Modified by:
  174. ** Modified date:
  175. **--------------------------------------------------------------------------------------------------------
  176. *********************************************************************************************************/
  177. int main(void)
  178. {
  179.     OSInit();                                                           /*  初始化uC/OS-II              */
  180.     OSTaskCreateExt(TaskKey,
  181.                     (void *)0,
  182.                     &TaskKeyStk[TASKKEY_STACK_SIZE - 1],
  183.                     TASKKEY_PRIO,
  184.                     TASKKEY_ID,
  185.                     &TaskKeyStk[0],
  186.                     TASKKEY_STACK_SIZE,
  187.                     (void *)0,
  188.                     OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);
  189.                                                                         /*  创建键盘任务                */
  190.     OSStart();                                                          /*  启动多任务操作系统          */
  191.     return  (0);
  192. }
  193. /*********************************************************************************************************
  194. ** Function name:           ZLG7290GetKey
  195. **
  196. ** Descriptions:            zlg7290读取键值
  197. **
  198. ** input parameters:
  199. ** output parameters:
  200. **
  201. ** Returned value           
  202. **
  203. **
  204. ** Created by:
  205. ** Created Date:
  206. **--------------------------------------------------------------------------------------------------------
  207. ** Modified by:
  208. ** Modified date:
  209. **--------------------------------------------------------------------------------------------------------
  210. *********************************************************************************************************/
  211. uint16 ZLG7290GetKey(void)
  212. {
  213.     uint8 temp[2];
  214.    
  215.     i2cRead( 0,                                                         /*  I2C0                        */
  216.              0x70,                                                      /*  器件地址                    */
  217.              temp,                                                      /*  接收数据的缓冲区            */
  218.              1,                                                         /*  器件子地址                  */
  219.              1,                                                         /*  器件子地址类型为单字节型    */
  220.              2);                                                        /*  读取数据的长度              */
  221.     while (i2cGetFlag(0) == I2C_BUSY);                                  /*  等待I2C操作完毕             */
  222.     return (uint16)(temp[0] + (temp[1] * 256));
  223. }
  224. /*********************************************************************************************************
  225. ** Function name:           ZLG7290ShowChar
  226. **
  227. ** Descriptions:            zlg7290显示数值
  228. **
  229. ** input parameters:
  230. ** output parameters:
  231. **
  232. ** Returned value           
  233. **
  234. **
  235. ** Created by:
  236. ** Created Date:
  237. **--------------------------------------------------------------------------------------------------------
  238. ** Modified by:
  239. ** Modified date:
  240. **--------------------------------------------------------------------------------------------------------
  241. *********************************************************************************************************/
  242. void ZLG7290ShowChar(uint8 index, uint8 data)
  243. {
  244.     uint8 buf[2];
  245.    
  246.     buf[0] = (uint8)(0x60 | (index & 0x0f));
  247.     buf[1] = data;
  248.     i2cWrite(0,                                                         /*  I2C0                        */
  249.              0x70,                                                      /*  器件地址                    */
  250.              buf,                                                       /*  要写入数据的缓冲区          */
  251.              0x07,                                                      /*  器件子地址                  */
  252.              1,                                                         /*  器件子地址类型为单字节型    */
  253.              2);                                                        /*  写入的数量                  */
  254.     while (i2cGetFlag(0) == I2C_BUSY);                                  /*  等待I2C操作完毕             */
  255. }
  256. /*********************************************************************************************************
  257. ** Function name:           rtcInit
  258. **
  259. ** Descriptions:            RTC初始化
  260. **
  261. ** input parameters:
  262. ** output parameters:
  263. **
  264. ** Returned value           
  265. **
  266. **
  267. ** Created by:
  268. ** Created Date:
  269. **--------------------------------------------------------------------------------------------------------
  270. ** Modified by:
  271. ** Modified date:
  272. **--------------------------------------------------------------------------------------------------------
  273. *********************************************************************************************************/
  274. void rtcInit(void)
  275. {
  276.     if(ALYEAR != 2007) {                                                /*  初始化一次                  */
  277.         CCR     = 0x00;                                                 /*  禁止时间计数器              */
  278.         PREINT  = Fpclk/32768-1;                                        /*  设置基准时钟分频器          */
  279.         PREFRAC = Fpclk%32768;
  280.         CISS    = 0;                                                    /*  禁止次秒级中断              */
  281.         AMR     = 0xFF;                                                 /*  禁止报警中断                */
  282.         CIIR    = 0x01;                                                 /*  使能秒增量中断              */
  283.         ILR     = 0x07;                                                 /*  清除RTC中断标志             */
  284.         ALYEAR  = 2007;                                                 /*  初始化标志                  */
  285.         
  286.         YEAR    = 2007;                                                 /*  初始化时间寄存器            */
  287.         MONTH   = 11;
  288.         DOM     = 5;
  289.         DOW     = 0;
  290.         HOUR    = 12;
  291.         MIN     = 0;
  292.         SEC     = 0;
  293.         CCR     = 0x11;
  294.     }
  295.     GetTime();                                                          /*  更新当前时间                */
  296. }
  297. /*********************************************************************************************************
  298. ** Function name:           TaskKey
  299. **
  300. ** Descriptions:            键盘任务
  301. **
  302. ** input parameters:
  303. ** output parameters:
  304. **
  305. ** Returned value           
  306. **
  307. **
  308. ** Created by:
  309. ** Created Date:
  310. **--------------------------------------------------------------------------------------------------------
  311. ** Modified by:
  312. ** Modified date:
  313. **--------------------------------------------------------------------------------------------------------
  314. *********************************************************************************************************/
  315. void TaskKey(void *pdata)
  316. {
  317.     unsigned char   ucKey;
  318.     unsigned char   ucKey0;
  319.     unsigned char   ucFlag = 0;                                         /*  修改状态标志                */
  320.    
  321.     pdata = pdata;                                                      /*  防止编译器警告              */
  322.    
  323.     TargetInit();
  324.     OSTimeDly(OS_TICKS_PER_SEC/10);                                     /*  上电延时，等待zlg7290复位   */
  325.    
  326.     PINSEL1 = (PINSEL1 & ~(0xff << 22))|(  0x05 << 22 );                /*  设置I2C管脚功能             */
  327.     i2cInit(0, "Speed=30000", NULL);                                    /*  初始化I2C0                  */
  328.     SetVICIRQ(9, 2, (int)i2c0IRQ);                                      /*  设置了IRQ中断               */
  329.    
  330.     GmboxRingCtrl = OSMboxCreate((void *)0);                            /*  创建消息邮箱                */
  331.     rtcInit();
  332.     SetVICIRQ(13, 3, (int)RTC_Exception);
  333.    
  334.     OSTaskCreateExt (TaskDisp,
  335.                      (void *)0,
  336.                      &TaskDispStk[TASKDISP_STACK_SIZE - 1],
  337.                      TASKDISP_PRIO,
  338.                      TASKDISP_ID,
  339.                      &TaskDispStk[0],
  340.                      TASKDISP_STACK_SIZE,
  341.                      (void *)0,
  342.                      OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);

  344.                                                                         /*  创建显示任务                */
  345.                                                                         
  346.     OSTaskCreateExt (TaskCtrl,
  347.                      (void *)0,
  348.                      &TaskCtrlStk[TASKCTRL_STACK_SIZE - 1],
  349.                      TASKCTRL_PRIO,
  350.                      TASKCTRL_ID,
  351.                      &TaskCtrlStk[0],
  352.                      TASKCTRL_STACK_SIZE,
  353.                      (void *)0,
  354.                      OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);

  356.                                                                         /*  创建输出控制任务            */
  357.    
  358.     while (1) {
  359.         OSTimeDly(4);                                                   /*  延时                        */
  360.         ucKey = (uint8)ZLG7290GetKey();                                 /*  获取键值                    */
  361.         if ((ucKey == 0) || (ucKey > 16)) {                             /*  没有按键                    */
  362.                 continue;
  363.         }
  364.         if (ucKey<11) {                                                 /*  数字键                      */
  365.                 ucKey0 = 0;
  366.         }
  367.         else {                                                          /*  功能键                      */
  368.                 ucKey0 = (uint8)(ucKey % 10);
  369.         }
  370.            
  371.             /*
  372.              *  键值处理
  373.              */
  374.             OS_ENTER_CRITICAL();                                            /*  进入临界区，原子操作        */
  375.         switch (ucKey0) {
  376.         
  377.         case 0:                                                         /*  数字键                      */
  378.             if (ucFlag) {                                               /*  数字键只有在修改状态下有效  */
  379.                 ucKey %= 10;
  380.                 switch (GuiMode) {
  381.                
  382.                 case 0:                                                 /*  时钟模式                    */
  383.                     if (ucKey <= GucTimeMaxTable[GuiItem][GuiCursor]) {
  384.                         GucTimeDispBuf[GuiItem][GuiCursor] = ucKey;
  385.                         GuiCursor = GucTimeNextCursor[GuiItem][GuiCursor];
  386.                         FromDispBuf();
  387.                         SetTime();
  388.                     }
  389.                     break;
  390.                 case 1:                                                 /*  闹钟模式                    */
  391.                     if (ucKey <= GucAlarmMaxTable[GuiItem][GuiCursor]) {
  392.                         GucAlarmDispBuf[GuiIndex][GuiItem][GuiCursor] = ucKey;
  393.                         GuiCursor = GucAlarmNextCursor[GuiItem][GuiCursor];
  394.                         FromDispBuf();
  395.                     }
  396.                     break;
  397.                 default:
  398.                     break;
  399.                 }
  400.                     
  401.             }
  402.             break;
  403.         case 1:                                                         /*  左移动键                    */
  404.             if (ucFlag) {
  405.                 switch (GuiMode) {
  406.                
  407.                 case 0:
  408.                     GuiCursor = GucTimePreCursor[GuiItem][GuiCursor];
  409.                     break;
  410.                 case 1:
  411.                     GuiCursor = GucAlarmPreCursor[GuiItem][GuiCursor];
  412.                     break;
  413.                 default:
  414.                     break;
  415.                 }
  416.             }
  417.             else {
  418.                 switch (GuiMode) {
  419.                
  420.                 case 0:
  421.                     if (GuiItem > 0) {
  422.                         GuiItem--;
  423.                     }
  424.                     else {
  425.                         GuiItem = 1;
  426.                     }
  427.                     break;
  428.                 case 1:
  429.                     if (GuiItem > 0) {
  430.                         GuiItem--;
  431.                     }
  432.                     else {
  433.                         GuiItem = 5;
  434.                     }
  435.                     break;
  436.                 default:
  437.                     break;
  438.                 }
  439.             }
  440.             break;
  441.         case 2:                                                         /*  右移动键                    */
  442.             if (ucFlag) {
  443.                 switch (GuiMode) {
  444.                
  445.                 case 0:
  446.                     GuiCursor = GucTimeNextCursor[GuiItem][GuiCursor];
  447.                     break;
  448.                 case 1:
  449.                     GuiCursor = GucAlarmNextCursor[GuiItem][GuiCursor];
  450.                     break;
  451.                 default:
  452.                     break;
  453.                 }
  454.             }
  455.             else {
  456.                 switch (GuiMode) {
  457.                
  458.                 case 0:
  459.                     GuiItem = (GuiItem+1)%2;
  460.                     break;
  461.                 case 1:
  462.                     GuiItem = (GuiItem+1)%6;
  463.                     break;
  464.                 default:
  465.                     break;
  466.                 }
  467.             }
  468.             break;
  469.         case 3:                                                         /*  上移动键                    */
  470.             if (ucFlag) {
  471.                 switch (GuiMode) {
  472.                
  473.                 case 0:
  474.                     break;
  475.                 case 1:
  476.                     break;
  477.                 default:
  478.                     break;
  479.                 }
  480.             }
  481.             else {
  482.                 switch (GuiMode) {
  483.                
  484.                 case 0:
  485.                     break;
  486.                 case 1:
  487.                     if(GuiIndex > 0 ) {
  488.                         GuiIndex--;
  489.                     }
  490.                     else {
  491.                         GuiIndex = MAX_ALARM-1;
  492.                     }
  493.                     GuiItem = 0;
  494.                     break;
  495.                 default:
  496.                     break;
  497.                 }
  498.             }
  499.             break;
  500.         case 4:                                                         /*  下移动键                    */
  501.             if (ucFlag) {
  502.                 switch (GuiMode) {
  503.                
  504.                 case 0:
  505.                     break;
  506.                 case 1:
  507.                     break;
  508.                 default:
  509.                     break;
  510.                 }
  511.             }
  512.             else {
  513.                 switch (GuiMode) {
  514.                 case 0:
  515.                     break;
  516.                 case 1:
  517.                     GuiIndex = (GuiIndex+1)%MAX_ALARM;
  518.                     GuiItem = 0;
  519.                     break;
  520.                 }
  521.             }
  522.             break;
  523.         case 5:                                                         /*  模式切换键                  */
  524.             if (!ucFlag) {
  525.                 GuiMode = (GuiMode+1)%2;
  526.                 GuiIndex = 0;
  527.                 GuiItem = 0;
  528.             }
  529.             break;
  530.         case 6:                                                         /*  确定键                      */
  531.             ucFlag = (uint8)(!ucFlag);
  532.             if (ucFlag) {
  533.                 switch (GuiMode) {
  534.                
  535.                 case 0:
  536.                     GuiCursor = GucTimeNextCursor[GuiItem][GuiCursor];
  537.                     break;
  538.                 case 1:
  539.                     GuiCursor = GucAlarmNextCursor[GuiItem][GuiCursor];
  540.                     break;
  541.                 default:
  542.                     break;
  543.                 }
  544.             }
  545.             else {
  546.                 GuiCursor = 8;
  547.             }
  548.             break;
  549.         default:
  550.             break;
  551.         }
  552.         OS_EXIT_CRITICAL();                                             /*  退出临界区                  */
  553.         
  554.         while (1) {                                                     /*  等待按键释放                */
  555.             OSTimeDly(4);                                               /*  延时                        */
  556.             ucKey = (uint8)ZLG7290GetKey();                             /*  获取键值                    */
  557.             if ((ucKey == 0) || (ucKey > 16)) {                         /*  按键释放                    */
  558.                 break;
  559.             }
  560.         }
  561.     }
  562. }
  563.    
  564. /*********************************************************************************************************
  565. ** Function name:           TaskDisp
  566. **
  567. ** Descriptions:            显示任务
  568. **
  569. ** input parameters:
  570. ** output parameters:
  571. **
  572. ** Returned value           
  573. **
  574. **
  575. ** Created by:
  576. ** Created Date:
  577. **--------------------------------------------------------------------------------------------------------
  578. ** Modified by:
  579. ** Modified date:
  580. **--------------------------------------------------------------------------------------------------------
  581. *********************************************************************************************************/
  582. void TaskDisp(void *pdata)
  583. {
  584.     uint8 i;
  585.    
  586.     pdata = pdata;
  587.    
  588.     while (1) {
  589. /*显示任务周期性的输出全局变量的信息（时钟和闹钟），100ms是一个经验值，
  590. 用户会觉得比较舒服，不会产生“系统死机”的感觉。  */  
  591.         OSTimeDly(20);                                                  /*  延时                        */
  592.         
  593.         OS_ENTER_CRITICAL();
  594.         ToDispBuf();                                                    /*  刷新显示缓冲区              */
  595.         OS_EXIT_CRITICAL();
  596.         
  597.         switch (GuiMode) {                                              /*  显示信息                    */
  598.         
  599.         case 0:                                                         /*  时钟模式                    */
  600.             for (i=0; i<8; i++) {
  601.                 ZLG7290ShowChar(i, (uint8)(((i==GuiCursor) ?
  602.                                 0x40 : 0x00) | GucTimeDispBuf[GuiItem][i]));
  603.                 OSTimeDly(1);
  604.             }
  605.             break;
  606.         case 1:                                                         /*  闹钟模式                    */
  607.             for (i=0; i<8; i++) {
  608.                 ZLG7290ShowChar(i, (uint8)(((i==GuiCursor) ?
  609.                                 0x40 : 0x00) | GucAlarmDispBuf[GuiIndex][GuiItem][i]));
  610.                 OSTimeDly(1);
  611.             }
  612.             break;
  613.         default:
  614.             break;
  615.         }
  616.     }
  617. }

  619. /*********************************************************************************************************
  620. ** Function name:           TaskCtrl
  621. **
  622. ** Descriptions:            输出控制任务
  623. **
  624. ** input parameters:
  625. ** output parameters:
  626. **
  627. ** Returned value           
  628. **
  629. **
  630. ** Created by:
  631. ** Created Date:
  632. **--------------------------------------------------------------------------------------------------------
  633. ** Modified by:
  634. ** Modified date:
  635. **--------------------------------------------------------------------------------------------------------
  636. *********************************************************************************************************/
  637. void TaskCtrl(void *pdata)
  638. {
  639.     INT8U   ucErr;
  640.     unsigned short  usLevel[4];                                         /*  4路输出电平控制             */
  641.     unsigned short  usTime[4];                                          /*  4路输出时间控制             */
  642.     unsigned short *pusMsg;
  643.     OS_MBOX_DATA mboxdataMsg;                                           /*  查询消息的结构体            */
  644.     int   i;
  645.    
  646.     pdata = pdata;
  647.     IO1DIR |=  (LED0 | LED1 | LED2 | LED3);                             /*  设置IO方向                  */
  648.     IO1SET = (LED0 | LED1 | LED2 |LED3);                                /*  设置IO初值                  */
  649.    
  650.     while (1) {
  651.         pusMsg = (unsigned short *)OSMboxPend(GmboxRingCtrl, 0, &ucErr);/*  获取消息                    */
  652.         for (i=0; i<4; i++) {                                           /*  解释消息                    */
  653.             usLevel[i] = pusMsg[2*i];
  654.             usTime[i]  = pusMsg[2*i+1];
  655.         }
  656.         if (usLevel[0]==0) {                                            /*  设置输出电平                */
  657.             IO1CLR = LED0;
  658.         }
  659.         if (usLevel[1]==0) {
  660.             IO1CLR = LED1;
  661.         }
  662.         if (usLevel[2]==0) {
  663.             IO1CLR = LED2;
  664.         }
  665.         if (usLevel[3]==0) {
  666.             IO1CLR = LED3;
  667.         }
  668.         while (1) {                                                     /*  输出时间循环                */
  669.             OSTimeDly(OS_TICKS_PER_SEC);
  670.             if (usTime[0] != 0) {                                       /*  0路时间                     */
  671.                 if (--usTime[0] == 0) {
  672.                     IO1SET = LED0;
  673.                 }
  674.             }
  675.             if (usTime[1] != 0) {                                       /*  1路时间                     */
  676.                 if (--usTime[1] == 0) {
  677.                     IO1SET = LED1;
  678.                 }
  679.             }
  680.             if (usTime[2] != 0) {                                       /*  2路时间                     */
  681.                 if (--usTime[2] == 0) {
  682.                     IO1SET = LED2;
  683.                 }
  684.             }
  685.             if (usTime[3] != 0) {                                       /*  3路时间                     */
  686.                 if (--usTime[3] == 0) {
  687.                     IO1SET = LED3;
  688.                 }
  689.             }
  690.             if ((usTime[0] == 0) && (usTime[1] == 0) && (usTime[2] == 0) && (usTime[3] == 0)) {
  691.                 break;
  692.             }
  693.             OSMboxQuery(GmboxRingCtrl, &mboxdataMsg);                   /*  查询是否有新的消息          */
  694.             if (mboxdataMsg.OSMsg != (void *)0) {
  695.                 break;
  696.             }
  697.         }
  698.     }
  699. }

  701. /*********************************************************************************************************
  702. ** Function name:           GetTime
  703. **
  704. ** Descriptions:            获取当前时间
  705. **
  706. ** input parameters:
  707. ** output parameters:
  708. **
  709. ** Returned value           
  710. **
  711. **
  712. ** Created by:
  713. ** Created Date:
  714. **--------------------------------------------------------------------------------------------------------
  715. ** Modified by:
  716. ** Modified date:
  717. **--------------------------------------------------------------------------------------------------------
  718. *********************************************************************************************************/
  719. void GetTime(void)
  720. {
  721.     GtimeCurrentTime.ucHour = (uint8)HOUR;
  722.     GtimeCurrentTime.ucMin  = (uint8)MIN;
  723.     GtimeCurrentTime.ucSec  = (uint8)SEC;
  724.     GtimeCurrentTime.usYear = (uint16)YEAR;
  725.     GtimeCurrentTime.ucMon  = (uint8)MONTH;
  726.     GtimeCurrentTime.ucDay  = (uint8)DOM;
  727.     GtimeCurrentTime.ucWeek = (uint8)DOW;
  728. }

  730. /*********************************************************************************************************
  731. ** Function name:           ToDispBuf
  732. **
  733. ** Descriptions:            更新显示缓冲区
  734. **
  735. ** input parameters:
  736. ** output parameters:
  737. **
  738. ** Returned value           
  739. **
  740. **
  741. ** Created by:
  742. ** Created Date:
  743. **--------------------------------------------------------------------------------------------------------
  744. ** Modified by:
  745. ** Modified date:
  746. **--------------------------------------------------------------------------------------------------------
  747. *********************************************************************************************************/
  748. void ToDispBuf(void)
  749. {
  750.     int i, j;
  751.    
  752.     GucTimeDispBuf[0][0] = (uint8)(GtimeCurrentTime.ucSec % 10);        /*  星期，时分秒                */
  753.     GucTimeDispBuf[0][1] = (uint8)(GtimeCurrentTime.ucSec / 10);
  754.     GucTimeDispBuf[0][2] = (uint8)(GtimeCurrentTime.ucMin % 10);
  755.     GucTimeDispBuf[0][3] = (uint8)(GtimeCurrentTime.ucMin / 10);
  756.     GucTimeDispBuf[0][4] = (uint8)(GtimeCurrentTime.ucHour % 10);
  757.     GucTimeDispBuf[0][5] = (uint8)(GtimeCurrentTime.ucHour / 10);
  758.     GucTimeDispBuf[0][6] = 0x1f;
  759.     GucTimeDispBuf[0][7] = GtimeCurrentTime.ucWeek;
  760.    
  761.     GucTimeDispBuf[1][0] = (uint8)(GtimeCurrentTime.ucDay % 10);        /*  年月日                      */
  762.     GucTimeDispBuf[1][1] = (uint8)(GtimeCurrentTime.ucDay / 10);
  763.     GucTimeDispBuf[1][2] = (uint8)(GtimeCurrentTime.ucMon % 10);
  764.     GucTimeDispBuf[1][3] = (uint8)(GtimeCurrentTime.ucMon / 10);
  765.     GucTimeDispBuf[1][4] = (uint8)(GtimeCurrentTime.usYear % 10);
  766.     GucTimeDispBuf[1][5] = (uint8)(GtimeCurrentTime.usYear % 100 / 10);
  767.     GucTimeDispBuf[1][6] = (uint8)(GtimeCurrentTime.usYear % 1000 / 100);
  768.     GucTimeDispBuf[1][7] = (uint8)(GtimeCurrentTime.usYear / 1000);
  769.    
  770.     for (i=0; i<MAX_ALARM; i++) {
  771.         GucAlarmDispBuf[i][0][0] = (uint8)(GalarmRingTime[i].ucSec % 10);
  772.         GucAlarmDispBuf[i][0][1] = (uint8)(GalarmRingTime[i].ucSec % 100 / 10);
  773.         GucAlarmDispBuf[i][0][2] = (uint8)(GalarmRingTime[i].ucMin % 10);
  774.         GucAlarmDispBuf[i][0][3] = (uint8)(GalarmRingTime[i].ucMin % 100 / 10);
  775.         GucAlarmDispBuf[i][0][4] = (uint8)(GalarmRingTime[i].ucHour % 10);
  776.         GucAlarmDispBuf[i][0][5] = (uint8)(GalarmRingTime[i].ucHour % 100 / 10);
  777.         GucAlarmDispBuf[i][0][6] = (uint8)i;
  778.         GucAlarmDispBuf[i][0][7] = 0x0a;
  779.         
  780.         for (j=0; j<8; j++) {
  781.             GucAlarmDispBuf[i][1][j] = (uint8)((GalarmRingTime[i].ucEnable&(1<<j)) ? 0x0e : 0x0d);
  782.         }
  783.         
  784.         for (j=0; j<4; j++) {
  785.             GucAlarmDispBuf[i][j+2][0] = (uint8)(GalarmRingTime[i].c[j].usTime % 10);
  786.             GucAlarmDispBuf[i][j+2][1] = (uint8)(GalarmRingTime[i].c[j].usTime % 100 / 10);
  787.             GucAlarmDispBuf[i][j+2][2] = (uint8)(GalarmRingTime[i].c[j].usTime % 1000 / 100);
  788.             GucAlarmDispBuf[i][j+2][3] = (uint8)(GalarmRingTime[i].c[j].usTime % 10000 / 1000);
  789.             GucAlarmDispBuf[i][j+2][4] = (uint8)(GalarmRingTime[i].c[j].usLevel ? 0x11 : 0x14);
  790.             GucAlarmDispBuf[i][j+2][5] = 0x1f;
  791.             GucAlarmDispBuf[i][j+2][6] = (uint8)j;
  792.             GucAlarmDispBuf[i][j+2][7] = 0x0c;
  793.         }
  794.     }
  795. }

  797. /*********************************************************************************************************
  798. ** Function name:           FromDispBuf
  799. **
  800. ** Descriptions:            更新当前时间
  801. **
  802. ** input parameters:
  803. ** output parameters:
  804. **
  805. ** Returned value           
  806. **
  807. **
  808. ** Created by:
  809. ** Created Date:
  810. **--------------------------------------------------------------------------------------------------------
  811. ** Modified by:
  812. ** Modified date:
  813. **--------------------------------------------------------------------------------------------------------
  814. *********************************************************************************************************/
  815. void FromDispBuf(void)
  816. {
  817.     int i, j;
  818.    
  819.     GtimeCurrentTime.ucSec  = (uint8)(GucTimeDispBuf[0][1]*10 + GucTimeDispBuf[0][0]);
  820.     GtimeCurrentTime.ucMin  = (uint8)(GucTimeDispBuf[0][3]*10 + GucTimeDispBuf[0][2]);
  821.     GtimeCurrentTime.ucHour = (uint8)(GucTimeDispBuf[0][5]*10 + GucTimeDispBuf[0][4]);
  822.     GtimeCurrentTime.ucWeek = GucTimeDispBuf[0][7];
  823.    
  824.     GtimeCurrentTime.ucDay  = (uint8)(GucTimeDispBuf[1][1]*10 + GucTimeDispBuf[1][0]);
  825.     GtimeCurrentTime.ucMon  = (uint8)(GucTimeDispBuf[1][3]*10 + GucTimeDispBuf[1][2]);
  826.     GtimeCurrentTime.usYear = (uint16)(GucTimeDispBuf[1][7]*1000 + GucTimeDispBuf[1][6]*100
  827.                             + GucTimeDispBuf[1][5]*10 + GucTimeDispBuf[1][4]);
  828.    
  829.     for (i=0; i<MAX_ALARM; i++) {
  830.         GalarmRingTime[i].ucSec = (uint8)(GucAlarmDispBuf[i][0][1]*10 + GucAlarmDispBuf[i][0][0]);
  831.         if (GalarmRingTime[i].ucSec > 59) {
  832.             GalarmRingTime[i].ucSec = 59;
  833.         }
  834.         GalarmRingTime[i].ucMin = (uint8)(GucAlarmDispBuf[i][0][3]*10 + GucAlarmDispBuf[i][0][2]);
  835.         if (GalarmRingTime[i].ucMin > 59) {
  836.             GalarmRingTime[i].ucMin = 59;
  837.         }
  838.         GalarmRingTime[i].ucHour = (uint8)(GucAlarmDispBuf[i][0][5]*10 + GucAlarmDispBuf[i][0][4]);
  839.         if (GalarmRingTime[i].ucHour > 23) {
  840.             GalarmRingTime[i].ucHour = 23;
  841.         }
  842.         
  843.         for (j=0; j<8; j++) {
  844.             if (GucAlarmDispBuf[i][1][j] == 1) {
  845.                 GalarmRingTime[i].ucEnable = (uint8)(GalarmRingTime[i].ucEnable | (1<<j));
  846.             }
  847.             else if (GucAlarmDispBuf[i][1][j] == 0) {
  848.                GalarmRingTime[i].ucEnable = (uint8)(GalarmRingTime[i].ucEnable & (~(1<<j)));
  849.             }
  850.         }
  851.         
  852.         for (j=0; j<4; j++) {
  853.             GalarmRingTime[i].c[j].usTime = (uint16)(GucAlarmDispBuf[i][j+2][3]*1000
  854.                                           + GucAlarmDispBuf[i][j+2][2]*100
  855.                                           + GucAlarmDispBuf[i][j+2][1]*10
  856.                                           + GucAlarmDispBuf[i][j+2][0]);
  857.             if (GucAlarmDispBuf[i][j+2][4] == 1) {
  858.                 GalarmRingTime[i].c[j].usLevel = 1;
  859.             }
  860.             else if (GucAlarmDispBuf[i][j+2][4] == 0) {
  861.                 GalarmRingTime[i].c[j].usLevel = 0;
  862.             }
  863.         }
  864.     }
  865. }

  867. /*********************************************************************************************************
  868. ** Function name:           SetTime
  869. **
  870. ** Descriptions:            设置当前时间
  871. **
  872. ** input parameters:
  873. ** output parameters:
  874. **
  875. ** Returned value           
  876. **
  877. **
  878. ** Created by:
  879. ……………………

  881. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
第四章 电脑自动打铃器设计与实现.rar (305.84 KB, 下载次数: 20)




分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

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