[其他ST产品] 正点原子STM32F1工程delay文件阅读

[复制链接]
7009|21
 楼主| 慢醇 发表于 2023-7-8 13:23 | 显示全部楼层 |阅读模式
正点原子STM32F1工程SYSTEM文件夹中delay代码阅读
为方便大家搭建工程,正点原子团队自己编写了sys.c、delay.c、usart.c三个文件,可用于任何STM32F1工程的搭建,提供诸如延时、串口通信等功能,下面就delay.c进行阅读,和大家分享我的理解思路。


首先先把源代码贴上来:


  1. #include "delay.h"
  2. //          
  3. //如果需要使用OS,则包括下面的头文件即可.
  4. #if SYSTEM_SUPPORT_OS
  5. #include "includes.h"                                        //ucos 使用          
  6. #endif
  7. //         
  8. //本程序只供学习使用,未经作者许可,不得用于其它任何用途
  9. //ALIENTEK STM32开发板
  10. //使用SysTick的普通计数模式对延迟进行管理(适合STM32F10x系列)
  11. //包括delay_us,delay_ms
  12. //正点原子@ALIENTEK
  13. //技术论坛:www.openedv.com
  14. //创建日期:2010/1/1
  15. //版本:V1.8
  16. //版权所有,盗版必究。
  17. //Copyright(C) 广州市星翼电子科技有限公司 2009-2019
  18. //All rights reserved
  19. //********************************************************************************
  20. //V1.2修改说明
  21. //修正了中断中调用出现死循环的错误
  22. //防止延时不准确,采用do while结构!
  23. //V1.3修改说明
  24. //增加了对UCOSII延时的支持.
  25. //如果使用ucosII,delay_init会自动设置SYSTICK的值,使之与ucos的TICKS_PER_SEC对应.
  26. //delay_ms和delay_us也进行了针对ucos的改造.
  27. //delay_us可以在ucos下使用,而且准确度很高,更重要的是没有占用额外的定时器.
  28. //delay_ms在ucos下,可以当成OSTimeDly来用,在未启动ucos时,它采用delay_us实现,从而准确延时
  29. //可以用来初始化外设,在启动了ucos之后delay_ms根据延时的长短,选择OSTimeDly实现或者delay_us实现.
  30. //V1.4修改说明 20110929
  31. //修改了使用ucos,但是ucos未启动的时候,delay_ms中中断无法响应的bug.
  32. //V1.5修改说明 20120902
  33. //在delay_us加入ucos上锁,防止由于ucos打断delay_us的执行,可能导致的延时不准。
  34. //V1.6修改说明 20150109
  35. //在delay_ms加入OSLockNesting判断。
  36. //V1.7修改说明 20150319
  37. //修改OS支持方式,以支持任意OS(不限于UCOSII和UCOSIII,理论上任意OS都可以支持)
  38. //添加:delay_osrunning/delay_ostickspersec/delay_osintnesting三个宏定义
  39. //添加:delay_osschedlock/delay_osschedunlock/delay_ostimedly三个函数
  40. //V1.8修改说明 20150519
  41. //修正UCOSIII支持时的2个bug:
  42. //delay_tickspersec改为:delay_ostickspersec
  43. //delay_intnesting改为:delay_osintnesting
  44. //  

  45. static u8  fac_us=0;                                                        //us延时倍乘数                          
  46. static u16 fac_ms=0;                                                        //ms延时倍乘数,在ucos下,代表每个节拍的ms数
  47.        
  48.        
  49. #if SYSTEM_SUPPORT_OS                                                        //如果SYSTEM_SUPPORT_OS定义了,说明要支持OS了(不限于UCOS).
  50. //当delay_us/delay_ms需要支持OS的时候需要三个与OS相关的宏定义和函数来支持
  51. //首先是3个宏定义:
  52. //    delay_osrunning:用于表示OS当前是否正在运行,以决定是否可以使用相关函数
  53. //delay_ostickspersec:用于表示OS设定的时钟节拍,delay_init将根据这个参数来初始哈systick
  54. // delay_osintnesting:用于表示OS中断嵌套级别,因为中断里面不可以调度,delay_ms使用该参数来决定如何运行
  55. //然后是3个函数:
  56. //  delay_osschedlock:用于锁定OS任务调度,禁止调度
  57. //delay_osschedunlock:用于解锁OS任务调度,重新开启调度
  58. //    delay_ostimedly:用于OS延时,可以引起任务调度.

  59. //本例程仅作UCOSII和UCOSIII的支持,其他OS,请自行参考着移植
  60. //支持UCOSII
  61. #ifdef         OS_CRITICAL_METHOD                                                //OS_CRITICAL_METHOD定义了,说明要支持UCOSII                               
  62. #define delay_osrunning                OSRunning                        //OS是否运行标记,0,不运行;1,在运行
  63. #define delay_ostickspersec        OS_TICKS_PER_SEC        //OS时钟节拍,即每秒调度次数
  64. #define delay_osintnesting         OSIntNesting                //中断嵌套级别,即中断嵌套次数
  65. #endif

  66. //支持UCOSIII
  67. #ifdef         CPU_CFG_CRITICAL_METHOD                                        //CPU_CFG_CRITICAL_METHOD定义了,说明要支持UCOSIII       
  68. #define delay_osrunning                OSRunning                        //OS是否运行标记,0,不运行;1,在运行
  69. #define delay_ostickspersec        OSCfg_TickRate_Hz        //OS时钟节拍,即每秒调度次数
  70. #define delay_osintnesting         OSIntNestingCtr                //中断嵌套级别,即中断嵌套次数
  71. #endif


  72. //us级延时时,关闭任务调度(防止打断us级延迟)
  73. void delay_osschedlock(void)
  74. {
  75. #ifdef CPU_CFG_CRITICAL_METHOD                                   //使用UCOSIII
  76.         OS_ERR err;
  77.         OSSchedLock(&err);                                                        //UCOSIII的方式,禁止调度,防止打断us延时
  78. #else                                                                                        //否则UCOSII
  79.         OSSchedLock();                                                                //UCOSII的方式,禁止调度,防止打断us延时
  80. #endif
  81. }

  82. //us级延时时,恢复任务调度
  83. void delay_osschedunlock(void)
  84. {       
  85. #ifdef CPU_CFG_CRITICAL_METHOD                                   //使用UCOSIII
  86.         OS_ERR err;
  87.         OSSchedUnlock(&err);                                                //UCOSIII的方式,恢复调度
  88. #else                                                                                        //否则UCOSII
  89.         OSSchedUnlock();                                                        //UCOSII的方式,恢复调度
  90. #endif
  91. }

  92. //调用OS自带的延时函数延时
  93. //ticks:延时的节拍数
  94. void delay_ostimedly(u32 ticks)
  95. {
  96. #ifdef CPU_CFG_CRITICAL_METHOD
  97.         OS_ERR err;
  98.         OSTimeDly(ticks,OS_OPT_TIME_PERIODIC,&err);        //UCOSIII延时采用周期模式
  99. #else
  100.         OSTimeDly(ticks);                                                        //UCOSII延时
  101. #endif
  102. }

  103. //systick中断服务函数,使用ucos时用到
  104. void SysTick_Handler(void)
  105. {       
  106.         if(delay_osrunning==1)                                                //OS开始跑了,才执行正常的调度处理
  107.         {
  108.                 OSIntEnter();                                                        //进入中断
  109.                 OSTimeTick();                                               //调用ucos的时钟服务程序               
  110.                 OSIntExit();                                                        //触发任务切换软中断
  111.         }
  112. }
  113. #endif

  114.                           
  115. //初始化延迟函数
  116. //当使用OS的时候,此函数会初始化OS的时钟节拍
  117. //SYSTICK的时钟固定为HCLK时钟的1/8
  118. //SYSCLK:系统时钟
  119. void delay_init()
  120. {
  121. #if SYSTEM_SUPPORT_OS                                                          //如果需要支持OS.
  122.         u32 reload;
  123. #endif
  124.         SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);        //选择外部时钟  HCLK/8
  125.         fac_us=SystemCoreClock/8000000;                                //为系统时钟的1/8  
  126. #if SYSTEM_SUPPORT_OS                                                          //如果需要支持OS.
  127.         reload=SystemCoreClock/8000000;                                //每秒钟的计数次数 单位为K          
  128.         reload*=1000000/delay_ostickspersec;                //根据delay_ostickspersec设定溢出时间
  129.                                                                                                 //reload为24位寄存器,最大值:16777216,在72M下,约合1.86s左右       
  130.         fac_ms=1000/delay_ostickspersec;                        //代表OS可以延时的最少单位          

  131.         SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;           //开启SYSTICK中断
  132.         SysTick->LOAD=reload;                                                 //每1/delay_ostickspersec秒中断一次       
  133.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;           //开启SYSTICK   

  134. #else
  135.         fac_ms=(u16)fac_us*1000;                                        //非OS下,代表每个ms需要的systick时钟数   
  136. #endif
  137. }                                                                    

  138. #if SYSTEM_SUPPORT_OS                                                          //如果需要支持OS.
  139. //延时nus
  140. //nus为要延时的us数.                                                                                      
  141. void delay_us(u32 nus)
  142. {               
  143.         u32 ticks;
  144.         u32 told,tnow,tcnt=0;
  145.         u32 reload=SysTick->LOAD;                                        //LOAD的值                     
  146.         ticks=nus*fac_us;                                                         //需要的节拍数                           
  147.         tcnt=0;
  148.         delay_osschedlock();                                                //阻止OS调度,防止打断us延时
  149.         told=SysTick->VAL;                                                //刚进入时的计数器值
  150.         while(1)
  151.         {
  152.                 tnow=SysTick->VAL;       
  153.                 if(tnow!=told)
  154.                 {            
  155.                         if(tnow<told)tcnt+=told-tnow;                //这里注意一下SYSTICK是一个递减的计数器就可以了.
  156.                         else tcnt+=reload-tnow+told;            
  157.                         told=tnow;
  158.                         if(tcnt>=ticks)break;                                //时间超过/等于要延迟的时间,则退出.
  159.                 }  
  160.         };
  161.         delay_osschedunlock();                                                //恢复OS调度                                                                            
  162. }
  163. //延时nms
  164. //nms:要延时的ms数
  165. void delay_ms(u16 nms)
  166. {       
  167.         if(delay_osrunning&&delay_osintnesting==0)        //如果OS已经在跑了,并且不是在中断里面(中断里面不能任务调度)            
  168.         {                 
  169.                 if(nms>=fac_ms)                                                        //延时的时间大于OS的最少时间周期
  170.                 {
  171.                            delay_ostimedly(nms/fac_ms);                //OS延时
  172.                 }
  173.                 nms%=fac_ms;                                                        //OS已经无法提供这么小的延时了,采用普通方式延时   
  174.         }
  175.         delay_us((u32)(nms*1000));                                        //普通方式延时  
  176. }
  177. #else //不用OS时
  178. //延时nus
  179. //nus为要延时的us数.                                                                                      
  180. void delay_us(u32 nus)
  181. {               
  182.         u32 temp;                     
  183.         SysTick->LOAD=nus*fac_us;                                         //时间加载                           
  184.         SysTick->VAL=0x00;                                                //清空计数器
  185.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;        //开始倒数          
  186.         do
  187.         {
  188.                 temp=SysTick->CTRL;
  189.         }while((temp&0x01)&&!(temp&(1<<16)));                //等待时间到达   
  190.         SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;        //关闭计数器
  191.         SysTick->VAL =0X00;                                               //清空计数器         
  192. }
  193. //延时nms
  194. //注意nms的范围
  195. //SysTick->LOAD为24位寄存器,所以,最大延时为:
  196. //nms<=0xffffff*8*1000/SYSCLK
  197. //SYSCLK单位为Hz,nms单位为ms
  198. //对72M条件下,nms<=1864
  199. void delay_ms(u16 nms)
  200. {                                     
  201.         u32 temp;                  
  202.         SysTick->LOAD=(u32)nms*fac_ms;                                //时间加载(SysTick->LOAD为24bit)
  203.         SysTick->VAL =0x00;                                                        //清空计数器
  204.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;        //开始倒数  
  205.         do
  206.         {
  207.                 temp=SysTick->CTRL;
  208.         }while((temp&0x01)&&!(temp&(1<<16)));                //等待时间到达   
  209.         SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;        //关闭计数器
  210.         SysTick->VAL =0X00;                                               //清空计数器                      
  211. }
  212. #endif

这段代码主要是实现了系统延时的功能函数,并且用条件编译使得无论是裸机还是带RTOS的程序都能够顺利的使用该函数。

在讲解之前有个概念需要先说明一下。


 楼主| 慢醇 发表于 2023-7-8 13:42 | 显示全部楼层
SysTick定时器:

来源于CM3权威指南。

SysTick定时器被捆绑在NVIC中,用于产生SYSTICK异常(异常号:15)。在以前,大多操作系统需要一个硬件定时器来产生操作系统需要的滴答中断,作为整个系统的时基。例如,为多个任务许以不同数目的时间片,确保没有一个任务能霸占系统;或者把每个定时器周期的某个时间范围赐予特定的任务等,还有操作系统提供的各种定时功能,都与这个滴答定时器有关。因此,需要一个定时器来产生周期性的中断,而且最好还让用户程序不能随意访问它的寄存器,以维持操作系统“心跳”的节律。

Cortex‐M3处理器内部包含了一个简单的定时器。因为所有的CM3芯片都带有这个定时器

简而言之就是所有CM3芯片都有一个SysTick定时器,用于产生操作系统所需的滴答中断。
 楼主| 慢醇 发表于 2023-7-8 13:42 | 显示全部楼层
定时器相信都不陌生,就是一个计数器,而SysTick就是一个给操作系统提供服务的定时器,所以当我们运行裸机程序,没有操作系统时,我们想怎么使用SysTick就可以怎么使用,但是如果我们使用了操作系统,那就不能随意的改变SysTick寄存器中的值,这也是为什么要分带操作系统和不带操作系统来写这个函数。
 楼主| 慢醇 发表于 2023-7-8 13:45 | 显示全部楼层
下面开始代码讲解

  1. #if SYSTEM_SUPPORT_OS
  2. #include "includes.h"                                        //ucos 使用          
  3. #endif


首先是这一部分,很简单,一个条件编译,如果使用操作系统的话,包含一个头文件,这个头文件是操作系统使用的。需要注意的是SYSTEM_SUPPORT_OS是在sys.h中define的,所以要在sys.h中修改它的值。
 楼主| 慢醇 发表于 2023-7-8 13:45 | 显示全部楼层
  1. static u8  fac_us=0;                                                        //us延时倍乘数                          
  2. static u16 fac_ms=0;                                                        //ms延时倍乘数,在ucos下,代表每个节拍的ms数


接下来是两个变量的定义,fac_us和fac_ms,前者是代表延时1us需要的SysTick滴答数,后者是代表延时1ms需要的SysTick嘀嗒数,自然fac_ms = 1000*fac_us,但是在支持操作系统时这两个变量的意思也发生了变化,后面再看。
 楼主| 慢醇 发表于 2023-7-8 14:15 | 显示全部楼层
  1. #if SYSTEM_SUPPORT_OS
  2. //支持UCOSII
  3. #ifdef         OS_CRITICAL_METHOD                                                //OS_CRITICAL_METHOD定义了,说明要支持UCOSII                               
  4. #define delay_osrunning                OSRunning                        //OS是否运行标记,0,不运行;1,在运行
  5. #define delay_ostickspersec        OS_TICKS_PER_SEC        //OS时钟节拍,即每秒调度次数
  6. #define delay_osintnesting         OSIntNesting                //中断嵌套级别,即中断嵌套次数
  7. #endif

  8. //支持UCOSIII
  9. #ifdef         CPU_CFG_CRITICAL_METHOD                                        //CPU_CFG_CRITICAL_METHOD定义了,说明要支持UCOSIII       
  10. #define delay_osrunning                OSRunning                        //OS是否运行标记,0,不运行;1,在运行
  11. #define delay_ostickspersec        OSCfg_TickRate_Hz        //OS时钟节拍,即每秒调度次数
  12. #define delay_osintnesting         OSIntNestingCtr                //中断嵌套级别,即中断嵌套次数
  13. #endif
 楼主| 慢醇 发表于 2023-7-8 14:16 | 显示全部楼层
条件编译,define了一些使用操作系统时需要用到的变量,上面可以支持UCOS-ii和UCOS-iii。OS_CRITICAL_METHOD和CPU_CFG_CRITICAL_METHOD应该是在对应的操作系统源码中定义的。

delay_osrunning是系统正在运行的标志,delay_ostickspersec是系统一秒钟对应的嘀嗒数,需要注意的是:这个嘀嗒数并不对应SysTick嘀嗒数,所以需要在SysTick嘀嗒数和OSTick嘀嗒数之间进行转换,后面代码读不懂的话很可能就是不知道这个的缘故。
 楼主| 慢醇 发表于 2023-7-8 14:21 | 显示全部楼层
delay_osintnesting代表中断嵌套次数,主要是用于判断当前是否处于中断中。

  1. //us级延时时,关闭任务调度(防止打断us级延迟)
  2. void delay_osschedlock(void)
  3. {
  4. #ifdef CPU_CFG_CRITICAL_METHOD                                   //使用UCOSIII
  5.         OS_ERR err;
  6.         OSSchedLock(&err);                                                        //UCOSIII的方式,禁止调度,防止打断us延时
  7. #else                                                                                        //否则UCOSII
  8.         OSSchedLock();                                                                //UCOSII的方式,禁止调度,防止打断us延时
  9. #endif
  10. }

  11. //us级延时时,恢复任务调度
  12. void delay_osschedunlock(void)
  13. {       
  14. #ifdef CPU_CFG_CRITICAL_METHOD                                   //使用UCOSIII
  15.         OS_ERR err;
  16.         OSSchedUnlock(&err);                                                //UCOSIII的方式,恢复调度
  17. #else                                                                                        //否则UCOSII
  18.         OSSchedUnlock();                                                        //UCOSII的方式,恢复调度
  19. #endif
  20. }
 楼主| 慢醇 发表于 2023-7-8 14:22 | 显示全部楼层
这两个函数也没什么好讲的,一个是关闭操作系统任务调度的函数,一个是恢复操作系统任务调度的函数。至于为什么要关闭任务调度,是为了防止在我们运行delay_us函数的时候出现高优先级的任务打断delay_us函数执行造成延时不准的情况发生。
  1. //调用OS自带的延时函数延时
  2. //ticks:延时的节拍数
  3. void delay_ostimedly(u32 ticks)
  4. {
  5. #ifdef CPU_CFG_CRITICAL_METHOD
  6.         OS_ERR err;
  7.         OSTimeDly(ticks,OS_OPT_TIME_PERIODIC,&err);        //UCOSIII延时采用周期模式
  8. #else
  9.         OSTimeDly(ticks);                                                        //UCOSII延时
  10. #endif
  11. }
 楼主| 慢醇 发表于 2023-7-8 14:22 | 显示全部楼层
这个函数则是对操作系统自带的延时函数的封装,同样也是分UCOS-iii和UCOS-ii。
  1. //systick中断服务函数,使用ucos时用到
  2. void SysTick_Handler(void)
  3. {       
  4.         if(delay_osrunning==1)                                                //OS开始跑了,才执行正常的调度处理
  5.         {
  6.                 OSIntEnter();                                                        //进入中断
  7.                 OSTimeTick();                                               //调用ucos的时钟服务程序               
  8.                 OSIntExit();                                                        //触发任务切换软中断
  9.         }
  10. }
  11. #endif
 楼主| 慢醇 发表于 2023-7-8 14:22 | 显示全部楼层
这个函数我暂时也不太懂,先不讲。。。
  1. //初始化延迟函数
  2. //当使用OS的时候,此函数会初始化OS的时钟节拍
  3. //SYSTICK的时钟固定为HCLK时钟的1/8
  4. //SYSCLK:系统时钟
  5. void delay_init()
  6. {
  7. #if SYSTEM_SUPPORT_OS                                                          //如果需要支持OS.
  8.         u32 reload;
  9. #endif
  10.         SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);        //选择外部时钟  HCLK/8
  11.         fac_us=SystemCoreClock/8000000;                                //为系统时钟的1/8  
  12. #if SYSTEM_SUPPORT_OS                                                          //如果需要支持OS.
  13.         reload=SystemCoreClock/8000000;                                //每秒钟的计数次数 单位为K          
  14.         reload*=1000000/delay_ostickspersec;                //根据delay_ostickspersec设定溢出时间
  15.                                                                                                 //reload为24位寄存器,最大值:16777216,在72M下,约合1.86s左右       
  16.         fac_ms=1000/delay_ostickspersec;                        //代表OS可以延时的最少单位          

  17.         SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;           //开启SYSTICK中断
  18.         SysTick->LOAD=reload;                                                 //每1/delay_ostickspersec秒中断一次       
  19.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;           //开启SYSTICK   

  20. #else
  21.         fac_ms=(u16)fac_us*1000;                                        //非OS下,代表每个ms需要的systick时钟数   
  22. #endif
  23. }       
 楼主| 慢醇 发表于 2023-7-8 14:22 | 显示全部楼层
delay的初始化函数。
  1. SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);        //选择外部时钟  HCLK/8
 楼主| 慢醇 发表于 2023-7-8 14:23 | 显示全部楼层
这里是选择SysTick的时钟源为HCLK/8 = 72M/8 = 9M。也就是说SysTick每秒钟产生9000000个嘀嗒。也就是每个嘀嗒代表1/9us,所以fac_us 应该等于9而fac_ms等于9000。

fac_us=SystemCoreClock/8000000,SystemCoreClock为72M,所以fac_us就是等于9。这里要注意fac_ms在支持操作系统和不支持操作系统中的含义是不一样的,至于不支持操作系统中的fac_ms=(u16)fac_us*1000;则没有什么好说的,接下来还是主要来看支持操作系统的代码。
 楼主| 慢醇 发表于 2023-7-8 14:29 | 显示全部楼层
  1. reload=SystemCoreClock/8000000;                                //每秒钟的计数次数 单位为K          
  2. reload*=1000000/delay_ostickspersec;                //根据delay_ostickspersec设定溢出时间
  3.                                                                                         //reload为24位寄存器,最大值:16777216,在72M下,约合1.86s左右       
  4. fac_ms=1000/delay_ostickspersec;                        //代表OS可以延时的最少单位          

  5. SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;           //开启SYSTICK中断
  6. SysTick->LOAD=reload;                                                 //每1/delay_ostickspersec秒中断一次       
  7. SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;           //开启SYSTICK
 楼主| 慢醇 发表于 2023-7-8 14:29 | 显示全部楼层
reload是在前面定义的,reload=SystemCoreClock/8000000;这和上面的fac_us=SystemCoreClock/8000000;是一模一样的,也就是9咯,但是后面的注释中写 “每秒钟的计数次数,单位为K”,这注释显然是错的,要么就是每毫秒的计数次数,单位为K,要么就是每秒钟的计数次数,单位为M。总而言之就是错了。后面的reload*=1000000/delay_ostickspersec;就比较难理解了。
 楼主| 慢醇 发表于 2023-7-8 14:29 | 显示全部楼层
3693664a9023dc7f19.png
reload本来是延时1us需要的SysTick嘀嗒数,乘以1M之后就变成了延时1s需要的SysTick嘀嗒数,再除以操作系统延时1s需要的OSTick嘀嗒数,其实就得到了一个转化比,SysTick的reload个嘀嗒相当于OSTick的1个嘀嗒,将SysTick的重装载寄存器设置为reload,这样SysTick才能为OS提供嘀嗒,前面已经说了,SysTick就是为OS提供嘀嗒服务的。
 楼主| 慢醇 发表于 2023-7-8 14:33 | 显示全部楼层
接下来来看下面一行的fac_ms=1000/delay_ostickspersec;。首先1/delay_ostickspersec的含义是一个OSTick代表的时间,单位是秒,乘以1000之后就可以变成:一个OSTick代表的时间,单位是毫秒,也就是fac_ms此时代表的是一个OSTick能够延时多少毫秒,后面进行ms延时的时候如果能够用OSTick进行延时的就优先进行OSTick延时。

下面的三行则是开启SysTick中断、设置SysTick的reload寄存器以给OS提供服务、最后开启SysTick。
 楼主| 慢醇 发表于 2023-7-8 14:34 | 显示全部楼层
接下来就简单了,支持操作系统情况下的us延时函数和ms延时函数:
  1. #if SYSTEM_SUPPORT_OS                                                          //如果需要支持OS.
  2. //延时nus
  3. //nus为要延时的us数.                                                                                      
  4. void delay_us(u32 nus)
  5. {               
  6.         u32 ticks;
  7.         u32 told,tnow,tcnt=0;
  8.         u32 reload=SysTick->LOAD;                                        //LOAD的值                     
  9.         ticks=nus*fac_us;                                                         //需要的节拍数                           
  10.         tcnt=0;
  11.         delay_osschedlock();                                                //阻止OS调度,防止打断us延时
  12.         told=SysTick->VAL;                                                //刚进入时的计数器值
  13.         while(1)
  14.         {
  15.                 tnow=SysTick->VAL;       
  16.                 if(tnow!=told)
  17.                 {            
  18.                         if(tnow<told)tcnt+=told-tnow;                //这里注意一下SYSTICK是一个递减的计数器就可以了.
  19.                         else tcnt+=reload-tnow+told;            
  20.                         told=tnow;
  21.                         if(tcnt>=ticks)break;                                //时间超过/等于要延迟的时间,则退出.
  22.                 }  
  23.         };
  24.         delay_osschedunlock();                                                //恢复OS调度                                                                            
  25. }
  26. //延时nms
  27. //nms:要延时的ms数
  28. void delay_ms(u16 nms)
  29. {       
  30.         if(delay_osrunning&&delay_osintnesting==0)        //如果OS已经在跑了,并且不是在中断里面(中断里面不能任务调度)            
  31.         {                 
  32.                 if(nms>=fac_ms)                                                        //延时的时间大于OS的最少时间周期
  33.                 {
  34.                            delay_ostimedly(nms/fac_ms);                //OS延时
  35.                 }
  36.                 nms%=fac_ms;                                                        //OS已经无法提供这么小的延时了,采用普通方式延时   
  37.         }
  38.         delay_us((u32)(nms*1000));                                        //普通方式延时  
  39. }
 楼主| 慢醇 发表于 2023-7-8 14:34 | 显示全部楼层
前面说了,有操作系统的情况下SysTick是给OS提供服务的,所以这种情况下不能随意修改SysTick的LOAD和VAL寄存器的值,必须在不改变SysTick的情况下延时,大概的思路就是先记录开始延时时的计数值,然后计算延时这么长时间需要多少个嘀嗒,然后一直等待这么多个嘀嗒,这个过程是不能被打断的,所以需要关闭OS调度。

而ms的延时则是分两部分,对于OSTick的整数部分,采用操作系统自带的延时函数,对于剩余的部分,采用delay_us进行延时。
 楼主| 慢醇 发表于 2023-7-8 14:34 | 显示全部楼层
下面是不带操作系统的延时函数,不给操作系统提供服务的情况下可以随意的修改SysTick,所以需要延时多久只需要修改SysTick的LOAD和VAL寄存器就行啦。
  1. #else //不用OS时
  2. //延时nus
  3. //nus为要延时的us数.                                                                                      
  4. void delay_us(u32 nus)
  5. {               
  6.         u32 temp;                     
  7.         SysTick->LOAD=nus*fac_us;                                         //时间加载                           
  8.         SysTick->VAL=0x00;                                                //清空计数器
  9.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;        //开始倒数          
  10.         do
  11.         {
  12.                 temp=SysTick->CTRL;
  13.         }while((temp&0x01)&&!(temp&(1<<16)));                //等待时间到达   
  14.         SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;        //关闭计数器
  15.         SysTick->VAL =0X00;                                               //清空计数器         
  16. }
  17. //延时nms
  18. //注意nms的范围
  19. //SysTick->LOAD为24位寄存器,所以,最大延时为:
  20. //nms<=0xffffff*8*1000/SYSCLK
  21. //SYSCLK单位为Hz,nms单位为ms
  22. //对72M条件下,nms<=1864
  23. void delay_ms(u16 nms)
  24. {                                     
  25.         u32 temp;                  
  26.         SysTick->LOAD=(u32)nms*fac_ms;                                //时间加载(SysTick->LOAD为24bit)
  27.         SysTick->VAL =0x00;                                                        //清空计数器
  28.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;        //开始倒数  
  29.         do
  30.         {
  31.                 temp=SysTick->CTRL;
  32.         }while((temp&0x01)&&!(temp&(1<<16)));                //等待时间到达   
  33.         SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;        //关闭计数器
  34.         SysTick->VAL =0X00;                                               //清空计数器                      
  35. }
  36. #endif
您需要登录后才可以回帖 登录 | 注册

本版积分规则

136

主题

1384

帖子

6

粉丝
快速回复 在线客服 返回列表 返回顶部