参考：
简介
框图
功能
时钟源
总览
内部时钟源(CK_INT)
外部时钟源模式1
当TIMx_SMCR寄存器的SMS=111时，此模式被选中。计数器可以在选定输入端的每个上升沿
或下降沿计数。
例如，要配置向上计数器在T12输入端的上升沿计数，使用下列步骤：
- 配置TIMx_CCMR1寄存器CC2S=’01’，配置通道2检测TI2输入的上升沿
- 配置TIMx_CCMR1寄存器的IC2F[3:0]，选择输入滤波器带宽(如果不需要滤波器，保持
IC2F=0000)
注： 捕获预分频器不用作触发，所以不需要对它进行配置
- 配置TIMx_CCER寄存器的CC2P=’0’，选定上升沿极性
- 配置TIMx_SMCR寄存器的SMS=’111’，选择定时器外部时钟模式1
- 配置TIMx_SMCR寄存器中的TS=’110’，选定TI2作为触发输入源
- 设置TIMx_CR1寄存器的CEN=’1’，启动计数器
当上升沿出现在TI2，计数器计数一次，且TIF标志被设置。
在TI2的上升沿和计数器实际时钟之间的延时，取决于在TI2输入端的重新同步电路。
外部时钟源模式2
选定此模式的方法为：令TIMx_SMCR寄存器中的ECE=1
计数器能够在外部触发ETR的每一个上升沿或下降沿计数。
下图是外部触发输入的框图：
例如，要配置在ETR下每2个上升沿计数一次的向上计数器，使用下列步骤：
- 本例中不需要滤波器，置TIMx_SMCR寄存器中的ETF[3:0]=0000
- 设置预分频器，置TIMx_SMCR寄存器中的ETPS[1:0]=01
- 设置在ETR的上升沿检测，置TIMx_SMCR寄存器中的ETP=0
- 开启外部时钟模式2，置TIMx_SMCR寄存器中的ECE=1
- 启动计数器，置TIMx_CR1寄存器中的CEN=1
计数器在每2个ETR上升沿计数一次。
在ETR的上升沿和计数器实际时钟之间的延时取决于在ETRP信号端的重新同步电路。
内部触发输入
使用一个定时器作为另一个定时器的预分频器
如：可以配置定时器1作为定时器2的预分频器。参考图138，进行下述操作：
- 配置定时器1为主模式，它可以在每一个更新事件UEV时输出一个周期性的触发信号。在
TIM1_CR2寄存器的MMS=’010’时，每当产生一个更新事件时在TRGO1上输出一个上升沿
信号。
- 连接定时器1的TRGO1输出至定时器2，设置TIM2_SMCR寄存器的TS=’000’，配置定时器2
为使用ITR1作为内部触发的从模式。
- 然后把从模式控制器置于外部时钟模式1(TIM2_SMCR寄存器的SMS=111)；这样定时器2
即可由定时器1周期性的上升沿(即定时器1的计数器溢出)信号驱动。
- 最后，必须设置相应(TIMx_CR1寄存器)的CEN位分别启动两个定时器。
注： 如果OCx已被选中为定时器1的触发输出(MMS=1xx)，它的上升沿用于驱动定时器2的计数器。
时基单元
计数器模式
向上计数模式
在向上计数模式中，计数器从0计数到自动加载值(TIMx_ARR计数器的内容)，然后重新从0开始
计数并且产生一个计数器溢出事件。
每次计数器溢出时可以产生更新事件，在TIMx_EGR寄存器中(通过软件方式或者使用从模式控
制器)设置UG位也同样可以产生一个更新事件。
设置TIMx_CR1寄存器中的UDIS位，可以禁止更新事件；这样可以避免在向预装载寄存器中写
入新值时更新影子寄存器。在UDIS位被清’0’之前，将不产生更新事件。但是在应该产生更新事
件时，计数器仍会被清’0’，同时预分频器的计数也被请0(但预分频系数不变)。此外，如果设置
了TIMx_CR1寄存器中的URS位(选择更新请求)，设置UG位将产生一个更新事件UEV，但硬件
不设置UIF标志(即不产生中断或DMA请求)；这是为了避免在捕获模式下清除计数器时，同时产
生更新和捕获中断。
当发生一个更新事件时，所有的寄存器都被更新，硬件同时(依据URS位)设置更新标志位
(TIMx_SR寄存器中的UIF位)。
- 预分频器的缓冲区被置入预装载寄存器的值(TIMx_PSC寄存器的内容)。
- 自动装载影子寄存器被重新置入预装载寄存器的值(TIMx_ARR)。
下图给出一些例子，当TIMx_ARR=0x36时计数器在不同时钟频率下的动作。
向下计数模式
中央对齐模式(向上/向下计数)
捕获/比较通道
在捕获模式下，捕获发生在影子寄存器上，然后再复制到预装载寄存器中。
在比较模式下，预装载寄存器的内容被复制到影子寄存器中，然后影子寄存器的内容和计数器
进行比较。
输入捕获模式
PWM输入模式
输出比较模式
PWM输出
简介：
通过捕获比较寄存器(TIMX_CCRX)的值和计数器(TIMX_CNT)的值相比较，从而输出高低电平，实现PWM输出。
框图：
定时器输出PWM原理：
PWM模式：
hal库配置
寄存器
总览
控制寄存器 1(TIMx_CR1)
控制寄存器 2(TIMx_CR2)
从模式控制寄存器(TIMx_SMCR)
DMA/中断使能寄存器(TIMx_DIER)
状态寄存器(TIMx_SR)
事件产生寄存器(TIMx_EGR)
捕获/比较模式寄存器 1(TIMx_CCMR1)
通道可用于输入(捕获模式)或输出(比较模式)，通道的方向由相应的CCxS定义。该寄存器其它
位的作用在输入和输出模式下不同。 OCxx描述了通道在输出模式下的功能， ICxx描述了通道在
输出模式下的功能。因此必须注意，同一个位在输出模式和输入模式下的功能是不同的。
输出比较模式：
输入捕获模式：
捕获/比较模式寄存器 2(TIMx_CCMR2)
参考CCMR1寄存器
捕获/比较使能寄存器(TIMx_CCER)
计数器(TIMx_CNT)
预分频器(TIMx_PSC)
自动重装载寄存器(TIMx_ARR)
捕获/比较寄存器 1234(TIMx_CCR1234)
DMA控制寄存器(TIMx_DCR)
连续模式的DMA地址(TIMx_DMAR)
示例
定时器中断控制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);
}
}
|
