实验五 SysTick—系统定时器

Posted on In Views:

一.实验目标

1.通过编程systick实现精准的延时

2.通过本实验掌握Keil 5新建工程、使用STM32库函数编写应用程序、将程序下载至实验板的步骤、方法；

3.通过本实验掌握STM32的systick精准延时实现。

二.知识储备及设计思路

SysTick 简介

SysTick—系统定时器是属于CM4 内核中的一个外设，内嵌在NVIC 中。系统定时器是一个24bit 的向下递减的计数器，计数器每计数一次的时间为1/SYSCLK，一般我们设置系统时钟SYSCLK 等于180M。当重装载数值寄存器的值递减到0 的时候，系统定时器就产生一次中断，以此循环往复。

因为SysTick 是属于CM4 内核的外设，所以所有基于CM4 内核的单片机都具有这个系统定时器，使得软件在CM4 单片机中可以很容易的移植。系统定时器一般用于操作系统，用于产生时基，维持操作系统的心跳。

SysTick 寄存器介绍

SysTick—系统定时有4 个寄存器，简要介绍如下。在使用SysTick 产生定时的时候，

只需要配置前三个寄存器，最后一个校准寄存器不需要使用。

img

再来看看怎样通过使用SysTick 定时器来实现延时。

延时包含了delay.c和delay.h两个文件，这两个文件用来实现系统的延时功能，其中包含7个函数，其中有4个是支持操作系统，在这里我们不研究这4个函数，只看需要用到的3个函数： 

1
2
3
void delay_init(uint8_t SYSCLK);
void delay_ms(uint16_t nms);
void delay_us(uint32_t nus);

在介绍这些函数之前，我们先了解一下编程思想：CM4内核的处理和CM3一样，内部都包含了一个SysTick定时器，SysTick 是一个24 位的倒计数定时器，当计到0 时，将从RELOAD 寄存器中自动重装载定时初值。只要不把它在SysTick 控制及状态寄存器中的使能位清除，就永不停息。SysTick在《STM32xx中文参考手册》里面基本没有介绍，其详细介绍，请参阅《STM32F3与F4系列Cortex M4内核编程手册》第230页。我们就是利用STM32的内部SysTick来实现延时的，这样既不占用中断，也不占用系统定时器。

这里我们将介绍的是新版本的延时函数，延时函数支持在任意操作系统（OS）下面使用，它可以和操作系统共用SysTick定时器。

这里，我们以UCOSII为例，介绍如何实现操作系统和我们的delay函数共用SysTick定时器。首先，我们简单介绍下UCOSII的时钟：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计数次数，这里为50168（假设系统时钟为168Mhz，因为我们设置systick的频率为系统时钟频率，那么systick每增加1，就是1/168us），然后我们就一直统计systick的计数变化，直到这个值变化了50168，一旦检测到变化达到或者超过这个值，就说明延时50us时间到了。这样，我们只是抓取SysTick计数器的变化，并不需要修改SysTick的任何状态，完全不影响SysTick作为UCOS时钟节拍的功能，这就是实现delay和操作系统共用SysTick定时器的原理。

下面我们开始介绍这几个函数。

三.程序设计

我们不使用操作系统，只看需要用到的三个函数，当需要用到操作系统时，请自行阅读代码。

delay_init函数

该函数用来初始化2个重要参数：fac_us以及fac_ms；同时把SysTick的时钟源选择为外部时钟。具体代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//初始化延迟函数
//当使用ucos的时候,此函数会初始化ucos的时钟节拍
//SYSTICK的时钟固定为AHB时钟
//SYSCLK:系统时钟频率
void delay_init(uint8_t SYSCLK)
{
#if SYSTEM_SUPPORT_OS 						
	//如果需要支持OS.	uint32_t reload;
#endif
    HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);//SysTick频率为HCLK	
    fac_us=SYSCLK;						//不论是否使用OS,fac_us都需要使用
#if SYSTEM_SUPPORT_OS 						//如果需要支持OS.	
    reload=SYSCLK;					  //每秒钟的计数次数 单位为K	  
    reload*=1000000/delay_ostickspersec;	//根据delay_ostickspersec设定溢出时间																							//reload为24位寄存器,最大值:16777216,在180M下,约合0.745s左右		
   	fac_ms=1000/delay_ostickspersec;		//代表OS可以延时的最少单位	  
    SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;//开启SYSTICK中断	
    SysTick->LOAD=reload; 					//每1/OS_TICKS_PER_SEC秒中断一次		
    SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk; //开启SYSTICK
#else
#endif
}

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

SysTick是MDK定义了的一个结构体（在core_m4.h里面），里面包含CTRL、LOAD、VAL、CALIB等4个寄存器，

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

img

图5.1 SysTick->CTRL寄存器各位定义

SysTick-> LOAD的定义如图5. 2所示：

img

图5. 2 SysTick->LOAD寄存器各位定义

SysTick-> VAL的定义如图5. 3所示：

img

图5. 3 SysTick->VAL寄存器各位定义

SysTick-> CALIB不常用，在这里我们也用不到，故不介绍了。

1
SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);

这句代码把SysTick的时钟选择为内核时钟，这里需要注意的是：SysTick的时钟源自HCLK，假设我们外部晶振为25M，然后倍频到180MHZ，那么SysTick的时钟即为180Mhz，也就是SysTick的计数器VAL每减1，就代表时间过了1/180us。所以fac_us=SYSCLK;这句话就是计算在SYSCLK时钟频率下延时1us需要多少个SysTick时钟周期。

在不使用OS的时候：fac_us，为us延时的基数，也就是延时1us，Systick定时器需要走过的时钟周期数。当使用OS的时候，fac_us，还是us延时的基数，不过这个值不会被写到SysTick->LOAD寄存器来实现延时，而是通过时钟摘取的办法实现的（前面已经介绍了）。而fac_ms则代表ucos自带的延时函数所能实现的最小延时时间（如delay_ostickspersec=200，那么fac_ms就是5ms）。

delay_us函数

该函数用来延时指定的us，其参数nus为要延时的微秒数。该函数有使用OS和不使用OS两个版本，这里我们介绍不使用OS的时候，实现函数如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//延时nus//nus为要延时的us数.
//nus:0~190887435(最大值即2^32/fac_us@fac_us=22.5)
void delay_us(uint32_t nus)
{			
	uint32_t ticks;	
	uint32_t told,tnow,tcnt=0;	
	uint32_t reload=SysTick->LOAD;				//LOAD的值	  	 
	ticks=nus*fac_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;            //时间超过/等于要延迟的时间,则退出.
        }
    };
}

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

delay_ms函数

该函数是用来延时指定的ms的，其参数nms为要延时的毫秒数。该函数有使用OS和不使用OS两个版本，这里我们分别介绍，首先是不使用OS的时候，实现函数如下：

1
2
3
4
5
6
7
//延时nms
//nms:要延时的ms数
void delay_ms(uint16_t nms)
{
	uint32_t i;
    for(i=0;i<nms;i++)  delay_us(1000);
}

该函数其实就是多次调用前面所讲的delay_us函数，来实现毫秒级延时的。

HAL库延时函数HAL_Delay解析

前面我们讲解了提供的使用Systick实现延时相关函数。实际上，HAL库有提供延时函数，只不过它只能实现简单的毫秒级别延时，没有实现us级别延时。下面我们列出HAL库实现延时相关的函数。首先是功能配置函数：

//调用HAL_SYSTICK_Config函数配置每隔1ms中断一次：文件stm32f4xx_hal.c中定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
__weak HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority)
{
	/* Configure the SysTick to have interrupt in 1ms time basis*/ 
	if (HAL_SYSTICK_Config(SystemCoreClock / (1000U / uwTickFreq)) > 0U) 
	{
    	return HAL_ERROR; 
    }  
    
    /* Configure the SysTick IRQ priority */ 
    if (TickPriority < (1UL << __NVIC_PRIO_BITS)) 
    {
    	HAL_NVIC_SetPriority(SysTick_IRQn, TickPriority, 0U);
        uwTickPrio = TickPriority; 
    }
    else
    {
    	return HAL_ERROR;
    }  
    
    /* Return function status */ 
    return HAL_OK;
}

//HAL库的SYSTICK配置函数：文件stm32f4xx_hal_context.c中定义

1
2
3
4
uint32_t HAL_SYSTICK_Config(uint32_t TicksNumb)
{
    return SysTick_Config(TicksNumb);
}

//内核的Systick配置函数，配置每隔ticks个systick周期中断一次//文件core_cm4.h中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks)
{
    if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk) 
    {  
        return (1UL);    /* Reload value impossible */ 
    }  
    SysTick->LOAD  = (uint32_t)(ticks - 1UL);             /* set reload register */ 
    NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */ 
    SysTick->VAL  = 0UL;                       /* Load the SysTick Counter Value */ 
    SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk | 
        SysTick_CTRL_TICKINT_Msk  | 
        SysTick_CTRL_ENABLE_Msk;             /* Enable SysTick IRQ and SysTick Timer */ 
    return (0UL);                           /* Function successful */
}

上面三个函数，实际上开放给HAL调用的主要是HAL_InitTick函数，该函数在HAL库初始化函数HAL_Init中会被调用。该函数通过间接调用SysTick_Config函数配置Systick定时器每隔1ms中断一次，永不停歇。

接下来我们来看看延时的逻辑控制代码：

//Systick中断服务函数：文件stm32f4xx_it.c中

1
2
3
4
void SysTick_Handler(void)
{
	HAL_IncTick();
}

//下面代码均在文件stm32f4xx_hal.c中

1
2
3
4
5
6
static __IO uint32_t uwTick; //定义计数全局变量

__weak void HAL_IncTick(void)
{
    uwTick += uwTickFreq;
}
1
2
3
4
__weak uint32_t HAL_GetTick(void)
{
    return uwTick;
}

//开放的HAL延时函数，延时Delay毫秒

1
2
3
4
5
6
7
8
9
10
11
12
13
__weak void HAL_Delay(uint32_t Delay)
{
    uint32_t tickstart = HAL_GetTick();
    uint32_t wait = Delay; 
    /* Add a freq to guarantee minimum wait */
    if (wait < HAL_MAX_DELAY) 
    {
        wait += (uint32_t)(uwTickFreq);
    } 
    while((HAL_GetTick() - tickstart) < wait) 
    {
    }
}

HAL库实现延时功能非常简单，首先定义了一个32位全局变量uwTick，在Systick中断服务函数SysTick_Handler中通过调用HAL_IncTick实现uwTick值不断增加，也就是每隔1ms增加1。而HAL_Delay函数在进入函数之后先记录当前uwTick的值，然后不断在循环中读取uwTick当前值，进行减运算，得出的就是延时的毫秒数，整个逻辑非常简单也非常清晰。

但是，HAL库的延时函数有一个局限性，在中断服务函数中使用HAL_Delay会引起混乱，因为它是通过中断方式实现，而Systick的中断优先级是最低的，所以在中断中运行HAL_Delay会导致延时出现严重误差。所以一般情况下，推荐大家使用我们提供的延时函数库。

四.实验结果

将编译好的代码下载到实验板中，按下复位键，流水灯会间隔1s闪烁。

五.思考与拓展

本实验通过使用systick实现延时，还有没其他精确延时方式？和怎么实现？