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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › STM32/8 › 牛人自制的STM32实时操作系统
返回列表 发新帖
查看: 5000|回复: 6
打印 上一主题 下一主题
收起左侧

牛人自制的STM32实时操作系统

  [复制链接]
跳转到指定楼层
楼主
ID:507431 发表于 2020-4-10 10:30 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
作者
https://bbs.csdn.net/topics/300000723
实现硬件 STM32F10vet6


1，内存使用量统计
硬件系统启动使用：
系统堆栈（系统启动的时候需要使用）        80个字节

操作系统内核使用：
任务表                                    96+16个字节   
                                注：20个字节/任务 * 8（默认任务个数）
                                
信号量                                    32个字节
                                注：4个字节/信号量 * 8（默认信号量个数）

消息队列                                54个字节
                                注: 默认8条消息/队列 * 3 (默认3个消息队列)
                                
空闲任务（Idle）                        96个字节   
                                注：每个任务最少需要96个字节的堆栈，推荐256个字节
                    
RAM使用统计：
一个原始的系统总共占用内存约为400个字节
其中内核占用内存不到300个字节

(注:根据armlink指示，另外还有96个字节的数据用于LIBSPACE.O文件，
这个查明，其实是开发环境在为main主函数初始化的时候用到)


2，代码量(包括ROM里面的只读数据)统计
内核                            1200 个字节
信号量                            300 个字节
消息队列                        500 个字节

ROM使用统计
原始的系统代码小于2K
其中内核代码小于1.2K

单片机源程序如下:
  1. #include "BenOSCore.h"

  3. /*当前OS中所有的任务*/
  4. I8U                        TaskNUM=0;
  5. TCB                        BenOSTCBTable[MAX_TASK_NUM];


  8. /*当前运行的任务*/
  9. TCB                        *BenOSCurTCB;

  11. /*当前准备新运行的任务*/
  12. TCB                 *BenOSNewTCB;

  14. I8U                   BenOSScheLock=0;            /* 0 = enable                 */


  17. /*无聊，所以把堆栈初始化模块用汇编写一遍，但愿性能会高点*/
  18. __asm    STACK_TYPE *BenOSTaskStkInit (void (*task),STACK_TYPE *ptos)
  19. {
  20.                  THUMB
  21.                  PRESERVE8

  23.                  PUSH     {R4-R6,LR}
  24.          MOV      R4,R0

  26.          MOV      R0,R1
  27.          MOV      R5,#0x1000000
  28.          STR      R5,[R0,#0]

  30.          SUBS     R0,R0,#4
  31.          STR      R4,[R0,#0]
  32.          
  33.          MVN      R5,#1
  34.          SUBS     R0,R0,#4
  35.          STR      R5,[R0,#0]
  36.          
  37.          MOV      R5,#0x2
  38.          SUBS     R0,R0,#4
  39.          STR      R5,[R0,#0]
  40.          
  41.          MOV      R5,#0x3
  42.          SUBS     R0,R0,#4
  43.          STR      R5,[R0,#0]
  44.          
  45.          MOV      R5,#0x4
  46.          SUBS     R0,R0,#4
  47.          STR      R5,[R0,#0]

  49.                  ASRS     R5,R5,#1
  50.          SUBS     R0,R0,#4
  51.          STR      R5,[R0,#0]
  52.          
  53.          SUBS     R0,R0,#4
  54.          STR      R1,[R0,#0]
  55.          
  56.          MOV      R5,#0x5
  57.          SUBS     R0,R0,#4
  58.          STR      R5,[R0,#0]

  60.          MOV      R5,#0x6
  61.          SUBS     R6,R0,#4
  62.          MOV      R0,R6
  63.          STR      R5,[R6,#0]
  64.          
  65.          MOV      R5,#0x7
  66.          SUBS     R0,R0,#4
  67.          STR      R5,[R0,#0]
  68.          
  69.          MOV      R5,#0x8
  70.          SUBS     R0,R0,#4
  71.          STR      R5,[R0,#0]

  73.          MOV      R5,#0x8
  74.          SUBS     R0,R0,#4
  75.          STR      R5,[R0,#0]

  77.          MOV      R5,#0x10
  78.          SUBS     R0,R0,#4
  79.          STR      R5,[R0,#0]

  81.          MOV      R5,#0x11
  82.          SUBS     R0,R0,#4
  83.          STR      R5,[R0,#0]

  85.          MOV      R5,#0x12
  86.          SUBS     R6,R0,#4
  87.          MOV          R0,R6
  88.          STR      R5,[R6,#0]
  89.          POP      {R4-R6,PC}

  91. }


  94. /*Thumb2指令集中无串操作指令，不过可以用字对齐进行优化*/
  95. /*考虑到Thumb2指令中，32位指令执行效率并不高，所以这里暂时不作优化*/
  96. void  _mem_clr (I8U *pdest, I32 size)
  97. {
  98.     while (size > 0) {
  99.         *pdest++ = (I8)0;
  100.         size--;
  101.     }
  102. }

  104. void  _mem_copy (I8U *pdest, I8U *psrc, I16U size)
  105. {
  106.     while (size > 0) {
  107.         *pdest++ = *psrc++;
  108.         size--;
  109.     }
  110. }

  112. /*在TCB表中取一个空闲的节点，给新任务使用*/
  113. /*对BenOSTCBTable表这个有序表进行插入排序*/
  114. /*将优先级高的任务放在前面*/
  115. TCB* BenOSGetFreeTCB(PRIORITY_TYPE prio)
  116. {
  117.         TCB        *pTCB;
  118.         I32        index=0,orgIndex;

  120.         pTCB = &(BenOSTCBTable[0]);
  121.         for (index = 0;index < TaskNUM+1;index++)
  122.         {
  123.                 pTCB = BenOSTCBTable+index;

  125.                 /*已经是空闲TCB了，就直接使用*/
  126.                 if (NULL == pTCB->pStackTop)
  127.                 {
  128.                         return        (TCB*)pTCB;
  129.                 }

  131.                 /*若新任务优先级比较低，则向后继续找*/
  132.                 if (pTCB->CurPriority >= prio)
  133.                 {
  134.                         continue;
  135.                 }
  136.                 else /*pTCB->CurPriority < prio 找到了该插入的位置了*/
  137.                 {  
  138.                         /*保存当前位置*/
  139.                         orgIndex = index;

  141.                         /*从当前节点遍历到最后一个使用了的节点*/
  142.                         for( index = TaskNUM+1 ; index > orgIndex ; index-- )
  143.                         {
  144.                                 pTCB = BenOSTCBTable+index;

  146.                                 /*将前一个节点的数据，保存到当前节点*/
  147.                                 _mem_copy((I8U *)(pTCB),(I8U *)(pTCB-1),sizeof(TCB));
  148.                         }
  149.                         _mem_clr((I8U *)(pTCB-1),sizeof(TCB))  ;
  150.                                
  151.                         return (TCB*)(pTCB-1);               

  153.                 }
  154.         }

  156.         return        (TCB*)NULL;
  157. }

  159. /*
  160. *时钟中断函数
  161. */
  162. void SysTick_Handler()
  163. {
  164.         I8        index;
  165.         TCB                *pTCB;
  166.         I8U        flagFirstTask=0;
  167.         INT_Stat  stat = 0;

  169.         stat = BenOS_INT_Save();

  171.     /*初始化*/
  172.         BenOSNewTCB = NULL;

  174.         /*禁止调度*/
  175.         if (BenOSScheLock != 0)
  176.         {
  177.                 BenOS_INT_Restore(stat);
  178.                 return;
  179.         }

  181.         for (index = 0;index < TaskNUM;index++)
  182.         {
  183.                 pTCB = BenOSTCBTable+index;

  185.                 /*该任务在睡眠状态，必须将所有时延都--*/
  186.                 if (pTCB->TCBDelay > 0)
  187.                 {
  188.                         pTCB->TCBDelay--;
  189.                         continue;
  190.                 }

  192.                 /*该任务被挂起*/
  193.                 if (pTCB->TaskStat == BenOS_Task_Pend)       
  194.                 {
  195.                         continue;
  196.                 }

  198.                 /*是否找到了应该调度进去的就绪任务*/
  199.                 if (flagFirstTask==0)
  200.                 {
  201.                         /*找到了最高优先级的任务，
  202.                           并且比当前任务优先级高*/
  203.                         if (BenOSCurTCB->CurPriority < pTCB->CurPriority)
  204.                         {
  205.                                 flagFirstTask = 1;
  206.                                 BenOSNewTCB = pTCB;
  207.                                 continue;
  208.                         }

  210.                         /*找到了比当前优先级低的任务*/
  211.                         if (BenOSCurTCB->CurPriority > pTCB->CurPriority)
  212.                         {
  213.                                 if (BenOSNewTCB == NULL)
  214.                                 {
  215.                                         flagFirstTask = 1;
  216.                                         BenOSNewTCB = pTCB;
  217.                                         continue  ;       
  218.                                 }
  219.                                 else
  220.                                 {
  221.                                         flagFirstTask = 1;
  222.                                         continue  ;               
  223.                                 }
  224.                         }
  225.                        
  226.                         /*找到了最高优先级的任务，
  227.                           并且跟当前任务优先级相等*/
  228.                         if (BenOSCurTCB->CurPriority == pTCB->CurPriority)
  229.                         {
  230.                                 /*该任务在当前任务之后*/
  231.                                 if ((pTCB > BenOSCurTCB)||(pTCB == BenOSCurTCB))
  232.                                 {       
  233.                                         flagFirstTask = 1;
  234.                                         BenOSNewTCB = pTCB;
  235.                                         continue  ;               
  236.                                 }       
  237.                                 /*在当前任务之前或者就是当前任务
  238.                                   则还需要继续向后搜索第一个同优先级的任务*/
  239.                                 if ((pTCB < BenOSCurTCB)
  240.                                      &&(BenOSNewTCB == NULL))
  241.                                 {
  242.                                          BenOSNewTCB = pTCB;
  243.                                          continue;
  244.                                 }
  245.                         }


  248.                         continue;
  249.                 }

  251.                
  252.         }
  253.         if (BenOSNewTCB != BenOSCurTCB)
  254.         {
  255.                 BenOSCtxSw();
  256.         }
  257.         BenOS_INT_Restore(stat);
  258. }

  260. /*
  261. *在非中断中 调度新的任务 并且切换
  262. */
  263. void BenOSTaskSche()
  264. {
  265.         INT_Stat  stat = 0;

  267.         stat = BenOS_INT_Save();
  268.         if (BenOSScheLock != 0)
  269.         {
  270.                 BenOS_INT_Restore(stat);
  271.                 return;
  272.         }               

  274.         if (BenOSNewTCB != BenOSCurTCB)
  275.         {
  276.                 BenOSCtxSw();
  277.         }
  278.         BenOS_INT_Restore(stat);
  279. }

  281. /*
  282. * 创建新的任务
  283. */
  284. TASK_TYPE*  BenOSCreateTask(void* task, STACK_TYPE *stack,PRIORITY_TYPE prio)
  285. {
  286.         TCB        *pTCB;
  287.         INT_Stat  stat = 0;
  288.        
  289.         stat = BenOS_INT_Save();
  290.        
  291.         pTCB = BenOSGetFreeTCB(prio);

  293.         if (NULL == pTCB)
  294.         {
  295.                 BenOS_INT_Restore(stat);
  296.                 return        NULL;
  297.         }


  300.         pTCB->pStackTop = BenOSTaskStkInit(task, stack);

  302.         pTCB->CurPriority = prio;

  304.         pTCB->TCBDelay = 0;
  305.        
  306.         TaskNUM++;
  307.         BenOS_INT_Restore(stat);
  308.         return pTCB;
  309. }

  311. /*idle任务堆栈默认为128个字节*/
  312. STACK_TYPE        idleStack[IDLE_TASK_STACK_SIZE];

  314. I32U         IdleConuter=0;

  316. void BenOSIdleTask()
  317. {
  318.         INT_Stat                  stat = 0;

  320.         while(1)
  321.         {
  322.                 stat = BenOS_INT_Save();
  323.                 IdleConuter++;
  324.                 BenOS_INT_Restore(stat);
  325.         }
  326. }


  329. /*操作系统启动(并且将优先级较低的IDLE任务创建)*/
  330. void BenOSStart()
  331. {
  332.         INT_Stat  stat = 0;
  333.        
  334.         stat = BenOS_INT_Save();

  336.         BenOSCurTCB = BenOSTCBTable;
  337.         if (BenOSCurTCB == NULL)
  338.         {
  339.                 BenOS_INT_Restore(stat);
  340.                 return;
  341.         }

  343.         BenOS_INT_Restore(stat);

  345.         BenOSCreateTask((void*)BenOSIdleTask,&idleStack[IDLE_TASK_STACK_SIZE-1],0);
  346.        
  347.         BenOSStartTask();
  348. }


  351. void  BenOSTimeDly (I32 ticks)
  352. {
  353.         INT_Stat  stat = 0;
  354.         I8          index;
  355.         TCB                  *pTCB;
  356.        
  357.         stat = BenOS_INT_Save();
  358.         BenOSCurTCB->TCBDelay = ticks;

  360.         BenOSNewTCB = NULL;

  362.         /*从当前任务向后遍历，
  363.         第一个最大的优先级的任务
  364.         就是需要调度进去的任务*/
  365.         for (index = 0; index < TaskNUM;index++)
  366.         {
  367.                 pTCB = BenOSTCBTable+index;

  369.                 /*跳过睡眠任务*/
  370.                 if (pTCB->TCBDelay != 0)
  371.                 {
  372.                         continue;
  373.                 }
  374.                 /*跳过挂起任务*/
  375.                 if  (pTCB->TaskStat == BenOS_Task_Pend)       
  376.                 {                               
  377.   
  378.                         continue;
  379.                 }

  381.                 /*找到了最高优先级的任务，
  382.                   并且比当前任务优先级高*/
  383.                 if (BenOSCurTCB->CurPriority < pTCB->CurPriority)
  384.                 {
  385.                         BenOSNewTCB = pTCB;
  386.                         break;
  387.                 }

  389.                 /*找到了比当前优先级低的任务*/
  390.                 if (BenOSCurTCB->CurPriority > pTCB->CurPriority)
  391.                 {
  392.                     /*如果当前任务之前有同优先级的就绪任务，
  393.                           则选择该任务，否则就使用*/
  394.                         if (BenOSNewTCB == NULL)
  395.                         {
  396.                                 BenOSNewTCB = pTCB;
  397.                         }                                                  
  398.                         break;
  399.                 }
  400.                        
  401.                 /*找到了最高优先级的任务，
  402.                   并且跟当前任务优先级相等*/
  403.                 if (BenOSCurTCB->CurPriority == pTCB->CurPriority)
  404.                 {
  405.                         /*该任务在当前任务之后*/
  406.                         if ((pTCB > BenOSCurTCB))
  407.                         {       
  408.                                 BenOSNewTCB = pTCB;
  409.                                 break  ;               
  410.                         }       
  411.                         /*在当前任务之前或者就是当前任务
  412.                           则还需要继续向后搜索第一个同优先级的任务*/
  413.                         if (((pTCB < BenOSCurTCB)||(pTCB == BenOSCurTCB))
  414.                              &&(BenOSNewTCB == NULL))
  415.                         {
  416.                                  BenOSNewTCB = pTCB;
  417.                                  continue;
  418.                         }

  420.                 }

  422.        
  423.         }
  424.         BenOS_INT_Restore(stat);
  425.         BenOSTaskSche();       
  426. }

  428. /*
  429. * 初始化任务数据，并创建IDLE任务
  430. */

  432. I8 BenOSInit()
  433. {
  434.         I32        index=0;
  435.         INT_Stat  stat = 0;
  436.        
  437.         stat = BenOS_INT_Save();

  439.         for (index = 0;index < MAX_TASK_NUM;index++)
  440.         {
  441.                 _mem_clr((I8U*)BenOSTCBTable,sizeof(TCB)*MAX_TASK_NUM);
  442.         }                               

  444.         for(index=0;index<MAX_SEM_NUM;index++)
  445.         {       
  446.                 BenOSSemaphore[index] = -1;
  447.         }

  449.         for (index=0;index<MAX_QUEUE_NUMBER;index++)
  450.         {
  451.                 MsgQueueFlag[index]=0;
  452.         }

  454.         BenOSCurTCB = NULL;               
  455.         BenOSNewTCB = NULL;

  457.         BenOS_INT_Restore(stat);
  458.         return        BenOS_OK;

  460. }

  462. /*
  463. * 恢复任务运行
  464. */
  465. void BenOSTaskResume(TASK_TYPE *task)
  466. {
  467.         I32        index=0;
  468.         TCB                  *pTCB;
  469.         INT_Stat  stat = 0;
  470.        
  471.         stat = BenOS_INT_Save();
  472.         task->TaskStat = BenOS_Task_Run;
  473.                 /*从头向后遍历，第一最大的优先级就是需要调度进去的任务*/
  474.         for (index = 0 ; index < TaskNUM;index++)
  475.         {
  476.                 pTCB = BenOSTCBTable+index;
  477.                 if ((pTCB->TCBDelay == 0) && (pTCB->TaskStat !=BenOS_Task_Pend)          )
  478.                 {       
  479.                         BenOSNewTCB = pTCB;
  480.                         break;
  481.                 }
  482.         }
  483.        
  484.         BenOS_INT_Restore(stat);       

  486.         BenOSTaskSche();       
  487. }

  489. ……………………

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

所有资料51hei提供下载:
系统.7z (143.71 KB, 下载次数: 54)

评分

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

查看全部评分

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

使用道具 举报

沙发
ID:64089 发表于 2020-4-11 08:29 | 只看该作者
大神级，学习了！
回复

使用道具 举报

板凳
ID:91165 发表于 2020-4-11 09:09 | 只看该作者
真是牛人，顶一下
回复

使用道具 举报

地板
ID:53978 发表于 2020-4-12 12:26 | 只看该作者
看技术帖虽然一点都不懂 但是要顶
回复

使用道具 举报

5#
ID:476903 发表于 2021-6-11 17:40 | 只看该作者
从B站评论过来顶一下啊
回复

使用道具 举报

6#
ID:1072895 发表于 2023-4-20 10:06 | 只看该作者
B站来的，学习了
回复

使用道具 举报

7#
ID:291668 发表于 2023-4-20 14:43 | 只看该作者
必须顶起啊！辛苦了
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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