标题: 51单片机多任务os源程序 [打印本页]
作者: wdliming    时间: 2019-11-22 20:53
标题: 51单片机多任务os源程序
调用系统服务使任务切换时不保存寄存器变量
中断服务执行任务切换时，保存寄存器变量
支持7个任务，支持7级中断嵌套
基于优先级调度，0号任务具有最高优先级
包含K_FLG K_SEM K_MSG K_TMO这几个系统服务，每种类型的系统服务最多提供16个

单片机源程序如下:
  1. #define _IN_LQ51_C_
  2. #include "lq51.h"
  3. #include<reg52.h>
  4. /******************************************
  5. /                          定义全局变量
  6. /******************************************/
  7. unsigned char data lqTaskStack[lqMaxID+1];                        /*任务堆栈指针*/
  8. unsigned char data lqSPtemp;                                                /*记录ID号=当前任务ID+1的堆栈底部*/
  9. unsigned char data lqTaskTimer[lqMaxID];                        /*任务定时器*/
  10. unsigned char data lqTaskState[lqMaxID];                        /*任务状态表*/
  11. unsigned char data lqRdyTbl;                                                /*就绪表*/
  12. unsigned char data lqSwitchType;                                        /*任务切换类型，如果通过中断切换任务则在相应位置1，否则置0*/
  13. unsigned char data lqIntNum;                                                /*进入中断服务子程序后系统把中断号传给这个变量*/
  14. unsigned char data lqCrt;                                                        /*当前正在运行的任务*/

  16. #if        LQ_FLG_EN                                /*该事件的最高位表示该标志位是否置位，其他位表示等待该标志量的任务，当标志位置位时，所有等待这个标志的任务都被激活*/
  17. unsigned char data lqFlgData[lqFlgMax]={
  18. 0,0
  19. };
  20. #endif

  22. #if        LQ_SEM_EN                                                        /*信号量数据结构*/
  23.                                                                                 /*一个信号量数据结构包含两个字节，第一个字节为信号量值*/
  24. unsigned char data lqSemData[lqSemMax*2]={                        /*第二个字节为等待这个信号量的任务*/
  25.         0,0,
  26.         0,0};
  27. #endif                                                                                               

  29. #if        LQ_MSG_EN                                                        /*消息邮箱数据结构*/
  30.                                                                                 /*一个消息邮箱数据结构包含两个字节，第一个字节为消息邮箱的消息*/
  31. unsigned char data lqMsgData[lqMsgMax*2]={                /*第二个字节的最高位表示当前邮箱是否有消息0表示没有1表示有，其他为表示等待这个消息的任务*/
  32.         0,0,
  33.         0,0};       
  34. #endif               


  37. const unsigned char code lqMap[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};

  39. /*****************************************
  40. /                        开始函数
  41. /这个函数必须在0号任务的最开始的部分调用
  42. /        void lqStart(void);
  43. /*****************************************/
  44. void lqStart(void)
  45. {
  46.         char i;
  47.         for(i=0;i<lqMaxID;++i){
  48.                 lqTaskTimer[i] = 0;
  49.                 lqTaskState[i] = 0;
  50.         }
  51.         lqRdyTbl=0xFF;
  52.         lqSwitchType=0x00;
  53.         EA = 1;
  54.         lqCrt=0;
  55. }

  57. #if LQ_DELAY_EN
  58. /***************************************************
  59. /                                任务延迟一段时间
  60. /        void lqDelay(unsigned char tmo)
  61. /        tmo:延迟时间，如果tmo=0,那么当前任务休眠，永远不会被激活
  62. /***************************************************/
  63. void lqDelay(unsigned char tmo)
  64. {
  65.         EA=0;
  66.         lqRdyTbl &= ~lqMap[lqCrt];
  67.         lqTaskState[lqCrt] |= K_TMO;
  68.         lqTaskTimer[lqCrt] = tmo;
  69.         EA=1;
  70.         lqSche();
  71. }
  72. #endif

  74. #if        LQ_FLG_EN
  75. /**************************************************
  76. /                        等待标志
  77. /        char lqWaitFlg(unsigned char index,unsigned char tmo)
  78. /        index        :标志量索引
  79. /        tmo                :超时等待时限，如果为0则无限等待
  80. /        返回值：
  81. /        标志量有效返回 K_FLG
  82. /        在规定的时件内标志量未发生返回 K_TMO
  83. /*************************************************/
  84. unsigned char lqWaitFlg(unsigned char index,unsigned char tmo)
  85. {
  86.         EA=0;
  87.         lqTaskState[lqCrt] &= 0xF0;
  88.         lqTaskState[lqCrt]|= index;                /*将当前索引值保存到任务状态的低四位，因为函数是不可重入的*/
  89.         if(lqFlgData[index] & 0x80){        /*标志量置位*/
  90.                 lqFlgData[index] = 0;
  91.                 EA=1;
  92.                 return        K_FLG;
  93.         }
  94.         lqFlgData[index] |= lqMap[lqCrt];
  95.         lqRdyTbl &= ~lqMap[lqCrt];
  96.         lqTaskState[lqCrt] |= K_FLG;
  97.         if(tmo){
  98.                 lqTaskState[lqCrt] |= K_TMO;
  99.                 lqTaskTimer[lqCrt] = tmo;
  100.         }
  101.         EA=1;
  102.         lqSche();
  103.         EA=0;
  104.         index = 0x0F & lqTaskState[lqCrt];
  105.         if(lqTaskState[lqCrt] & K_FLG){                /*等待超时返回*/
  106.                 lqTaskState[lqCrt] &= ~K_FLG;
  107.                 lqTaskState[lqCrt] |= K_TMO;        /*超时标记*/
  108.                 lqFlgData[index] &= ~lqMap[lqCrt];
  109.                 EA=1;
  110.                 return K_TMO;
  111.         }
  112.         EA=1;
  113.         return K_FLG;
  114. }

  116. /************************************************
  117. /                中断服务子程序发送标志
  118. /        char lqSendFlgISR(unsigned char index)
  119. /        index        :标志量索引
  120. /        返回值：
  121. /        1 -- 有更高优先级的任务就绪，需要执行任务切换
  122. /        0 -- 不需要执行任务切换
  123. /************************************************/
  124. char lqSendFlgISR(unsigned char index)
  125. {
  126.         char i,j;
  127.         EA=0;
  128.         if(lqFlgData[index] & 0x7F){                /*有任务在等待这个标志事件*/
  129.                 i=lqMaxID;
  130.                 for(j=0;j<lqMaxID;++j){
  131.                         if(lqFlgData[index] & lqMap[j]){        /*任务等待这个标志事件*/
  132.                                 lqTaskState[j] &= ~K_FLG;
  133.                                 lqTaskState[j] &= ~K_TMO;
  134.                                 lqTaskTimer[j] = 0;
  135.                                 lqRdyTbl |= lqMap[j];
  136.                                 if(j<i){
  137.                                         i=j;
  138.                                 }
  139.                         }
  140.                 }
  141.                 lqFlgData[index] = 0;
  142.                 if(i<lqCrt){
  143.                         EA=1;
  144.                         return 1;
  145.                 }
  146.                 EA=1;
  147.                 return 0;
  148.         }
  149.         lqFlgData[index] = 0x80;
  150.         EA=1;
  151.         return 0;
  152. }
  153. /********************************************
  154. /                任务发送标志事件
  155. /        void lqSendFlg(unsigned char index)
  156. /********************************************/
  157. void lqSendFlg(unsigned char index)
  158. {
  159.         if(lqSendFlgISR(index)){
  160.                 lqSche();
  161.         }
  162. }
  163. #endif

  165. #if        LQ_SEM_EN
  166. /************************************************
  167. /                等待一个信号量
  168. /        char lqWaitSem(unsigned char index,unsigned char tmo)
  169. /        index        :信号量索引
  170. /        tmo                :超时等待时限，如果为0则无限等待
  171. /        返回值：
  172. /        信号量有效返回 K_SEM
  173. /        在规定的时件内信号量未发生返回 K_TMO
  174. /************************************************/
  175. unsigned char lqWaitSem(unsigned char index,unsigned char tmo)
  176. {
  177.         EA=0;
  178.         lqTaskState[lqCrt] &= 0xF0;
  179.         lqTaskState[lqCrt]|= index;                /*因为函数不可重，所以存储信号量索引*/
  180.         index *= 2;
  181.         if(lqSemData[index]){
  182.                 --lqSemData[index];
  183.                 EA=1;
  184.                 return K_SEM;
  185.         }
  186.         lqRdyTbl &= ~lqMap[lqCrt];
  187.         lqSemData[index+1] |= lqMap[lqCrt];
  188.         lqTaskState[lqCrt] |= K_SEM;
  189.         if(tmo){
  190.                 lqTaskState[lqCrt] |= K_TMO;
  191.                 lqTaskTimer[lqCrt] = tmo;
  192.         }
  193.         EA=1;
  194.         lqSche();
  195.         EA=0;
  196.         index = 0x0F & lqTaskState[lqCrt];
  197.         if(lqTaskState[lqCrt] & K_SEM){
  198.                 lqTaskState[lqCrt] &= ~K_SEM;
  199.                 lqTaskState[lqCrt] |= K_TMO;
  200.                 lqSemData[index*2+1] &= ~lqMap[lqCrt];
  201.                 EA=1;
  202.                 return K_TMO;
  203.         }
  204.         EA=1;
  205.         return K_SEM;
  206. }

  208. /*********************************************
  209. /                        中断子程序发送信号量
  210. /        char lqSendSemISR(unsigned char index)
  211. /        index        :信号量索引
  212. /        返回值：
  213. /        1 -- 有更高优先级的任务就绪，需要执行任务切换
  214. /        0 -- 不需要执行任务切换
  215. /*********************************************/
  216. char lqSendSemISR(unsigned char index)
  217. {
  218.         char j;
  219.         EA=0;
  220.         index*=2;
  221.         if(lqSemData[index+1]){
  222.                 for(j=0;j<lqMaxID;++j){
  223.                         if(lqSemData[index+1] & lqMap[j]){
  224.                                 break;
  225.                         }
  226.                 }
  227.                 lqSemData[index+1] &= ~lqMap[j];
  228.                 lqTaskTimer[j] = 0;
  229.                 lqTaskState[j] &= ~K_SEM;
  230.                 lqTaskState[j] &= ~K_TMO;
  231.                 lqRdyTbl |= lqMap[j];
  232.                 if(j<lqCrt){
  233.                         EA=1;
  234.                         return 1;
  235.                 }
  236.                 EA=1;
  237.                 return 0;
  238.         }
  239.         ++lqSemData[index];
  240.         EA=1;
  241.         return 0;
  242. }

  244. /************************************************
  245. /                        任务发送信号量
  246. /        void lqSendSem(unsinged char index)
  247. /***********************************************/
  248. void lqSendSem(unsigned char index)
  249. {
  250.         if(lqSendSemISR(index)){
  251.                 lqSche();
  252.         }
  253. }
  254. #endif

  256. #if        LQ_MSG_EN
  257. /*********************************************
  258. /                        等待消息邮箱
  259. /        unsigned char lqWaitMsg(unsigned char index,unsigned char tmo)
  260. /        index        :邮箱索引
  261. /        tmo                :超时等待时限，如果为0则无限等待
  262. /        邮箱中的值为 0x00~0xFF
  263. /        lqMsgData[2*index+1]的最高为0表示当前没邮件，
  264. /        否则表示当前有邮件
  265. /        返回值        :
  266. /        如果在规定的时间内有消息送到这个邮箱，则返回这个消息
  267. /        如果在规定的时间内没有消息送到这个邮箱，则返回 MSG_TMO
  268. /        MSG_TMO在lq51.h中有定义，如果 MSG_TMO 所代表的值是消息的一部分，
  269. /        那么在这个函数返回后建议执行char lqIsTaskTmo(),检查当前任务
  270. /        是否从超时返回
  271. /********************************************/
  272. unsigned char lqWaitMsg(unsigned char index,unsigned char tmo)
  273. {
  274.         EA=0;
  275.         lqTaskState[lqCrt] &= 0xF0;
  276.         lqTaskState[lqCrt] |= index;
  277.         index *= 2;
  278.         if(lqMsgData[index+1] & 0x80){                /*当前邮箱有邮件*/
  279.                 lqMsgData[index+1] &= 0x7F;
  280.                 EA=1;
  281.                 return lqMsgData[index];
  282.         }
  283.         lqRdyTbl &= ~lqMap[lqCrt];
  284.         lqMsgData[index+1] |= lqMap[lqCrt];
  285.         lqTaskState[lqCrt] |= K_MSG;
  286.         if(tmo){
  287.                 lqTaskState[lqCrt] |= K_TMO;
  288.                 lqTaskTimer[lqCrt] = tmo;
  289.         }
  290.         EA=1;
  291.         lqSche();
  292.         EA=0;
  293.         index = lqTaskState[lqCrt] & 0x0F;
  294.         index *= 2;
  295.         if(lqTaskState[lqCrt] & K_MSG){
  296.                 lqTaskState[lqCrt] &= ~K_MSG;
  297.                 lqTaskState[lqCrt] |= K_TMO;
  298.                 lqMsgData[index] = MSG_TMO;
  299.                 lqMsgData[index+1] &= ~lqMap[lqCrt];
  300.         }
  301.         lqMsgData[index+1] &= 0x7F;
  302.         EA=1;
  303.         return lqMsgData[index];
  304. }
  305. /*******************************************
  306. /        char lqIsMsgEmpty(unsigned char index)
  307. /        index        :邮箱索引
  308. /        返回值:
  309. /        0 -- 邮箱中有消息
  310. /        1 -- 邮箱中没有消息
  311. /******************************************/
  312. #if        LQ_CHK_MSG_EN
  313. char lqIsMsgEmpty(unsigned char index)
  314. {
  315.         EA=0;
  316.         if(lqMsgData[index*2+1] & 0x80){
  317.                 EA=1;
  318.                 return 0;                                /*邮箱不为空，邮箱中有消息*/
  319.         }
  320.         EA=1;
  321.         return 1;                                        /*邮箱为空，邮箱中无消息*/
  322. }
  323. #endif
  324. /*******************************************
  325. /                中断子程序发送邮件
  326. /        char lqSendMsgISR(unsigned char index,unsigned char Msg)
  327. /        index        :邮箱索引
  328. /        Msg                :被发送的消息
  329. /        如果邮箱中已经存在消息，原来的消息不会被覆盖，函数之间返回
  330. /        返回值:
  331. /        1 -- 有更高优先级的任务就绪，需要执行任务切换
  332. /        0 -- 不需要执行任务切换
  333. /*******************************************/
  334. char lqSendMsgISR(unsigned char index,unsigned char Msg)
  335. {
  336.         EA=0;
  337.         index *= 2;
  338.         if(lqMsgData[index+1] & 0x80){
  339.                 EA=1;
  340.                 return 0;                                        /*邮箱不为空*/
  341.         }
  342.         lqMsgData[index] = Msg;
  343.         ++index;
  344.         lqMsgData[index] |= 0x80;
  345.         if(lqMsgData[index] & 0x7F){        /*有任务在等待这个邮件*/
  346.                 for(Msg=0;Msg<lqMaxID;++Msg){
  347.                         if(lqMsgData[index] & lqMap[Msg]){
  348.                                 break;
  349.                         }
  350.                 }
  351.                 lqMsgData[index] &= ~lqMap[Msg];
  352.                 lqTaskState[Msg] &= ~K_MSG;
  353.                 lqRdyTbl |= lqMap[Msg];
  354.                 if(Msg < lqCrt){
  355.                         EA=1;
  356.                         return 1;
  357.                 }
  358.         }
  359.         EA = 1;
  360.         return 0;
  361. }
  362. /********************************************
  363. /                任务发送邮件
  364. /        void lqSendMsg(unsigned char index,unsigned char Msg)
  365. /        index        :邮箱索引
  366. /        Msg                :被发送的消息
  367. /*******************************************/
  368. void lqSendMsg(unsigned char index,unsigned char Msg)
  369. {
  370.         if(lqSendMsgISR(index,Msg)){
  371.                 lqSche();
  372.         }
  373. }
  374. #endif

  376. #if        LQ_TASK_TMO_CHK_EN
  377. /***********************************************
  378. /                        任务超时返回检查
  379. /        char lqIsTaskTmo()
  380. /        如果当前任务是超时返回，那么任务状态(lqTaskState)的B_TMO位置位,否则该标志位被清零
  381. /        一般情况下只针对邮箱事件返回后做超时检查
  382. /        返回值：
  383. /        1  --  当前任务是超时返回
  384. /        0  --  当前任务不是超时返回
  385. /************************************************/
  386. char lqIsTaskTmo()
  387. {
  388.         if(lqTaskState[lqCrt] & K_TMO){
  389.                 return 1;
  390.         }
  391.         return 0;
  392. }
  393. #endif
复制代码

所有资料51hei提供下载:
lq51-master.zip (216.94 KB, 下载次数: 18)






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