找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 1799|回复: 0
收起左侧

51单片机多任务os源程序

[复制链接]
ID:20672 发表于 2019-11-22 20:53 | 显示全部楼层 |阅读模式
调用系统服务使任务切换时不保存寄存器变量
中断服务执行任务切换时,保存寄存器变量
支持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;                                                        /*当前正在运行的任务*/

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

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

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


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

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

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

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

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

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

  197. /*********************************************
  198. /                        中断子程序发送信号量
  199. /        char lqSendSemISR(unsigned char index)
  200. /        index        :信号量索引
  201. /        返回值:
  202. /        1 -- 有更高优先级的任务就绪,需要执行任务切换
  203. /        0 -- 不需要执行任务切换
  204. /*********************************************/
  205. char lqSendSemISR(unsigned char index)
  206. {
  207.         char j;
  208.         EA=0;
  209.         index*=2;
  210.         if(lqSemData[index+1]){
  211.                 for(j=0;j<lqMaxID;++j){
  212.                         if(lqSemData[index+1] & lqMap[j]){
  213.                                 break;
  214.                         }
  215.                 }
  216.                 lqSemData[index+1] &= ~lqMap[j];
  217.                 lqTaskTimer[j] = 0;
  218.                 lqTaskState[j] &= ~K_SEM;
  219.                 lqTaskState[j] &= ~K_TMO;
  220.                 lqRdyTbl |= lqMap[j];
  221.                 if(j<lqCrt){
  222.                         EA=1;
  223.                         return 1;
  224.                 }
  225.                 EA=1;
  226.                 return 0;
  227.         }
  228.         ++lqSemData[index];
  229.         EA=1;
  230.         return 0;
  231. }

  232. /************************************************
  233. /                        任务发送信号量
  234. /        void lqSendSem(unsinged char index)
  235. /***********************************************/
  236. void lqSendSem(unsigned char index)
  237. {
  238.         if(lqSendSemISR(index)){
  239.                 lqSche();
  240.         }
  241. }
  242. #endif

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

  362. #if        LQ_TASK_TMO_CHK_EN
  363. /***********************************************
  364. /                        任务超时返回检查
  365. /        char lqIsTaskTmo()
  366. /        如果当前任务是超时返回,那么任务状态(lqTaskState)的B_TMO位置位,否则该标志位被清零
  367. /        一般情况下只针对邮箱事件返回后做超时检查
  368. /        返回值:
  369. /        1  --  当前任务是超时返回
  370. /        0  --  当前任务不是超时返回
  371. /************************************************/
  372. char lqIsTaskTmo()
  373. {
  374.         if(lqTaskState[lqCrt] & K_TMO){
  375.                 return 1;
  376.         }
  377.         return 0;
  378. }
  379. #endif
复制代码

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

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励!

查看全部评分

回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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