【stm32】delay详解

1 首先看函数：

1.1 当使用ucos时才有以下部分：
主要实现宏定义与基本函数定义。

#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                  //使用UCOSIIIOS_ERR err; OSSchedLock(&err);                           //UCOSIII的方式,禁止调度，防止打断us延时
#else                                           //否则UCOSIIOSSchedLock();                                //UCOSII的方式,禁止调度，防止打断us延时
#endif
}//us级延时时,恢复任务调度
void delay_osschedunlock(void)
{
#ifdef CPU_CFG_CRITICAL_METHOD                  //使用UCOSIIIOS_ERR err; OSSchedUnlock(&err);                     //UCOSIII的方式,恢复调度
#else                                           //否则UCOSIIOSSchedUnlock();                          //UCOSII的方式,恢复调度
#endif
}//调用OS自带的延时函数延时
//ticks:延时的节拍数
void delay_ostimedly(u32 ticks)
{#ifdef CPU_CFG_CRITICAL_METHODOS_ERR err; OSTimeDly(ticks,OS_OPT_TIME_PERIODIC,&err);   //UCOSIII延时采用周期模式
#elseOSTimeDly(ticks);                          //UCOSII延时
#endif
}//systick中断服务函数,使用ucos时用到
void SysTick_Handler(void)
{   if(delay_osrunning==1)                        //OS开始跑了,才执行正常的调度处理{OSIntEnter();                           //进入中断OSTimeTick();                         //调用ucos的时钟服务程序               OSIntExit();                              //触发任务切换软中断}
}
#endif

1.2 使用ucos的delay函数

#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时

1.3 不使用ucos的delay函数

//延时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;                          //清空计数器
}

1.4 无论是否使用ucos的初始化函数

//初始化延迟函数
//当使用OS的时候,此函数会初始化OS的时钟节拍
//SYSTICK的时钟固定为HCLK时钟的1/8
//SYSCLK:系统时钟
void delay_init()
{#if SYSTEM_SUPPORT_OS                           //如果需要支持OS.u32 reload;
#endifSysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8); //选择外部时钟  HCLK/8fac_us=SystemCoreClock/8000000;                //为系统时钟的1/8
#if SYSTEM_SUPPORT_OS                           //如果需要支持OS.reload=SystemCoreClock/8000000;             //每秒钟的计数次数 单位为M  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    #elsefac_ms=(u16)fac_us*1000;                   //非OS下,代表每个ms需要的systick时钟数
#endif
}

2 什么是SysTick

CM3 内核的处理器，内部包含了一个 SysTick 定时器，SysTick 是一个 24 位的倒计数定时器，当计数到 0 时，将从RELOAD 寄存器中自动重装载定时初值，开始新一轮计数。只要不把它在 SysTick 控制及状态寄存器中的使能位清除，就永不停息。 STM32 的内部 SysTick 来实现延时既不占用中断，也不占用系统定时器。
SysTick 是 MDK 定义了的一个结构体（在 core_m3.h 里面），里面包含 CTRL、LOAD、VAL、CALIB 等 4 个寄存器，

2.1 SysTick->CTRL 的各位定义如图所示：

2.2 SysTick-> LOAD 的定义如图所示：

2.3 SysTick-> VAL 的定义如图所示：

2.4 SysTick-> CALIB 不常用

2.5 ucos下的SysTick以及如何实现delay_ms与delay_us

ucos 运行需要一个系统时钟节拍（类似 “心跳”），而这个节拍是固定的（由 OS_TICKS_PER_SEC 宏定义设置），比如要求 5ms 一次（即可设置OS_TICKS_PER_SEC=200），在 STM32 上面，一般是由 SysTick 来提供这个节拍，也就是SysTick要设置为 5ms 中断一次，为 ucos 提供时钟节拍，而且这个时钟一般是不能被打断的（否则就不准了）。

因为在 ucos 下 SysTick 不能再被随意更改，如果我们还想利用 SysTick 来做 delay_us 或者delay_ms 的延时，就必须想点办法了，这里我们利用的是时钟摘取法。以 delay_us 为例，比如
delay_us(50)，在刚进入 delay_us 的时候先计算好这段延时需要等待的 SysTick 计数次数，这里
为 50 * 9（假设系统时钟为72Mhz，那么SysTick每增加1，就是1/9us）（SysTick每增加9就是1us）（SysTick的频率为div8），然后我们就一直统计SysTick 的计数变化，直到这个值变化了 50*9，一旦检测到变化达到或者超过这个值，就说明延时 50us 时间到了。这样，我们只是抓取 SysTick 计数器的变化，并不需要修改 SysTick 的任何状态，完全不影响 SysTick 作为 UCOS 时钟节拍的功能，这就是实现 delay 和操作系统共用SysTick 定时器的原理。

2.6外部8M晶振原因

Systick 的时钟来自系统时钟 8 分频，正因为如此，系统时钟如果不是 8 的倍数(不能被 8 整除)，则会导致延时函数不准确，这也是我们推荐外部时钟选择 8M 的原因。

3 函数详解

3.1 delay_init

delay_init 函数使用了条件编译，来选择不同的初始化过程，如果不使用 OS 的时候，只是设置一下 SysTick 的时钟源以及确定 fac_us 和 fac_ms 的值。而如果使用 OS 的时候，则会进行一些不同的配置，这里的条件编译是根据 SYSTEM_SUPPORT_OS 这个宏来确定的，该宏在 sys.h 里面定义。

void delay_init()
{#if SYSTEM_SUPPORT_OS                           //如果需要支持OS.u32 reload;
#endifSysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8); //选择外部时钟  HCLK/8fac_us=SystemCoreClock/8000000;                //为系统时钟的1/8
#if SYSTEM_SUPPORT_OS                           //如果需要支持OS.reload=SystemCoreClock/8000000;             //每秒钟的计数次数 单位为M  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    #elsefac_ms=(u16)fac_us*1000;                   //非OS下,代表每个ms需要的systick时钟数
#endif
}

SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);这一句把SysTick的时钟选择外部时钟，SysTick 的时钟源自 HCLK 的 8 分频，假设我们外部晶振为 8M，然后倍频到 72M，那么 SysTick 的时钟即为 9Mhz，也就是SysTick 的计数器 VAL 每减 1，就代表时间过了 1/9us。
fac_us=SystemCoreClock/8000000;这句话就是计算在 SystemCoreClock 时钟频率下延时
1us 需要多少个 SysTick 时钟周期。
fac_ms=(u16)fac_us*1000;就是计算延时 1ms 需要多少个 SysTick 时钟周期，它自然是 1us
的 1000 倍。

在不使用 OS 的时候：fac_us为 us 延时的基数，也就是延时 1us时候SysTick->LOAD 所应设置的值。fac_ms 为 ms 延时的基数，也就是延时 1ms，SysTick->LOAD 所应设置的值。fac_us为 8 位整形数据，fac_ms 为 16 位整形数据。

当使用 OS 的时候，fac_us还是 us 延时的基数，不过这个值不会被写到 SysTick->LOAD寄存器来实现延时，而是通过时钟摘取的办法实现的。而 fac_ms 则代表 ucos自带的延时函数所能实现的最小延时时间（如 delay_ostickspersec=200，那么 fac_ms 就是 5ms）。

3.2 不使用ucos的delay_us

该函数用来延时指定的 us，其参数 nus 为要延时的微秒数。

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;                           //清空计数器
}

实现一次延时 nus的操作：

先把要延时的 us 数换算成 SysTick 的时钟数，然后写入 LOAD 寄存器。
然后清空当前寄存器 VAL 的内容，再开启倒数功能。
等到倒数结束，即延时了 nus。
最后关闭 SysTick，清空 VAL 的值。

nus 的值，不能太大，必须保证 nus<=（2^24）/fac_us，否则将导致延时时间不准确。 temp&0x01，这一句是用来判断 systick 定时器是否还处于开启状态，可以防止 systick 被意外关闭导致的死循环

3.3 ucos下的delay_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调度
}

利用时钟摘取法，ticks 是延时 nus 需要等待的 SysTick 计数次数（也就是延时时间），told 用于记录最近一次的 SysTick->VAL 值，然后 tnow 则是当前的SysTick->VAL 值，通过他们的对比累加，实现 SysTick 计数次数的统计，统计值存放在 tcnt 里面，然后通过对比 tcnt 和 ticks，来判断延时是否到达，从而达到不修改 SysTick 实现 nus 的延时，从而可以和 OS 共用一个 SysTick。
delay_osschedlock 和 delay_osschedunlock 是 OS 提供的两个函数，用于调度上锁和解锁，这里为了防止 OS 在 delay_us 的时候打断延时，可能导致的延时不准，所以我们利用这两个函数来实现免打断，从而保证延时精度！同时，此时的 delay_us，可以实现最长 2^32us 的延时，大概是 4294 秒。

3.4 不使用ucos的delay_ms

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;                          //清空计数器
}

注意：单次延时时间不能超过1864ms，原因如下：
同delay_us大致一样，LOAD 仅仅是一个 24bit 的寄存器，延时的 ms 数不能太长。否则超出了 LOAD 的范围，高位会被舍去，导致延时不准。最大延迟 ms 数可以通过公式：nms<=0xffffff81000/SYSCLK 计算。SYSCLK 单位为 Hz，nms 的单位为 ms。如果时钟为 72M，那么 nms 的最大值为 1864ms。超过这个值，建议通过多次调用 delay_ms 实现，否则就会导致延时不准确。

3.5 ucos下的delay_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));                   //普通方式延时
}

该函数中，delay_osrunning 是 OS 正在运行的标志，delay_osintnesting 则是 OS 中断嵌套次数，必须 delay_osrunning 为真，且 delay_osintnesting 为 0 的时候，才可以调用 OS 自带的延时函数进行延时（可以进行任务调度），delay_ostimedly 函数就是利用 OS 自带的延时函数，实现任务级延时的，其参数代表延时的时钟节拍数（假设 delay_ostickspersec=200 ，那么delay_ostimedly (1)，就代表延时 5ms）。
当 OS 还未运行的时候，我们的 delay_ms 就是直接由 delay_us 实现的，OS 下的 delay_us可以实现很长的延时而不溢出！，所以放心的使用 delay_us 来实现 delay_ms，不过由于 delay_us的时候，任务调度被上锁了，所以还是建议不要用 delay_us 来延时很长的时间，否则影响整个系统的性能。
当 OS 运行的时候，我们的 delay_ms 函数将先判断延时时长是否大于等于 1 个 OS 时钟节拍（fac_ms）,当大于这个值的时候，我们就通过调用 OS 的延时函数来实现（此时任务可以调度），不足 1 个时钟节拍的时候，直接调用 delay_us 函数实现（此时任务无法调度）。