PY32F403K1CU6定时器1~6基本配置，1ms中断，每隔1秒打印

tim.h

#ifndef __TIM_H__
#define __TIM_H__ 
#include "main.h" 
extern u32 t32;
extern u8 b32; 
void MX_TIM_Init(void); 
void MX_TIM6_Init(void);  
#endif /* __TIM_H__ */ 

tim.c

//tim.c
#include "tim.h"
#include "main.h"
#include "led.h"
#include "key.h"
#include "dac.h"
#include "key.h"

u32 t32=0; 
u8 b32=1;
TIM_HandleTypeDef htim1, htim2, htim3, htim4;
TIM_HandleTypeDef htim6;
// 定时器初始化函数（所有定时器都配置为1ms中断）
void MX_TIM_Init(void)
{
    TIM_HandleTypeDef* timers[] = {&htim1, &htim2, &htim3, &htim4};
    TIM_TypeDef* tim_instances[] = {TIM1, TIM2, TIM3, TIM4};
    for(int i = 0; i < 4; i++)
    {
			//if(i!=1)continue;	//只用TIM2
        timers[i]->Instance = tim_instances[i];
        timers[i]->Init.Prescaler = 80 - 1;           // 80MHz/80 = 1MHz
        timers[i]->Init.Period = 1000 - 1;            // 1MHz/1000 = 1kHz (1ms)
        timers[i]->Init.CounterMode = TIM_COUNTERMODE_UP;
        timers[i]->Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
        timers[i]->Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
        if (HAL_TIM_Base_Init(timers[i]) != HAL_OK)
        {
            Error_Handler();
        }
        if (HAL_TIM_Base_Start_IT(timers[i]) != HAL_OK)
        {
            Error_Handler();
        }
    }
}
// tim.c 中修改 MX_TIM6_Init（仅保留这一个版本）
void MX_TIM6_Init(void) {
  htim6.Instance = TIM6;
  htim6.Init.Prescaler = 80-1;    // 144MHz/(179+1) = 800kHz
  htim6.Init.Period = 1000-1;        // 800kHz/(99+1) = 8kHz 中断
  htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  if (HAL_TIM_Base_Init(&htim6) != HAL_OK) {
    Error_Handler();
  }
  if (HAL_TIM_Base_Start_IT(&htim6) != HAL_OK) {
    Error_Handler();
  }
  uint32_t tim6_clk = HAL_RCC_GetPCLK1Freq();
  uint32_t irq_freq = tim6_clk / ((htim6.Init.Prescaler + 1) * (htim6.Init.Period + 1));
}
// MSP初始化
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
{
    uint8_t priority = 0; 
    if(tim_baseHandle->Instance == TIM1)
    {
        __HAL_RCC_TIM1_CLK_ENABLE();
        priority = 0;
        HAL_NVIC_SetPriority(TIM1_UP_IRQn, priority, 0);
        HAL_NVIC_EnableIRQ(TIM1_UP_IRQn);
    }
    else if(tim_baseHandle->Instance == TIM2)
    {
        __HAL_RCC_TIM2_CLK_ENABLE();
        priority = 1;
        HAL_NVIC_SetPriority(TIM2_IRQn, priority, 0);
        HAL_NVIC_EnableIRQ(TIM2_IRQn);
    }
    else if(tim_baseHandle->Instance == TIM3)
    {
        __HAL_RCC_TIM3_CLK_ENABLE();
        priority = 2;
        HAL_NVIC_SetPriority(TIM3_IRQn, priority, 0);
        HAL_NVIC_EnableIRQ(TIM3_IRQn);
    }
    else if(tim_baseHandle->Instance == TIM4)
    {
        __HAL_RCC_TIM4_CLK_ENABLE();
        priority = 3;
        HAL_NVIC_SetPriority(TIM4_IRQn, priority, 0);
        HAL_NVIC_EnableIRQ(TIM4_IRQn);
    }
		 else if(tim_baseHandle->Instance == TIM6)
    {
        __HAL_RCC_TIM6_CLK_ENABLE();  // 使能 TIM6 时钟
        priority = 0;  // TIM6 最高优先级
        HAL_NVIC_SetPriority(TIM6_IRQn, priority, 0);  // 抢占优先级 0，响应优先级 0
        HAL_NVIC_EnableIRQ(TIM6_IRQn);  // 使能 TIM6 中断
    }
}

// MSP反初始化
void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef* tim_baseHandle)
{
    if(tim_baseHandle->Instance == TIM1)
    {
        __HAL_RCC_TIM1_CLK_DISABLE();
        HAL_NVIC_DisableIRQ(TIM1_UP_IRQn);
    }
    else if(tim_baseHandle->Instance == TIM2)
    {
        __HAL_RCC_TIM2_CLK_DISABLE();
        HAL_NVIC_DisableIRQ(TIM2_IRQn);
    }
    else if(tim_baseHandle->Instance == TIM3)
    {
        __HAL_RCC_TIM3_CLK_DISABLE();
        HAL_NVIC_DisableIRQ(TIM3_IRQn);
    }
    else if(tim_baseHandle->Instance == TIM4)
    {
        __HAL_RCC_TIM4_CLK_DISABLE();
        HAL_NVIC_DisableIRQ(TIM4_IRQn);
    }
}

// 中断处理函数
void TIM1_UP_IRQHandler(void) { HAL_TIM_IRQHandler(&htim1); }
void TIM2_IRQHandler(void)    { HAL_TIM_IRQHandler(&htim2); }
void TIM3_IRQHandler(void)    { HAL_TIM_IRQHandler(&htim3); }
void TIM4_IRQHandler(void)    { HAL_TIM_IRQHandler(&htim4); }
void TIM6_IRQHandler(void)    { HAL_TIM_IRQHandler(&htim6); }
// 定时器回调函数 - 所有定时器都是1ms中断，但1秒打印一次
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    static uint16_t counters[5] = {0};  // 每个定时器的计数器
    
    if(htim->Instance == TIM1)
    {
        counters[0]++;
        if(counters[0] >= 1000)
        {
            counters[0] = 0; 
            printf("TIM1: 1 second\n");  // 1秒
        }
    }
    else if(htim->Instance == TIM2)
    { 
        counters[1]++;
				b32=1;
				key_scan();		//每1ms 扫描一次按键  
				if(counters[1]%300==0)
				{ 
					IWDG_Feed();    			//喂狗 
				}
				if(counters[1]%500==0)
				{
					HAL_GPIO_TogglePin(LED0_PORT, LED0_PIN); 
				}
        if(counters[1] >= 1000)  // 1秒
        {
            counters[1] = 0;  //printf("TIM2: 1 second\n");
        }
    }
    else if(htim->Instance == TIM3)
    {
        counters[2]++;
        if(counters[2] >= 1000)  // 1秒
        {
            counters[2] = 0;
            printf("TIM3: 1 second\n");
        }
    }
    else if(htim->Instance == TIM4)
    {
        counters[3]++;
        if(counters[3] >= 1000)  // 1秒
        {
            counters[3] = 0;
            printf("TIM4: 1 second\n");
        }
    }
    else if(htim->Instance == TIM6) { 
			
        counters[4]++;
        if(counters[4] >= 1000)  // 1秒
        {
            counters[4] = 0;
            printf("TIM6: 1 second\n");
        }
    }
}

main.c

int main(void)
{ 
  HAL_Init(); 
  APP_SystemClockConfig(); 
  /* Enable LSI clock: 40k*/
  __HAL_RCC_LSI_ENABLE();    
  /* Wait for LSI READY to be set */
  while (READ_BIT(RCC->CSR, RCC_CSR_LSIRDY) == 0U)
  {
  }
	delay_init(216);	//延时初始化	
  LedConfig();			//LED初始化
	uart_init(115200);	//串口初始化
	IWDG_Init(IWDG_PRESCALER_32,625); //0.2=(32/40000)×(Reload+1)//Reload+1=0.2×40000/32=250 
  MX_TIM_Init(); 		//定时器初始化
  MX_TIM6_Init();
  DAC1_Init();
  while (1)
  { 
		if(b32)
		{
			t32++;b32=0;
		}
		//if(t32%500==0)
		//{ 
		//		dac_test(); 
		//}  
  }
}
  

每隔1秒打印一次, 执行结果

TIM1: 1 second
TIM6: 1 second
TIM3: 1 second
TIM4: 1 second
TIM1: 1 second
TIM6: 1 second
TIM3: 1 second
TIM4: 1 second
TIM1: 1 second
TIM6: 1 second
TIM3: 1 second
TIM4: 1 second