参考：
-正点原子定时器
定时器概述
定时器定时原理
定时器分类
定时器特性表
基本、通用、高级定时器的功能整体区别
特点芯片定时器资源和引脚
参考hal库usart外设->查看引脚定义
定时器的主从模式
核心概念
- 主模式（Master）：主动发信号。定时器自己跑，并通过 TRGO（触发输出）给别的定时器 / 外设发 “命令”（同步信号）。
- 从模式（Slave）：被动听命令。定时器自己不主动跑，等待外部信号或别的定时器通过 TRGI（触发输入）来控制它（启动、停止、清零、当时钟）。
主模式（Master Mode）详解
作用：让一个定时器作为指挥官，控制其他定时器或外设同步启动 / 停止。
怎么工作？
配置定时器在特定事件发生时，通过 TRGO 引脚 / 内部线 输出一个触发脉冲：
- 计数器 CNT 归零 (Update) 时发 TRGO
- 捕获 / 比较事件发生 (Capture) 时发 TRGO
- 使能时发 TRGO 等
典型应用：
- 多定时器同步：TIM2（主）发 TRGO → 控制 TIM3、TIM4 同时启动。
- 触发 ADC 采样：定时器定时发 TRGO → 自动启动 ADC 转换（硬件触发，比软件准）。
- 触发 DMA：定时事件自动启动数据传输。
从模式（Slave Mode）详解
作用：让定时器作为执行者，受控于外部信号或主定时器。
STM32 定时器有 5 种常用从模式：
- 复位模式 (Reset) —— 最常用（测频率）
- 行为：收到 TRGI 上升沿时，硬件自动把 CNT 清 0。
- 应用：输入捕获测周期 / 频率。（就是你上一问的 “硬件清除计数器”）
- 原理：信号每来一个周期，计数器就被清零一次，CCR 里的值就是精准周期。
- 门控模式 (Gated) —— 测脉宽
- 行为：TRGI 高电平时计数，低电平时暂停。
- 应用：测量高电平持续时间（脉冲宽度）。
- 触发模式 (Trigger)
- 行为：收到 TRGI 信号才开始计数，没收到就一直停着。
- 应用：多定时器精准同步启动、外部信号触发计时。
- 外部时钟模式 1 (External Clock Mode 1)
- 行为：把 TRGI 信号当作计数器的时钟。每来一个脉冲，CNT+1。
- 应用：外部脉冲计数、转速测量。
- 编码器模式 (Encoder Mode)
- 行为：专门响应编码器 A/B 相脉冲，自动判断正反转。
- 应用：电机编码器测速。
主 / 从模式对比表
| 特性 |
主模式 (Master) |
从模式 (Slave) |
| 角色 |
指挥官 |
执行者 |
| 信号流向 |
输出 TRGO |
输入 TRGI |
| 控制权 |
自主运行，控制别人 |
被动，被别人控制 |
| 核心用途 |
同步其他外设、发命令 |
测频率、测脉宽、同步计数、编码器测速 |
基本定时器
简介
框图
计数模式及溢出条件
相关寄存器
溢出时间计算方法
hal库配置
相关函数
中断实验配置步骤
示例
定时器中断控制led闪烁
宏定义
1
2
3
4
| #define BTIM_TIMX_INT TIM6
#define BTIM_TIMX_INT_IRQn TIM6_DAC_IRQn
#define BTIM_TIMX_INT_IRQHandler TIM6_DAC_IRQHandler
#define BTIM_TIMX_INT_CLK_ENABLE() do{ __HAL_RCC_TIM6_CLK_ENABLE(); }while(0)
|
全局变量
1
| TIM_HandleTypeDef g_timx_handle;
|
初始化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
void btim_timx_int_init(uint16_t arr, uint16_t psc)
{
g_timx_handle.Instance = BTIM_TIMX_INT;
g_timx_handle.Init.Prescaler = psc;
g_timx_handle.Init.CounterMode = TIM_COUNTERMODE_UP;
g_timx_handle.Init.Period = arr;
HAL_TIM_Base_Init(&g_timx_handle);
HAL_TIM_Base_Start_IT(&g_timx_handle);
}
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
{
if (htim->Instance == BTIM_TIMX_INT)
{
BTIM_TIMX_INT_CLK_ENABLE();
HAL_NVIC_SetPriority(BTIM_TIMX_INT_IRQn, 1, 3);
HAL_NVIC_EnableIRQ(BTIM_TIMX_INT_IRQn);
}
}
|
中断服务函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
void BTIM_TIMX_INT_IRQHandler(void)
{
HAL_TIM_IRQHandler(&g_timx_handle);
}
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
if (htim->Instance == BTIM_TIMX_INT)
{
LED1_TOGGLE();
}
}
|
主函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| int main(void)
{
HAL_Init();
sys_stm32_clock_init(RCC_PLL_MUL9);
delay_init(72);
led_init();
btim_timx_int_init(5000 - 1, 7200 - 1);
while (1)
{
LED0_TOGGLE();
delay_ms(200);
}
}
|
通用定时器
简介
框图
计数器时钟源
总览
外部时钟模式1
外部时钟模式2
使用一个定时器作为另一个定时器的预分频器（F1为例）
计数器时钟源寄存器设置方法（F1为例）
更新中断
PWM输出
简介
通过捕获比较寄存器(TIMX_CCRX)的值和计数器(TIMX_CNT)的值相比较，从而输出高低电平，实现PWM输出。
框图
定时器输出PWM原理
PWM模式
hal库配置PWM输出
输入捕获
简介
通过捕获输入信号的上升沿或下降沿，将计数器(TIMX_CNT)的值存储到捕获寄存器(TIMX_CCRx)中，同时用从模式或中断清空计数器(TIMX_CNT)。
通过捕获寄存器(TIMX_CCRx)的值和定时器更新次数，可以计算出输入信号的周期。
也可以直接分别记录两次捕获寄存器(TIMX_CCRx)的值和期间定时器更新次数，计算出输入信号的周期。
框图
输入捕获脉宽测量原理
hal库配置
示例
定时器中断控制led闪烁
宏定义
1
2
3
4
| #define GTIM_TIMX_INT TIM3
#define GTIM_TIMX_INT_IRQn TIM3_IRQn
#define GTIM_TIMX_INT_IRQHandler TIM3_IRQHandler
#define GTIM_TIMX_INT_CLK_ENABLE() do{ __HAL_RCC_TIM3_CLK_ENABLE(); }while(0)
|
全局变量
1
| TIM_HandleTypeDef g_timx_handle;
|
初始化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
void gtim_timx_int_init(uint16_t arr, uint16_t psc)
{
GTIM_TIMX_INT_CLK_ENABLE();
g_timx_handle.Instance = GTIM_TIMX_INT;
g_timx_handle.Init.Prescaler = psc;
g_timx_handle.Init.CounterMode = TIM_COUNTERMODE_UP;
g_timx_handle.Init.Period = arr;
HAL_TIM_Base_Init(&g_timx_handle);
HAL_NVIC_SetPriority(GTIM_TIMX_INT_IRQn, 1, 3);
HAL_NVIC_EnableIRQ(GTIM_TIMX_INT_IRQn);
HAL_TIM_Base_Start_IT(&g_timx_handle);
}
|
中断服务函数
1
2
3
4
5
6
7
8
9
| void GTIM_TIMX_INT_IRQHandler(void)
{
if(__HAL_TIM_GET_FLAG(&g_timx_handle, TIM_FLAG_UPDATE) != RESET)
{
LED1_TOGGLE();
__HAL_TIM_CLEAR_IT(&g_timx_handle, TIM_IT_UPDATE);
}
}
|
主函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| int main(void)
{
HAL_Init();
sys_stm32_clock_init(RCC_PLL_MUL9);
delay_init(72);
led_init();
gtim_timx_int_init(5000 - 1, 7200 - 1);
while(1)
{
LED0_TOGGLE();
delay_ms(200);
}
}
|
PWM输出展现呼吸灯效果
PA0接灯
宏定义
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
#define GTIM_TIMX_PWM_CHY_GPIO_PORT GPIOA
#define GTIM_TIMX_PWM_CHY_GPIO_PIN GPIO_PIN_0
#define GTIM_TIMX_PWM_CHY_GPIO_CLK_ENABLE() do{ __HAL_RCC_GPIOA_CLK_ENABLE(); }while(0)
#define GTIM_TIMX_PWM_CHY_GPIO_REMAP() do{__HAL_RCC_AFIO_CLK_ENABLE();\
__HAL_AFIO_REMAP_TIM3_PARTIAL();\
}while(0)
#define GTIM_TIMX_PWM TIM2
#define GTIM_TIMX_PWM_CHY TIM_CHANNEL_1
#define GTIM_TIMX_PWM_CHY_CCRX TIM2->CCR2
#define GTIM_TIMX_PWM_CHY_CLK_ENABLE() do{ __HAL_RCC_TIM2_CLK_ENABLE(); }while(0)
|
全局变量
1
| TIM_HandleTypeDef g_timx_pwm_handle;
|
初始化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
|
void gtim_timx_pwm_chy_init(uint16_t arr, uint16_t psc)
{
TIM_OC_InitTypeDef timx_oc_pwm_chy = {0};
g_timx_pwm_chy_handle.Instance = GTIM_TIMX_PWM;
g_timx_pwm_chy_handle.Init.Prescaler = psc;
g_timx_pwm_chy_handle.Init.CounterMode = TIM_COUNTERMODE_UP;
g_timx_pwm_chy_handle.Init.Period = arr;
HAL_TIM_PWM_Init(&g_timx_pwm_chy_handle);
timx_oc_pwm_chy.OCMode = TIM_OCMODE_PWM1;
timx_oc_pwm_chy.Pulse = arr / 2;
timx_oc_pwm_chy.OCPolarity = TIM_OCPOLARITY_LOW;
HAL_TIM_PWM_ConfigChannel(&g_timx_pwm_chy_handle, &timx_oc_pwm_chy, GTIM_TIMX_PWM_CHY);
HAL_TIM_PWM_Start(&g_timx_pwm_chy_handle, GTIM_TIMX_PWM_CHY);
}
void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
{
if (htim->Instance == GTIM_TIMX_PWM)
{
GPIO_InitTypeDef gpio_init_struct;
GTIM_TIMX_PWM_CHY_GPIO_CLK_ENABLE();
GTIM_TIMX_PWM_CHY_CLK_ENABLE();
gpio_init_struct.Pin = GTIM_TIMX_PWM_CHY_GPIO_PIN;
gpio_init_struct.Mode = GPIO_MODE_AF_PP;
gpio_init_struct.Pull = GPIO_PULLUP;
gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GTIM_TIMX_PWM_CHY_GPIO_PORT, &gpio_init_struct);
}
}
|
主函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| int main(void)
{
uint16_t ledrpwmval = 0;
uint8_t dir = 1;
HAL_Init();
sys_stm32_clock_init(RCC_PLL_MUL9);
delay_init(72);
gtim_timx_pwm_chy_init(500 - 1, 72 - 1);
while(1)
{
delay_ms(5);
if (dir)ledrpwmval++;
else ledrpwmval--;
if (ledrpwmval >= 500)dir = 0;
if (ledrpwmval == 0)dir = 1;
__HAL_TIM_SET_COMPARE(&g_timx_pwm_chy_handle, GTIM_TIMX_PWM_CHY, ledrpwmval);
}
}
|
输入捕获测按键PB1按下时长
宏定义
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
#define GTIM_TIMX_CAP_CHY_GPIO_PORT GPIOB
#define GTIM_TIMX_CAP_CHY_GPIO_PIN GPIO_PIN_1
#define GTIM_TIMX_CAP_CHY_GPIO_CLK_ENABLE() do{ __HAL_RCC_GPIOB_CLK_ENABLE(); }while(0)
#define GTIM_TIMX_CAP TIM3
#define GTIM_TIMX_CAP_IRQn TIM3_IRQn
#define GTIM_TIMX_CAP_IRQHandler TIM3_IRQHandler
#define GTIM_TIMX_CAP_CHY TIM_CHANNEL_4
#define GTIM_TIMX_CAP_CHY_CCRX TIM3->CCR4
#define GTIM_TIMX_CAP_CHY_CLK_ENABLE() do{ __HAL_RCC_TIM3_CLK_ENABLE(); }while(0)
|
全局变量
1
2
3
4
5
6
7
8
9
10
11
12
| TIM_HandleTypeDef g_timx_cap_chy_handle;
uint8_t g_timxchy_cap_sta = 0;
uint16_t g_timxchy_cap_val = 0;
|
初始化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
void gtim_timx_cap_chy_init(uint16_t arr, uint16_t psc)
{
TIM_IC_InitTypeDef timx_ic_cap_chy = {0};
g_timx_cap_chy_handle.Instance = GTIM_TIMX_CAP;
g_timx_cap_chy_handle.Init.Prescaler = psc;
g_timx_cap_chy_handle.Init.CounterMode = TIM_COUNTERMODE_UP;
g_timx_cap_chy_handle.Init.Period = arr;
HAL_TIM_IC_Init(&g_timx_cap_chy_handle);
timx_ic_cap_chy.ICPolarity = TIM_ICPOLARITY_RISING;
timx_ic_cap_chy.ICSelection = TIM_ICSELECTION_DIRECTTI;
timx_ic_cap_chy.ICPrescaler = TIM_ICPSC_DIV1;
timx_ic_cap_chy.ICFilter = 0;
HAL_TIM_IC_ConfigChannel(&g_timx_cap_chy_handle, &timx_ic_cap_chy, GTIM_TIMX_CAP_CHY);
__HAL_TIM_ENABLE_IT(&g_timx_cap_chy_handle, TIM_IT_UPDATE);
HAL_TIM_IC_Start_IT(&g_timx_cap_chy_handle, GTIM_TIMX_CAP_CHY);
}
void HAL_TIM_IC_MspInit(TIM_HandleTypeDef *htim)
{
if (htim->Instance == GTIM_TIMX_CAP)
{
GPIO_InitTypeDef gpio_init_struct;
GTIM_TIMX_CAP_CHY_CLK_ENABLE();
GTIM_TIMX_CAP_CHY_GPIO_CLK_ENABLE();
gpio_init_struct.Pin = GTIM_TIMX_CAP_CHY_GPIO_PIN;
gpio_init_struct.Mode = GPIO_MODE_AF_INPUT;
gpio_init_struct.Pull = GPIO_PULLDOWN;
gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GTIM_TIMX_CAP_CHY_GPIO_PORT, &gpio_init_struct);
HAL_NVIC_SetPriority(GTIM_TIMX_CAP_IRQn, 1, 3);
HAL_NVIC_EnableIRQ(GTIM_TIMX_CAP_IRQn);
}
}
|
中断服务函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
|
void GTIM_TIMX_CAP_IRQHandler(void)
{
HAL_TIM_IRQHandler(&g_timx_cap_chy_handle);
}
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
if (htim->Instance == GTIM_TIMX_CAP)
{
if ((g_timxchy_cap_sta & 0X80) == 0)
{
if (g_timxchy_cap_sta & 0X40)
{
g_timxchy_cap_sta |= 0X80;
g_timxchy_cap_val = HAL_TIM_ReadCapturedValue(&g_timx_cap_chy_handle, GTIM_TIMX_CAP_CHY);
TIM_RESET_CAPTUREPOLARITY(&g_timx_cap_chy_handle, GTIM_TIMX_CAP_CHY);
TIM_SET_CAPTUREPOLARITY(&g_timx_cap_chy_handle, GTIM_TIMX_CAP_CHY, TIM_ICPOLARITY_RISING);
}
else
{
g_timxchy_cap_sta = 0;
g_timxchy_cap_val = 0;
g_timxchy_cap_sta |= 0X40;
__HAL_TIM_SET_COUNTER(&g_timx_cap_chy_handle, 0);
TIM_RESET_CAPTUREPOLARITY(&g_timx_cap_chy_handle, GTIM_TIMX_CAP_CHY);
TIM_SET_CAPTUREPOLARITY(&g_timx_cap_chy_handle, GTIM_TIMX_CAP_CHY, TIM_ICPOLARITY_FALLING);
}
}
}
}
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
if (htim->Instance == GTIM_TIMX_CAP)
{
if ((g_timxchy_cap_sta & 0X80) == 0)
{
if (g_timxchy_cap_sta & 0X40)
{
if ((g_timxchy_cap_sta & 0X3F) == 0X3F)
{
TIM_RESET_CAPTUREPOLARITY(&g_timx_cap_chy_handle, GTIM_TIMX_CAP_CHY);
TIM_SET_CAPTUREPOLARITY(&g_timx_cap_chy_handle, GTIM_TIMX_CAP_CHY, TIM_ICPOLARITY_RISING);
g_timxchy_cap_sta |= 0X80;
g_timxchy_cap_val = 0XFFFF;
}
else
{
g_timxchy_cap_sta++;
}
}
}
}
}
|
主函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
| int main(void)
{
uint32_t temp = 0;
uint8_t t = 0;
HAL_Init();
sys_stm32_clock_init(RCC_PLL_MUL9);
delay_init(72);
usart_init(115200);
led_init();
gtim_timx_cap_chy_init(0XFFFF, 72 - 1);
printf("Start:\n");
while (1)
{
if (g_timxchy_cap_sta & 0X80)
{
temp = g_timxchy_cap_sta & 0X3F;
temp *= 65536;
temp += g_timxchy_cap_val;
printf("HIGH:%d us\r\n", temp);
g_timxchy_cap_sta = 0;
}
t++;
if (t > 20)
{
t = 0;
LED0_TOGGLE();
}
delay_ms(10);
}
}
|
输入捕获测PA6脉冲数
宏定义
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
#define GTIM_TIMX_CNT_CHY_GPIO_PORT GPIOA
#define GTIM_TIMX_CNT_CHY_GPIO_PIN GPIO_PIN_6
#define GTIM_TIMX_CNT_CHY_GPIO_CLK_ENABLE() do{ __HAL_RCC_GPIOA_CLK_ENABLE(); }while(0)
#define GTIM_TIMX_CNT TIM3
#define GTIM_TIMX_CNT_IRQn TIM3_IRQn
#define GTIM_TIMX_CNT_IRQHandler TIM3_IRQHandler
#define GTIM_TIMX_CNT_CHY TIM_CHANNEL_1
#define GTIM_TIMX_CNT_InputTrigger TIM_TS_TI1FP1
#define GTIM_TIMX_CNT_CHY_CLK_ENABLE() do{ __HAL_RCC_TIM3_CLK_ENABLE(); }while(0)
|
全局变量
1
2
3
4
| TIM_HandleTypeDef g_timx_cnt_chy_handle;
uint32_t g_timxchy_cnt_ofcnt = 0 ;
|
初始化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
void gtim_timx_cnt_chy_init(uint16_t psc)
{
GPIO_InitTypeDef gpio_init_struct;
TIM_SlaveConfigTypeDef tim_slave_config = {0};
GTIM_TIMX_CNT_CHY_CLK_ENABLE();
GTIM_TIMX_CNT_CHY_GPIO_CLK_ENABLE();
g_timx_cnt_chy_handle.Instance = GTIM_TIMX_CNT;
g_timx_cnt_chy_handle.Init.Prescaler = psc;
g_timx_cnt_chy_handle.Init.CounterMode = TIM_COUNTERMODE_UP;
g_timx_cnt_chy_handle.Init.Period = 65535;
HAL_TIM_IC_Init(&g_timx_cnt_chy_handle);
gpio_init_struct.Pin = GTIM_TIMX_CNT_CHY_GPIO_PIN;
gpio_init_struct.Mode = GPIO_MODE_AF_INPUT;
gpio_init_struct.Pull = GPIO_PULLDOWN;
gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GTIM_TIMX_CNT_CHY_GPIO_PORT, &gpio_init_struct);
tim_slave_config.SlaveMode = TIM_SLAVEMODE_EXTERNAL1;
tim_slave_config.InputTrigger = GTIM_TIMX_CNT_InputTrigger;
tim_slave_config.TriggerPolarity = TIM_TRIGGERPOLARITY_RISING;
tim_slave_config.TriggerPrescaler = TIM_TRIGGERPRESCALER_DIV1;
tim_slave_config.TriggerFilter = 0x0;
HAL_TIM_SlaveConfigSynchro(&g_timx_cnt_chy_handle, &tim_slave_config);
HAL_NVIC_SetPriority(GTIM_TIMX_CNT_IRQn, 1, 3);
HAL_NVIC_EnableIRQ(GTIM_TIMX_CNT_IRQn);
__HAL_TIM_ENABLE_IT(&g_timx_cnt_chy_handle, TIM_IT_UPDATE);
HAL_TIM_IC_Start(&g_timx_cnt_chy_handle, GTIM_TIMX_CNT_CHY);
}
|
中断函数
1
2
3
4
5
6
7
8
9
10
| void GTIM_TIMX_CNT_IRQHandler(void)
{
if(__HAL_TIM_GET_FLAG(&g_timx_cnt_chy_handle, TIM_FLAG_UPDATE) != RESET)
{
g_timxchy_cnt_ofcnt++;
}
__HAL_TIM_CLEAR_IT(&g_timx_cnt_chy_handle, TIM_IT_UPDATE);
}
|
其他函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
uint32_t gtim_timx_cnt_chy_get_count(void)
{
uint32_t count = 0;
count = g_timxchy_cnt_ofcnt * 65536;
count += __HAL_TIM_GET_COUNTER(&g_timx_cnt_chy_handle);
return count;
}
void gtim_timx_cnt_chy_restart(void)
{
__HAL_TIM_DISABLE(&g_timx_cnt_chy_handle);
g_timxchy_cnt_ofcnt = 0;
__HAL_TIM_SET_COUNTER(&g_timx_cnt_chy_handle, 0);
__HAL_TIM_ENABLE(&g_timx_cnt_chy_handle);
}
|
主函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
| int main(void)
{
uint32_t curcnt = 0;
uint32_t oldcnt = 0;
uint8_t key = 0;
uint8_t t = 0;
HAL_Init();
sys_stm32_clock_init(RCC_PLL_MUL9);
delay_init(72);
usart_init(115200);
led_init();
key_init();
gtim_timx_cnt_chy_init(0);
gtim_timx_cnt_chy_restart();
while (1)
{
key = key_scan(0);
if (key == KEY0_PRES)
{
gtim_timx_cnt_chy_restart();
}
curcnt = gtim_timx_cnt_chy_get_count();
if (oldcnt != curcnt)
{
oldcnt = curcnt;
printf("CNT:%d\r\n", oldcnt);
}
t++;
if (t > 20)
{
t = 0;
LED0_TOGGLE();
}
delay_ms(10);
}
}
|
