打印
[其他ST产品]

正点原子STM32F1工程delay文件阅读

[复制链接]
3485|21
手机看帖
扫描二维码
随时随地手机跟帖
跳转到指定楼层
楼主
慢醇|  楼主 | 2023-7-8 13:23 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
正点原子STM32F1工程SYSTEM文件夹中delay代码阅读
为方便大家搭建工程,正点原子团队自己编写了sys.c、delay.c、usart.c三个文件,可用于任何STM32F1工程的搭建,提供诸如延时、串口通信等功能,下面就delay.c进行阅读,和大家分享我的理解思路。


首先先把源代码贴上来:


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

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

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

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


//us级延时时,关闭任务调度(防止打断us级延迟)
void delay_osschedlock(void)
{
#ifdef CPU_CFG_CRITICAL_METHOD                                   //使用UCOSIII
        OS_ERR err;
        OSSchedLock(&err);                                                        //UCOSIII的方式,禁止调度,防止打断us延时
#else                                                                                        //否则UCOSII
        OSSchedLock();                                                                //UCOSII的方式,禁止调度,防止打断us延时
#endif
}

//us级延时时,恢复任务调度
void delay_osschedunlock(void)
{       
#ifdef CPU_CFG_CRITICAL_METHOD                                   //使用UCOSIII
        OS_ERR err;
        OSSchedUnlock(&err);                                                //UCOSIII的方式,恢复调度
#else                                                                                        //否则UCOSII
        OSSchedUnlock();                                                        //UCOSII的方式,恢复调度
#endif
}

//调用OS自带的延时函数延时
//ticks:延时的节拍数
void delay_ostimedly(u32 ticks)
{
#ifdef CPU_CFG_CRITICAL_METHOD
        OS_ERR err;
        OSTimeDly(ticks,OS_OPT_TIME_PERIODIC,&err);        //UCOSIII延时采用周期模式
#else
        OSTimeDly(ticks);                                                        //UCOSII延时
#endif
}

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

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

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

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

#if SYSTEM_SUPPORT_OS                                                          //如果需要支持OS.
//延时nus
//nus为要延时的us数.                                                                                      
void delay_us(u32 nus)
{               
        u32 ticks;
        u32 told,tnow,tcnt=0;
        u32 reload=SysTick->LOAD;                                        //LOAD的值                     
        ticks=nus*fac_us;                                                         //需要的节拍数                           
        tcnt=0;
        delay_osschedlock();                                                //阻止OS调度,防止打断us延时
        told=SysTick->VAL;                                                //刚进入时的计数器值
        while(1)
        {
                tnow=SysTick->VAL;       
                if(tnow!=told)
                {            
                        if(tnow<told)tcnt+=told-tnow;                //这里注意一下SYSTICK是一个递减的计数器就可以了.
                        else tcnt+=reload-tnow+told;            
                        told=tnow;
                        if(tcnt>=ticks)break;                                //时间超过/等于要延迟的时间,则退出.
                }  
        };
        delay_osschedunlock();                                                //恢复OS调度                                                                            
}
//延时nms
//nms:要延时的ms数
void delay_ms(u16 nms)
{       
        if(delay_osrunning&&delay_osintnesting==0)        //如果OS已经在跑了,并且不是在中断里面(中断里面不能任务调度)            
        {                 
                if(nms>=fac_ms)                                                        //延时的时间大于OS的最少时间周期
                {
                           delay_ostimedly(nms/fac_ms);                //OS延时
                }
                nms%=fac_ms;                                                        //OS已经无法提供这么小的延时了,采用普通方式延时   
        }
        delay_us((u32)(nms*1000));                                        //普通方式延时  
}
#else //不用OS时
//延时nus
//nus为要延时的us数.                                                                                      
void delay_us(u32 nus)
{               
        u32 temp;                     
        SysTick->LOAD=nus*fac_us;                                         //时间加载                           
        SysTick->VAL=0x00;                                                //清空计数器
        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;        //开始倒数          
        do
        {
                temp=SysTick->CTRL;
        }while((temp&0x01)&&!(temp&(1<<16)));                //等待时间到达   
        SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;        //关闭计数器
        SysTick->VAL =0X00;                                               //清空计数器         
}
//延时nms
//注意nms的范围
//SysTick->LOAD为24位寄存器,所以,最大延时为:
//nms<=0xffffff*8*1000/SYSCLK
//SYSCLK单位为Hz,nms单位为ms
//对72M条件下,nms<=1864
void delay_ms(u16 nms)
{                                     
        u32 temp;                  
        SysTick->LOAD=(u32)nms*fac_ms;                                //时间加载(SysTick->LOAD为24bit)
        SysTick->VAL =0x00;                                                        //清空计数器
        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;        //开始倒数  
        do
        {
                temp=SysTick->CTRL;
        }while((temp&0x01)&&!(temp&(1<<16)));                //等待时间到达   
        SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;        //关闭计数器
        SysTick->VAL =0X00;                                               //清空计数器                      
}
#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 | 只看该作者
下面开始代码讲解

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


首先是这一部分,很简单,一个条件编译,如果使用操作系统的话,包含一个头文件,这个头文件是操作系统使用的。需要注意的是SYSTEM_SUPPORT_OS是在sys.h中define的,所以要在sys.h中修改它的值。

使用特权

评论回复
5
慢醇|  楼主 | 2023-7-8 13:45 | 只看该作者
static u8  fac_us=0;                                                        //us延时倍乘数                           
static u16 fac_ms=0;                                                        //ms延时倍乘数,在ucos下,代表每个节拍的ms数


接下来是两个变量的定义,fac_us和fac_ms,前者是代表延时1us需要的SysTick滴答数,后者是代表延时1ms需要的SysTick嘀嗒数,自然fac_ms = 1000*fac_us,但是在支持操作系统时这两个变量的意思也发生了变化,后面再看。

使用特权

评论回复
6
慢醇|  楼主 | 2023-7-8 14:15 | 只看该作者
#if SYSTEM_SUPPORT_OS
//支持UCOSII
#ifdef         OS_CRITICAL_METHOD                                                //OS_CRITICAL_METHOD定义了,说明要支持UCOSII                               
#define delay_osrunning                OSRunning                        //OS是否运行标记,0,不运行;1,在运行
#define delay_ostickspersec        OS_TICKS_PER_SEC        //OS时钟节拍,即每秒调度次数
#define delay_osintnesting         OSIntNesting                //中断嵌套级别,即中断嵌套次数
#endif

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

使用特权

评论回复
7
慢醇|  楼主 | 2023-7-8 14:16 | 只看该作者
条件编译,define了一些使用操作系统时需要用到的变量,上面可以支持UCOS-ii和UCOS-iii。OS_CRITICAL_METHOD和CPU_CFG_CRITICAL_METHOD应该是在对应的操作系统源码中定义的。

delay_osrunning是系统正在运行的标志,delay_ostickspersec是系统一秒钟对应的嘀嗒数,需要注意的是:这个嘀嗒数并不对应SysTick嘀嗒数,所以需要在SysTick嘀嗒数和OSTick嘀嗒数之间进行转换,后面代码读不懂的话很可能就是不知道这个的缘故。

使用特权

评论回复
8
慢醇|  楼主 | 2023-7-8 14:21 | 只看该作者
delay_osintnesting代表中断嵌套次数,主要是用于判断当前是否处于中断中。

//us级延时时,关闭任务调度(防止打断us级延迟)
void delay_osschedlock(void)
{
#ifdef CPU_CFG_CRITICAL_METHOD                                   //使用UCOSIII
        OS_ERR err;
        OSSchedLock(&err);                                                        //UCOSIII的方式,禁止调度,防止打断us延时
#else                                                                                        //否则UCOSII
        OSSchedLock();                                                                //UCOSII的方式,禁止调度,防止打断us延时
#endif
}

//us级延时时,恢复任务调度
void delay_osschedunlock(void)
{       
#ifdef CPU_CFG_CRITICAL_METHOD                                   //使用UCOSIII
        OS_ERR err;
        OSSchedUnlock(&err);                                                //UCOSIII的方式,恢复调度
#else                                                                                        //否则UCOSII
        OSSchedUnlock();                                                        //UCOSII的方式,恢复调度
#endif
}

使用特权

评论回复
9
慢醇|  楼主 | 2023-7-8 14:22 | 只看该作者
这两个函数也没什么好讲的,一个是关闭操作系统任务调度的函数,一个是恢复操作系统任务调度的函数。至于为什么要关闭任务调度,是为了防止在我们运行delay_us函数的时候出现高优先级的任务打断delay_us函数执行造成延时不准的情况发生。
//调用OS自带的延时函数延时
//ticks:延时的节拍数
void delay_ostimedly(u32 ticks)
{
#ifdef CPU_CFG_CRITICAL_METHOD
        OS_ERR err;
        OSTimeDly(ticks,OS_OPT_TIME_PERIODIC,&err);        //UCOSIII延时采用周期模式
#else
        OSTimeDly(ticks);                                                        //UCOSII延时
#endif
}

使用特权

评论回复
10
慢醇|  楼主 | 2023-7-8 14:22 | 只看该作者
这个函数则是对操作系统自带的延时函数的封装,同样也是分UCOS-iii和UCOS-ii。
//systick中断服务函数,使用ucos时用到
void SysTick_Handler(void)
{       
        if(delay_osrunning==1)                                                //OS开始跑了,才执行正常的调度处理
        {
                OSIntEnter();                                                        //进入中断
                OSTimeTick();                                               //调用ucos的时钟服务程序               
                OSIntExit();                                                        //触发任务切换软中断
        }
}
#endif

使用特权

评论回复
11
慢醇|  楼主 | 2023-7-8 14:22 | 只看该作者
这个函数我暂时也不太懂,先不讲。。。
//初始化延迟函数
//当使用OS的时候,此函数会初始化OS的时钟节拍
//SYSTICK的时钟固定为HCLK时钟的1/8
//SYSCLK:系统时钟
void delay_init()
{
#if SYSTEM_SUPPORT_OS                                                          //如果需要支持OS.
        u32 reload;
#endif
        SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);        //选择外部时钟  HCLK/8
        fac_us=SystemCoreClock/8000000;                                //为系统时钟的1/8  
#if SYSTEM_SUPPORT_OS                                                          //如果需要支持OS.
        reload=SystemCoreClock/8000000;                                //每秒钟的计数次数 单位为K          
        reload*=1000000/delay_ostickspersec;                //根据delay_ostickspersec设定溢出时间
                                                                                                //reload为24位寄存器,最大值:16777216,在72M下,约合1.86s左右       
        fac_ms=1000/delay_ostickspersec;                        //代表OS可以延时的最少单位          

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

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

使用特权

评论回复
12
慢醇|  楼主 | 2023-7-8 14:22 | 只看该作者
delay的初始化函数。
SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);        //选择外部时钟  HCLK/8

使用特权

评论回复
13
慢醇|  楼主 | 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;则没有什么好说的,接下来还是主要来看支持操作系统的代码。

使用特权

评论回复
14
慢醇|  楼主 | 2023-7-8 14:29 | 只看该作者
reload=SystemCoreClock/8000000;                                //每秒钟的计数次数 单位为K           
reload*=1000000/delay_ostickspersec;                //根据delay_ostickspersec设定溢出时间
                                                                                        //reload为24位寄存器,最大值:16777216,在72M下,约合1.86s左右       
fac_ms=1000/delay_ostickspersec;                        //代表OS可以延时的最少单位          

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

使用特权

评论回复
15
慢醇|  楼主 | 2023-7-8 14:29 | 只看该作者
reload是在前面定义的,reload=SystemCoreClock/8000000;这和上面的fac_us=SystemCoreClock/8000000;是一模一样的,也就是9咯,但是后面的注释中写 “每秒钟的计数次数,单位为K”,这注释显然是错的,要么就是每毫秒的计数次数,单位为K,要么就是每秒钟的计数次数,单位为M。总而言之就是错了。后面的reload*=1000000/delay_ostickspersec;就比较难理解了。

使用特权

评论回复
16
慢醇|  楼主 | 2023-7-8 14:29 | 只看该作者

reload本来是延时1us需要的SysTick嘀嗒数,乘以1M之后就变成了延时1s需要的SysTick嘀嗒数,再除以操作系统延时1s需要的OSTick嘀嗒数,其实就得到了一个转化比,SysTick的reload个嘀嗒相当于OSTick的1个嘀嗒,将SysTick的重装载寄存器设置为reload,这样SysTick才能为OS提供嘀嗒,前面已经说了,SysTick就是为OS提供嘀嗒服务的。

使用特权

评论回复
17
慢醇|  楼主 | 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。

使用特权

评论回复
18
慢醇|  楼主 | 2023-7-8 14:34 | 只看该作者
接下来就简单了,支持操作系统情况下的us延时函数和ms延时函数:
#if SYSTEM_SUPPORT_OS                                                          //如果需要支持OS.
//延时nus
//nus为要延时的us数.                                                                                      
void delay_us(u32 nus)
{               
        u32 ticks;
        u32 told,tnow,tcnt=0;
        u32 reload=SysTick->LOAD;                                        //LOAD的值                     
        ticks=nus*fac_us;                                                         //需要的节拍数                           
        tcnt=0;
        delay_osschedlock();                                                //阻止OS调度,防止打断us延时
        told=SysTick->VAL;                                                //刚进入时的计数器值
        while(1)
        {
                tnow=SysTick->VAL;       
                if(tnow!=told)
                {            
                        if(tnow<told)tcnt+=told-tnow;                //这里注意一下SYSTICK是一个递减的计数器就可以了.
                        else tcnt+=reload-tnow+told;            
                        told=tnow;
                        if(tcnt>=ticks)break;                                //时间超过/等于要延迟的时间,则退出.
                }  
        };
        delay_osschedunlock();                                                //恢复OS调度                                                                            
}
//延时nms
//nms:要延时的ms数
void delay_ms(u16 nms)
{       
        if(delay_osrunning&&delay_osintnesting==0)        //如果OS已经在跑了,并且不是在中断里面(中断里面不能任务调度)            
        {                 
                if(nms>=fac_ms)                                                        //延时的时间大于OS的最少时间周期
                {
                           delay_ostimedly(nms/fac_ms);                //OS延时
                }
                nms%=fac_ms;                                                        //OS已经无法提供这么小的延时了,采用普通方式延时   
        }
        delay_us((u32)(nms*1000));                                        //普通方式延时  
}

使用特权

评论回复
19
慢醇|  楼主 | 2023-7-8 14:34 | 只看该作者
前面说了,有操作系统的情况下SysTick是给OS提供服务的,所以这种情况下不能随意修改SysTick的LOAD和VAL寄存器的值,必须在不改变SysTick的情况下延时,大概的思路就是先记录开始延时时的计数值,然后计算延时这么长时间需要多少个嘀嗒,然后一直等待这么多个嘀嗒,这个过程是不能被打断的,所以需要关闭OS调度。

而ms的延时则是分两部分,对于OSTick的整数部分,采用操作系统自带的延时函数,对于剩余的部分,采用delay_us进行延时。

使用特权

评论回复
20
慢醇|  楼主 | 2023-7-8 14:34 | 只看该作者
下面是不带操作系统的延时函数,不给操作系统提供服务的情况下可以随意的修改SysTick,所以需要延时多久只需要修改SysTick的LOAD和VAL寄存器就行啦。
#else //不用OS时
//延时nus
//nus为要延时的us数.                                                                                      
void delay_us(u32 nus)
{               
        u32 temp;                     
        SysTick->LOAD=nus*fac_us;                                         //时间加载                           
        SysTick->VAL=0x00;                                                //清空计数器
        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;        //开始倒数          
        do
        {
                temp=SysTick->CTRL;
        }while((temp&0x01)&&!(temp&(1<<16)));                //等待时间到达   
        SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;        //关闭计数器
        SysTick->VAL =0X00;                                               //清空计数器         
}
//延时nms
//注意nms的范围
//SysTick->LOAD为24位寄存器,所以,最大延时为:
//nms<=0xffffff*8*1000/SYSCLK
//SYSCLK单位为Hz,nms单位为ms
//对72M条件下,nms<=1864
void delay_ms(u16 nms)
{                                     
        u32 temp;                  
        SysTick->LOAD=(u32)nms*fac_ms;                                //时间加载(SysTick->LOAD为24bit)
        SysTick->VAL =0x00;                                                        //清空计数器
        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;        //开始倒数  
        do
        {
                temp=SysTick->CTRL;
        }while((temp&0x01)&&!(temp&(1<<16)));                //等待时间到达   
        SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;        //关闭计数器
        SysTick->VAL =0X00;                                               //清空计数器                      
}
#endif

使用特权

评论回复
发新帖 我要提问
您需要登录后才可以回帖 登录 | 注册

本版积分规则

118

主题

1234

帖子

5

粉丝