ID da página inicial do blog CSDN
: Eterlove
, um golpe de cada vez, registrando minha vida de estudo! De pé sobre ombros
de gigantes!
Este artigo é original, por favor, indique a fonte e o autor para reimpressão!
prefácio
Costumamos usar atraso para concluir alguns requisitos do projeto, muitas vezes usando o atraso de software alcançado pelo loop ocioso da CPU para alcançar, o método tem as vantagens de ser simples, mas haverá um problema de baixa precisão de tempo , e este é um método com óbvio desvantagens, porque quando a função de atraso está em andamento, o sistema não pode realizar outras operações, o que reduz muito a eficiência do sistema.
O segundo método é usar o temporizador TIM para conseguir um atraso preciso, mas parece que os recursos são muito dispendiosos. Neste momento, o temporizador SysTick do STM32 vem a calhar, mas a introdução do temporizador SysTick, ST não descreve muito no manual STM32Reference. , então registre a experiência no blog.
//空循环达到的软件延时
void Delay_ms(unsigned int ms)
{
unsigned int i,j;
for(i=0; i<ms; i++)
{
for(j=0; j<8450; j++) ;
}
}
1. Introdução ao temporizador SysTick
Há um cronômetro Systick no núcleo do ARM Cortex-M3, que é um cronômetro de contagem regressiva de 24 bits . Quando a contagem chegar a 0, ele recarregará automaticamente o valor inicial do registrador Load.
O texto original do manual STM32Reference é que o
RCC é usado como o relógio externo do timer do sistema Cortex (SysTick) depois de dividir o relógio AHB (HCLK) por 8 . Ao definir o controle SysTick e o registro de status, o relógio acima ou o relógio Cortex (HCLK) pode ser selecionado como o relógio SysTick. O clock ADC é obtido dividindo o clock APB2 de alta velocidade por 2, 4, 6 ou 8.
英文版为STM32Manual de referência Rev 21
O RCC alimenta o relógio externo Cortex® System Timer (SysTick) com o relógio AHB (HCLK) dividido por 8. O SysTick pode trabalhar com este relógio ou com o relógio Cortex® (HCLK), configurável no registro de controle e status do SysTick. Os ADCs são cronometrados pelo clock do domínio de alta velocidade (APB2) dividido por 2, 4, 6 ou 8.
Conforme mostrado na figura e no texto acima, existem duas fontes de clock para o temporizador SysTick, uma é o clock após HCLK ser dividido por 8 –> HCLK/8 (na verdade 72MHZ/8 = 9MHZ), e a outra é HCLK sem frequência Relógio de divisão —> HCLK (72MHZ)
Existe uma definição de macro da fonte de relógio SysTick_clock_source na linha P172 do arquivo misc.h!
//misc.h文件P172行处
/** @defgroup SysTick_cl
ock_source
* @{
*/
#define SysTick_CLKSource_HCLK_Div8 ((uint32_t)0xFFFFFFFB)
#define SysTick_CLKSource_HCLK ((uint32_t)0x00000004)
2. Registro SysTick
Primeiro veja a definição na função da biblioteca ST, no arquivo core_cm3.h linha P365 ~ linha P371
//core_cm3.h 文件P365行~P371行
typedef struct
{
__IO uint32_t CTRL; /*!< Offset: 0x00 SysTick Control and Status Register */
__IO uint32_t LOAD; /*!< Offset: 0x04 SysTick Reload Value Register */
__IO uint32_t VAL; /*!< Offset: 0x08 SysTick Current Value Register */
__I uint32_t CALIB; /*!< Offset: 0x0C SysTick Calibration Register */
} SysTick_Type;
Introdução ao registro
CTRL ----->SysTick Controle e Registro de Status Controle e Registro de Status
LOAD----->SysTick Reload Value Register Reload Value Register
VAL------->SysTick Current Value RegisterCurrent Value Register
CALIB-- --->Registro de Valor de Calibração do SysTick
Controle SysTick e Registro de Status
Para uma descrição mais detalhada dos registros, consulte o documento Cortex™-M3 r1p1 Technical Reference Manual (TRM) , que não está listado aqui.
A função SysTick_Config() é uma função CMSIS que configura o registrador SysTick Reload cujo valor é passado como parâmetro da função.
//core_cm3.h P1694行~P1705行
static __INLINE uint32_t SysTick_Config(uint32_t ticks)
{
if (ticks > SysTick_LOAD_RELOAD_Msk) return (1); /* Reload value impossible */
SysTick->LOAD = (ticks & SysTick_LOAD_RELOAD_Msk) - 1; /* set reload register */
NVIC_SetPriority (SysTick_IRQn, (1<<__NVIC_PRIO_BITS) - 1); /* set Priority for Cortex-M0 System Interrupts */
SysTick->VAL = 0; /* 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 (0); /* Function successful */
}
3. Etapas para configurar o temporizador SysTick
1. Configure a fonte do relógio
void SysTick_CLKSourceConfig(uint32_t SysTick_CLKSource)
//在misc.c文件
void SysTick_CLKSourceConfig(uint32_t SysTick_CLKSource)
{
/* Check the parameters */
assert_param(IS_SYSTICK_CLK_SOURCE(SysTick_CLKSource));
if (SysTick_CLKSource == SysTick_CLKSource_HCLK)
{
SysTick->CTRL |= SysTick_CLKSource_HCLK;
}
else
{
SysTick->CTRL &= SysTick_CLKSource_HCLK_Div8;
}
}
2. Calcular
o valor de recarga Valor de recarga = SysTick Counter Clock (Hz) x base de tempo desejada (s)
3. Habilitar interrupção do SysTick
4. Habilitar SysTick Counter
4. Código do programa (comentários detalhados)
#include "stm32f10x.h" //包含需要的头文件
#include "delay.h"
/*-------------------------------------------------*/
/*函数名：初始化延迟计数器函数 */
/*参 数：无 */
/*返回值：无 */
/*-------------------------------------------------*/
void Delay_Init(void)
{
SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);
//SysTick_CLKSource_HCLK_Div8 = 8 表示分频系数
//因为分频系数我们设置为8，所以SysTick（滴答时钟）的频率是主频率的1/8
//通常主频率为最大的72M，那么SysTick的频率是9M
//那么SysTick计数器的1个数，代表(1/9)us
}
/*-------------------------------------------------*/
/*函数名：延迟微秒函数 */
/*参 数：us：延时多少微秒 */
/*返回值：无 */
/*-------------------------------------------------*/
void delay_us(unsigned int us)
{
unsigned int temp; //定义一个变量待用
SysTick->LOAD=us*9; //计数器的重载值，要注意SysTick是倒数计数的
//SysTick计数器每倒数一个数是1/9微秒，所以我们用us*9，就是计数器的重载值
SysTick->VAL=0x00; //清空当前计数器的值
SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ; //使能SysTick计数器，重载值加载到计数器中，开始倒数计数
do{
temp=SysTick->CTRL; //循环读取SysTick状态寄存器，用于判断计时结束与否
}while(temp&0x01&&!(temp&(1<<16))); //等待时间到达
SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk; //关闭计数器
}
/*-------------------------------------------------*/
/*函数名：延迟毫秒函数 */
/*参 数：ms：延时多少毫秒 */
/*返回值：无 */
/*-------------------------------------------------*/
void delay_ms(unsigned int ms)
{
//我们首先注意一个问题SysTick时钟计数器是24位的，9M频率下，总共能延时1864.135ms
//所有我们以1800为界限，小于1800的延时一次计数就行，大于1800的多次计数
unsigned char i; //定义一个变量待用
unsigned int temp; //定义一个变量待用
/*-----------if判断，小于1800ms延时的情况，执行if分支------------------*/
if(ms<1800){
SysTick->LOAD=(unsigned int)ms*9*1000; //计数器的重载值，要注意SysTick是倒数计数的
//SysTick计1个数是1/9微秒，换算成ms的话，乘以9再乘以1000，就是计数器的重载值
SysTick->VAL=0x00; //清空当前计数器的值
SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ; //使能SysTick计数器，重载值加载到计数器中，开始倒数
do{
temp=SysTick->CTRL; //循环读取SysTick状态寄存器，判断计时结束与否
}while(temp&0x01&&!(temp&(1<<16))); //等待时间到达
SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;} //关闭计数器
/*--------------大于1800ms延时的情况，执行else分支-------------------*/
else{
for(i=0;i<(ms/1800);i++){
//除以1800，整数部分，用for循环，每次延时1800ms
SysTick->LOAD=(unsigned int)1800*9*1000; //计数器的重载值，要注意SysTick是倒数计数的
//SysTick一个数是1/9微秒，1800ms就是 1800*9*1000
SysTick->VAL=0x00; //清空当前计数器的值
SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ; //使能SysTick计数器，重载值加载到计数器中，开始倒数
do{
temp=SysTick->CTRL; //循环读取SysTick状态寄存器，判断计时结束与否
}while(temp&0x01&&!(temp&(1<<16))); //等待时间到达
SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;} //关闭计数器
//接下来余数部分的延时
SysTick->LOAD=(unsigned int)(ms%1800)*9*1000; //计数器的重载值，要注意SysTick是倒数计数的
//SysTick一个数是1/9微秒，余数部分就是(ms%1800)*9*1000
SysTick->VAL =0x00; //清空当前计数器的值
SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ; //使能SysTick计数器，重载值加载到计数器中，开始倒数
do{
temp=SysTick->CTRL; //循环读取SysTick状态寄存器，判断计时结束与否
}while(temp&0x01&&!(temp&(1<<16))); //等待时间到达
SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk; //关闭计数器
}
}
Para uma descrição detalhada do núcleo Cortex-M3, temporizador SysTick e NVIC, consulte outro documento ST e um documento ARM: "Manual de programação STM32F10xxx Cortex-M3" e "Manual de referência técnica Cortex™-M3"