找回密碼
 立即注冊

QQ登錄

只需一步，快速開始

搜索
查看: 7225|回復: 11
收起左側

牛人自制的STM32實時操作系統(tǒng)

  [復制鏈接]
ID:507431 發(fā)表于 2020-4-10 10:30 | 顯示全部樓層 |閱讀模式
作者
https://bbs.csdn.net/topics/300000723
實現(xiàn)硬件 STM32F10vet6


1，內存使用量統(tǒng)計
硬件系統(tǒng)啟動使用：
系統(tǒng)堆棧（系統(tǒng)啟動的時候需要使用）        80個字節(jié)

操作系統(tǒng)內核使用：
任務表                                    96+16個字節(jié)   
                                注：20個字節(jié)/任務 * 8（默認任務個數(shù)）
                                
信號量                                    32個字節(jié)
                                注：4個字節(jié)/信號量 * 8（默認信號量個數(shù)）

消息隊列                                54個字節(jié)
                                注: 默認8條消息/隊列 * 3 (默認3個消息隊列)
                                
空閑任務（Idle）                        96個字節(jié)   
                                注：每個任務最少需要96個字節(jié)的堆棧，推薦256個字節(jié)
                    
RAM使用統(tǒng)計：
一個原始的系統(tǒng)總共占用內存約為400個字節(jié)
其中內核占用內存不到300個字節(jié)

(注:根據(jù)armlink指示，另外還有96個字節(jié)的數(shù)據(jù)用于LIBSPACE.O文件，
這個查明，其實是開發(fā)環(huán)境在為main主函數(shù)初始化的時候用到)


2，代碼量(包括ROM里面的只讀數(shù)據(jù))統(tǒng)計
內核                            1200 個字節(jié)
信號量                            300 個字節(jié)
消息隊列                        500 個字節(jié)

ROM使用統(tǒng)計
原始的系統(tǒng)代碼小于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指令集中無串操作指令，不過可以用字對齊進行優(yōu)化*/
  95. /*考慮到Thumb2指令中，32位指令執(zhí)行效率并不高，所以這里暫時不作優(yōu)化*/
  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表中取一個空閑的節(jié)點，給新任務使用*/
  113. /*對BenOSTCBTable表這個有序表進行插入排序*/
  114. /*將優(yōu)先級高的任務放在前面*/
  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.                 /*已經(jīng)是空閑TCB了，就直接使用*/
  126.                 if (NULL == pTCB->pStackTop)
  127.                 {
  128.                         return        (TCB*)pTCB;
  129.                 }

  131.                 /*若新任務優(yōu)先級比較低，則向后繼續(xù)找*/
  132.                 if (pTCB->CurPriority >= prio)
  133.                 {
  134.                         continue;
  135.                 }
  136.                 else /*pTCB->CurPriority < prio 找到了該插入的位置了*/
  137.                 {  
  138.                         /*保存當前位置*/
  139.                         orgIndex = index;

  141.                         /*從當前節(jié)點遍歷到最后一個使用了的節(jié)點*/
  142.                         for( index = TaskNUM+1 ; index > orgIndex ; index-- )
  143.                         {
  144.                                 pTCB = BenOSTCBTable+index;

  146.                                 /*將前一個節(jié)點的數(shù)據(jù)，保存到當前節(jié)點*/
  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. *時鐘中斷函數(shù)
  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.                 /*該任務在睡眠狀態(tài)，必須將所有時延都--*/
  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.                         /*找到了最高優(yōu)先級的任務，
  202.                           并且比當前任務優(yōu)先級高*/
  203.                         if (BenOSCurTCB->CurPriority < pTCB->CurPriority)
  204.                         {
  205.                                 flagFirstTask = 1;
  206.                                 BenOSNewTCB = pTCB;
  207.                                 continue;
  208.                         }

  210.                         /*找到了比當前優(yōu)先級低的任務*/
  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.                         /*找到了最高優(yōu)先級的任務，
  227.                           并且跟當前任務優(yōu)先級相等*/
  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.                                   則還需要繼續(xù)向后搜索第一個同優(yōu)先級的任務*/
  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. * 創(chuàng)建新的任務
  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個字節(jié)*/
  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. /*操作系統(tǒng)啟動(并且將優(yōu)先級較低的IDLE任務創(chuàng)建)*/
  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.         第一個最大的優(yōu)先級的任務
  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.                 /*找到了最高優(yōu)先級的任務，
  382.                   并且比當前任務優(yōu)先級高*/
  383.                 if (BenOSCurTCB->CurPriority < pTCB->CurPriority)
  384.                 {
  385.                         BenOSNewTCB = pTCB;
  386.                         break;
  387.                 }

  389.                 /*找到了比當前優(yōu)先級低的任務*/
  390.                 if (BenOSCurTCB->CurPriority > pTCB->CurPriority)
  391.                 {
  392.                     /*如果當前任務之前有同優(yōu)先級的就緒任務，
  393.                           則選擇該任務，否則就使用*/
  394.                         if (BenOSNewTCB == NULL)
  395.                         {
  396.                                 BenOSNewTCB = pTCB;
  397.                         }                                                  
  398.                         break;
  399.                 }
  400.                        
  401.                 /*找到了最高優(yōu)先級的任務，
  402.                   并且跟當前任務優(yōu)先級相等*/
  403.                 if (BenOSCurTCB->CurPriority == pTCB->CurPriority)
  404.                 {
  405.                         /*該任務在當前任務之后*/
  406.                         if ((pTCB > BenOSCurTCB))
  407.                         {       
  408.                                 BenOSNewTCB = pTCB;
  409.                                 break  ;               
  410.                         }       
  411.                         /*在當前任務之前或者就是當前任務
  412.                           則還需要繼續(xù)向后搜索第一個同優(yōu)先級的任務*/
  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. * 初始化任務數(shù)據(jù)，并創(chuàng)建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.                 /*從頭向后遍歷，第一最大的優(yōu)先級就是需要調度進去的任務*/
  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提供下載:
系統(tǒng).7z (143.71 KB, 下載次數(shù): 75)

評分

參與人數(shù) 1黑幣 +50 收起 理由
admin + 50 共享資料的黑幣獎勵！

查看全部評分

回復

使用道具 舉報

ID:64089 發(fā)表于 2020-4-11 08:29 | 顯示全部樓層
大神級，學習了！
回復

使用道具 舉報

ID:91165 發(fā)表于 2020-4-11 09:09 | 顯示全部樓層
真是牛人，頂一下
回復

使用道具 舉報

ID:53978 發(fā)表于 2020-4-12 12:26 | 顯示全部樓層
看技術帖雖然一點都不懂 但是要頂
回復

使用道具 舉報

ID:476903 發(fā)表于 2021-6-11 17:40 | 顯示全部樓層
從B站評論過來頂一下啊
回復

使用道具 舉報

ID:1072895 發(fā)表于 2023-4-20 10:06 | 顯示全部樓層
B站來的，學習了
回復

使用道具 舉報

ID:291668 發(fā)表于 2023-4-20 14:43 | 顯示全部樓層
必須頂起��！辛苦了
回復

使用道具 舉報

ID:1129103 發(fā)表于 2024-7-16 15:40 | 顯示全部樓層
頂, 前來學習觀望
回復

使用道具 舉報

ID:25103 發(fā)表于 2024-7-16 16:41 | 顯示全部樓層

大神級，學習了！
回復

使用道具 舉報

ID:169559 發(fā)表于 2024-7-19 07:26 | 顯示全部樓層
厲害�。∧ぐ菀粋�！
回復

使用道具 舉報

ID:1130105 發(fā)表于 2024-8-6 08:56 | 顯示全部樓層
我看有人說是從B站找過來的，請問一下有視頻的鏈接嗎，能分享一下觀摩一二嗎。
回復

使用道具 舉報

ID:87000 發(fā)表于 2024-8-6 09:26 | 顯示全部樓層
還是下載來看看，適不適合自己試用
回復

使用道具 舉報

您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規(guī)則

手機版|小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術交流QQ群281945664

Powered by 單片機教程網(wǎng)

快速回復 返回頂部 返回列表