前言：STM32G431RBT6实现嵌入式组第九届题目解析+源码，本文默认读者具备基础的stm32知识。文章末尾有第九届题目。

1.题目解析

1.1 分而治之，藕断丝连

还是那句话，将不同模块进行封装，通过变量进行模块间的合作。
函数将模块分而治之，变量使模块间藕断丝连。

1.2 模块化思维导图

下图根据题目梳理。还是使用思维导图。

1.3 模块解析

整合模块，逻辑思维。第九届的难度就在按键长按和短按的处理上，如果会处理第九届难度不大，如果不会就寄了。

1.3.1 KEY模块

按键长按大家都想到的是计时，计时的方法有很多种，定时器生成时基，systick1ms时基。我们时基选择越小越好（其实也没必要，影响不大），为什么呢？假如生成1个10ms时基计数80次就到了800ms，假如你在n次周期和第n+1次中间按下按键，按下之后第一次计时不能够快速响应。理论上最大在0~10ms之间。那为什么每必要呢？因为我们做的事精度要求没有那么高。
我写的有个缺点无法解决，就是长按之前必然会执行一次短按。
函数开始读取四个按键状态，然后遍历判断按键是否按下。如果按键按下，判断是否是刚按下，如果是，设置对应需要的状态。如果不是计时判断>=800ms长按，否则短按。如果没有按下，设置释放状态。

void key_process()
{
    keys_state[0] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0);    //读取电平状态
    keys_state[1] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1);
    keys_state[2] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2);
    keys_state[3] = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0);
    for(int i = 0; i<4; i++)
    {
        if(keys_state[i] == 0)    //如果按键按下
        {
            if(keys[i] == key_released){     //证明是刚开始按下
                keys[i] = key_pressed;
                short_pressed_limit = 1;
                key_pressed_start = HAL_GetTick();      //开始计时    
            }
            else{
                if(HAL_GetTick() - key_pressed_start >= 800)  //超过0.8s长按
                {
                    if(i == 0) keys[i] = key_short_pressed;    //按键1没有长按
                    else keys[i] = key_long_pressed;
                }else{                                      //其他都是短按
                    keys[i] = key_short_pressed;
                }
            }
        }
        else{                                           //电平为高，按键释放
            keys[i] = key_released;
        }
    }
}

1.3.2 LED模块

定时器在运行状态下，led以0.5s周期闪烁，所以需要0.25s的时基，一闪一灭0.5s一个周期。其他状态灭。
这里只说解决思路，具体代码请看源码

1.3.3 LCD模块

lcd显示存储位置，定时时间，定时器状态。使用到状态机。
根据四个按键的状态在三种状态之间不停的切换。
状态0：切换显示5个定时器，standby状态；
状态1：设置定时器，设置对应时间位高亮显示，setting状态；
状态2：定时器running和pause状态。
具体实现看源码

1.3.3.1 高亮处理函数

我不知道高亮到底是啥意思，随便设置了一下背景色和文本颜色。

/**
* @brief 高亮显示对应时间设置位
* @param str: 指定序列
         line: 指定行
         start: 序列高亮起始位置
         end: 序列高亮结束位置
* @retval 
*/
void highLight(char *str, u8 line,u8 start, u8 end)
{
    for(int i=0;i<start;i++)
        LCD_DisplayChar(line, 320-16*i, str[i]);
    LCD_SetTextColor(Red);
    LCD_SetBackColor(Black);
    for(int i=start;i<end;i++)
        LCD_DisplayChar(line, 320-16*i, str[i]);
    LCD_SetTextColor(Black);
    LCD_SetBackColor(White);
    for(int i=end;i<strlen(str);i++)
        LCD_DisplayChar(line, 320-16*i, str[i]);    
}

1.3.4 IIC模块

完成eeprom中数据的读写。开发板的PB6和PB7设置为开漏输出，使用软件模拟实现单字节数据的读写。注意：魔术棒->c\c+±>optimization选项要设置成-O0，要不然代码执行后得不到想要的结果。

1.3.4.1 软件模拟读写上图中的Byte Write 和 Random Read

//iic写入软件模拟
void iic_write(u8 addr, u8 data)
{
    I2CStart();
    I2CSendByte(0xa0);
    I2CSendAck();
    I2CSendByte(addr);
    I2CSendAck();
    I2CSendByte(data);
    I2CSendAck();
    I2CStop();
}
//iic读取软件模拟
u8 iic_read(u8 addr)
{
    u8 ret = 0;
    I2CStart();
    I2CSendByte(0xa0);
    I2CSendAck();
    I2CSendByte(addr);
    I2CSendAck();
    I2CStart();
    I2CSendByte(0xa1);
    I2CSendAck();
    ret = I2CReceiveByte();
    I2CSendNotAck();
    I2CStop();
    return ret;
}

1.3.4.2 at24c02读写定时器

每一次读写必须延时（3~5ms之间），这是rom的缺点。

/**
* @brief at24c02写入软件模拟
* @param addr_seq: 指定地址
*/
void at24c02_write(u8 addr_seq)
{
    u8 *timer_member_ptr[3] = {&timer[addr_seq-1].hours, 
                               &timer[addr_seq-1].minutes,
                               &timer[addr_seq-1].seconds};
    for(u8 i=0;i<3;i++)
    {
        iic_write(3*addr_seq+i, *timer_member_ptr[i]);
        HAL_Delay(3);
    }
}
/**
* @brief at24c02读取软件模拟
* @param addr_seq: 指定地址
*/
void at24c02_read(u8 addr_seq)
{
    u8 *timer_member_ptr[3] = {&timer[addr_seq-1].hours, 
                               &timer[addr_seq-1].minutes,
                               &timer[addr_seq-1].seconds};
    for(u8 i=0;i<3;i++)       
    {
        *timer_member_ptr[i] = iic_read(3*addr_seq+i);
        if(i==0 && *timer_member_ptr[i] >23){                 //初始读取eeprom数据，保证数据的正确性
            *timer_member_ptr[i] = 0;
        }else if(*timer_member_ptr[i] > 59){
            *timer_member_ptr[i] = 0;
        }
        HAL_Delay(3);
    }
}

1.3.5 TIM模块

TIM2产生0.25s时基。PSC：1699，ARR：24999；
TIM3产生频率为1KHz的pwm。PSC：16，ARR：9999；
PSC和ARR计算公式（计算周期就是频率的倒数）：

1.3.5.1 pwm和led处理

//pwm周期完成结束回调函数
void HAL_TIM_PWM_PulseFinishedCallback(TIM_HandleTypeDef *htim)
{
    if(global_state == 2 && tim_run_pause == 0)    //running状态输出pwm占空比80%
        TIM3->CCR1 = 7999; 
    else{                                          //其他状态不输出
        TIM3->CCR1 = 0;
    }
}

//tim时基周期回调函数
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if(global_state == 2 && tim_run_pause == 0){   //running状态led闪烁
        tim2_base_1s++;   
        led_flash ^= 1;     //0,1变化
        HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, 1);
        GPIOC->ODR = 0xff00 ^ led_flash << 8;
        HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, 0);
    }else{                                        //其他状态led灭
        HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, 1);
        GPIOC->ODR = 0xff00;
        HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, 0);
    }
}

1.3.5.2 定时器倒计时借位

秒向分借位，分向时借位，如果都为0

/**
* @brief 定时器倒计时时间借位和倒计时结束判断
* @param tim_req: 指定定时器
*/
void tim_running(u8 tim_req)
{
    if(timer[tim_req-1].seconds == 0)       //秒为0，分钟借位
    {
        if(timer[tim_req-1].minutes == 0)      //分为0，小时借位
        {
            if(timer[tim_req-1].minutes != 0){
                timer[tim_req-1].hours --;
                timer[tim_req-1].minutes = 59;
                timer[tim_req-1].seconds = 59;
            }
        }else{
            timer[tim_req-1].minutes --;
            timer[tim_req-1].seconds = 59;
        }
    }else{
        timer[tim_req-1].seconds--;
    }
    if(timer[tim_req-1].hours == 0 && timer[tim_req-1].minutes == 0 && timer[tim_req-1].seconds == 0)   //定时器结束判断
    {
        global_state = 0;
    }
}

2.源码

我所有的实现都在main.c文件中。

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2025 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "tim.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "stdio.h"
#include "i2c_hal.h"
#include "lcd.h"
#include "string.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

//按键状态枚举
enum{
    key_pressed = 0U,
    key_released,
    key_reduction,
    key_short_pressed,
    key_long_pressed
};

//时间结构体
typedef struct{
    uint8_t hours;
    uint8_t minutes;
    uint8_t seconds;
} timer_t;

timer_t timer[5] = {11,11,11};
/*
short_pressed_limit：限制短按所执行的程序只执行一次
B1_addr_cycle：B1控制存储地址
B2_tim_set_cycle：B2控制时分秒切换
tim2_base_1s：产生倒计时1s时基
tim_run_pause：定时器运行暂停状态控制，1：运行，0：暂停
global_state：状态机标志，0：切换定时器存储地址，1：设置时间，2：控制定时器运行暂停结束
led_flash：led闪烁控制
*/
uint8_t short_pressed_limit = 0, B1_addr_cycle = 1, B2_tim_set_cycle = 0, tim2_base_1s = 0, 
        tim_run_pause = 1, tim_standby = 0, global_state = 0, led_flash = 0;
/*
key_pressed_start：800ms计时
*/
uint32_t key_pressed_start = 0;
/*
keys：按键按下状态
keys_state：检测按键对应引脚状态
*/
uint8_t keys[4] = {0}, keys_state[4] = {0};
/*
lcd_str：lcd显示
tim_state：显示定时器状态
*/
char lcd_str[20] = {0}, tim_state[20] = {0};

void key_process();
void key_state_setting();
void state_process();
void lcd_process();
void highLight(char *str, u8 line,u8 start, u8 end);
void iic_write(u8 addr, u8 data);
u8 iic_read(u8 addr);
void at24c02_write(u8 addr_seq);
void at24c02_read(u8 addr_seq);
void tim_running(u8 tim_req);
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{

  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */
    LCD_Init();
    LCD_Clear(White);
    LCD_SetTextColor(Black);
  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_TIM2_Init();
  MX_TIM3_Init();
  /* USER CODE BEGIN 2 */
    HAL_TIM_PWM_Start_IT(&htim3, TIM_CHANNEL_1);   //PA6pwm中断
    HAL_TIM_Base_Start_IT(&htim2); //0.25s时基中断
    //初始化读取eeprom数据
    for(u8 i=1;i<6;i++)
    {
        at24c02_read(i);
    }
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
      key_process();
      key_state_setting();
      state_process();
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Configure the main internal regulator output voltage
  */
  HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1_BOOST);

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV6;
  RCC_OscInitStruct.PLL.PLLN = 85;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
  RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */
//获取按键状态，按下，短按，长按，释放
void key_process()
{
    keys_state[0] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0);    //读取电平状态
    keys_state[1] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1);
    keys_state[2] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2);
    keys_state[3] = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0);
    for(int i = 0; i<4; i++)
    {
        if(keys_state[i] == 0)    //如果按键按下
        {
            if(keys[i] == key_released){     //证明是刚开始按下
                keys[i] = key_pressed;
                short_pressed_limit = 1;
                key_pressed_start = HAL_GetTick();      //开始计时    
            }
            else{
                if(HAL_GetTick() - key_pressed_start >= 800)  //超过0.8s长按
                {
                    if(i == 0) keys[i] = key_short_pressed;    //按键1没有长按
                    else keys[i] = key_long_pressed;
                }else{                                      //其他都是短按
                    keys[i] = key_short_pressed;
                }
            }
        }
        else{                                           //电平为高，按键释放
            keys[i] = key_released;
        }
    }
}

//根据按键状态设置对应要求标志
void key_state_setting()
{
    if(keys[0] == key_short_pressed && short_pressed_limit == 1)    //B1按下+短按限制
    {
        short_pressed_limit = 0;                                    //保证短按只执行一次        
        B1_addr_cycle++;                                             //地址循环
        if(B1_addr_cycle == 6) B1_addr_cycle = 0;
        global_state = 0;                                               //状态为1
    }
    if(keys[1] == key_short_pressed && short_pressed_limit == 1)
    {
        short_pressed_limit = 0;
        B2_tim_set_cycle++;
        if(B2_tim_set_cycle == 3) B2_tim_set_cycle = 0;
        global_state = 1;
    }
    else if(keys[1] == key_long_pressed)             //B2长按处理
    {
        at24c02_write(B1_addr_cycle);
        global_state = 0;
    }
    if(global_state == 1){                      //保证B2按下后B3起作用
        if(keys[2] == key_short_pressed && short_pressed_limit == 1 || keys[2] == key_long_pressed)   //B3长按短按处理都一样，只是B3短按加了短按限制
        {
            if(keys[2] == key_short_pressed) short_pressed_limit = 0;   
            if(B2_tim_set_cycle == 1){            //小时处理0-23
                timer[B1_addr_cycle-1].hours++;
                if(timer[B1_addr_cycle-1].hours == 24)
                    timer[B1_addr_cycle-1].hours = 0;
            }
            else if(B2_tim_set_cycle == 2){        //分钟处理0-23
                timer[B1_addr_cycle-1].minutes++;
                if(timer[B1_addr_cycle-1].minutes == 60)
                    timer[B1_addr_cycle-1].minutes = 0;
            }else{                                            //秒处理0-23
                timer[B1_addr_cycle-1].seconds++;
                if(timer[B1_addr_cycle-1].seconds == 60)
                    timer[B1_addr_cycle-1].seconds = 0;
            }
        }
    }
    
    if(keys[3] == key_short_pressed && short_pressed_limit == 1)
    {
        short_pressed_limit = 0;
        tim_run_pause ^= 1;               //运行暂停切换
        global_state = 2;
    }
    else if(keys[3] == key_long_pressed)              
    {
        global_state = 0;
    }
    
}

//状态显示，0：切换不同的定时器，1：设置定时器，2：定时器运行暂停结束控制
void state_process()
{
    switch(global_state)
    {
        case 0:
            sprintf(lcd_str, "  No %d             ", B1_addr_cycle);
            LCD_DisplayStringLine(Line2, (uint8_t*)lcd_str);
            sprintf(lcd_str, "      %2d:%2d:%2d     ", timer[B1_addr_cycle-1].hours,
                      timer[B1_addr_cycle-1].minutes,timer[B1_addr_cycle-1].seconds);
            LCD_DisplayStringLine(Line4, (uint8_t*)lcd_str);
            sprintf(tim_state, "       Standby     ");
            LCD_DisplayStringLine(Line6, (uint8_t*)tim_state);
            break;
        case 1:
            sprintf(lcd_str, "  No %d             ", B1_addr_cycle);
            LCD_DisplayStringLine(Line2, (uint8_t*)lcd_str);
            sprintf(lcd_str, "      %2d:%2d:%2d     ", timer[B1_addr_cycle-1].hours,
                      timer[B1_addr_cycle-1].minutes,timer[B1_addr_cycle-1].seconds);
            if(B2_tim_set_cycle == 1)
            {
                highLight(lcd_str, Line4, 6, 8);   
            }
            else if(B2_tim_set_cycle == 2)
            {
                highLight(lcd_str, Line4, 9, 11);
            }
            else
            {
                highLight(lcd_str, Line4, 12, 14);
            }
            sprintf(tim_state, "       Setting     ");
            LCD_DisplayStringLine(Line6, (uint8_t*)tim_state);
            break;
        case 2:
            sprintf(lcd_str, "  No %d             ", B1_addr_cycle);
            LCD_DisplayStringLine(Line2, (uint8_t*)lcd_str);
            sprintf(lcd_str, "      %2d:%2d:%2d     ", timer[B1_addr_cycle-1].hours,
                      timer[B1_addr_cycle-1].minutes,timer[B1_addr_cycle-1].seconds);
            LCD_DisplayStringLine(Line4, (uint8_t*)lcd_str);
            if(tim_run_pause == 0){
                if(tim2_base_1s == 4){
                    tim2_base_1s = 0;
                    tim_running(B1_addr_cycle);
                }
                sprintf(tim_state, "       Running     ");
            }else{
                sprintf(tim_state, "       Pause     ");
            }
            LCD_DisplayStringLine(Line6, (uint8_t*)tim_state);
            break;
    }
}

/**
* @brief 高亮显示对应时间设置位
* @param str: 指定序列
         line: 指定行
         start: 序列高亮起始位置
         end: 序列高亮结束位置
* @retval 
*/
void highLight(char *str, u8 line,u8 start, u8 end)
{
    for(int i=0;i<start;i++)
        LCD_DisplayChar(line, 320-16*i, str[i]);
    LCD_SetTextColor(Red);
    LCD_SetBackColor(Black);
    for(int i=start;i<end;i++)
        LCD_DisplayChar(line, 320-16*i, str[i]);
    LCD_SetTextColor(Black);
    LCD_SetBackColor(White);
    for(int i=end;i<strlen(str);i++)
        LCD_DisplayChar(line, 320-16*i, str[i]);    
}

//iic写入软件模拟
void iic_write(u8 addr, u8 data)
{
    I2CStart();
    I2CSendByte(0xa0);
    I2CSendAck();
    I2CSendByte(addr);
    I2CSendAck();
    I2CSendByte(data);
    I2CSendAck();
    I2CStop();
}
//iic读取软件模拟
u8 iic_read(u8 addr)
{
    u8 ret = 0;
    I2CStart();
    I2CSendByte(0xa0);
    I2CSendAck();
    I2CSendByte(addr);
    I2CSendAck();
    I2CStart();
    I2CSendByte(0xa1);
    I2CSendAck();
    ret = I2CReceiveByte();
    I2CSendNotAck();
    I2CStop();
    return ret;
}
/**
* @brief at24c02写入软件模拟
* @param addr_seq: 指定地址
*/
void at24c02_write(u8 addr_seq)
{
    u8 *timer_member_ptr[3] = {&timer[addr_seq-1].hours, 
                               &timer[addr_seq-1].minutes,
                               &timer[addr_seq-1].seconds};
    for(u8 i=0;i<3;i++)
    {
        iic_write(3*addr_seq+i, *timer_member_ptr[i]);
        HAL_Delay(3);
    }
}
/**
* @brief at24c02读取软件模拟
* @param addr_seq: 指定地址
*/
void at24c02_read(u8 addr_seq)
{
    u8 *timer_member_ptr[3] = {&timer[addr_seq-1].hours, 
                               &timer[addr_seq-1].minutes,
                               &timer[addr_seq-1].seconds};
    for(u8 i=0;i<3;i++)       
    {
        *timer_member_ptr[i] = iic_read(3*addr_seq+i);
        if(i==0 && *timer_member_ptr[i] >23){                 //初始读取eeprom数据，保证数据的正确性
            *timer_member_ptr[i] = 0;
        }else if(*timer_member_ptr[i] > 59){
            *timer_member_ptr[i] = 0;
        }
        HAL_Delay(3);
    }
}

/**
* @brief 定时器倒计时时间借位和倒计时结束判断
* @param tim_req: 指定定时器
*/
void tim_running(u8 tim_req)
{
    if(timer[tim_req-1].seconds == 0)       //秒为0，分钟借位
    {
        if(timer[tim_req-1].minutes == 0)      //分为0，小时借位
        {
                timer[tim_req-1].hours --;
                timer[tim_req-1].minutes = 59;
                timer[tim_req-1].seconds = 59;
        }else{
            timer[tim_req-1].minutes --;
            timer[tim_req-1].seconds = 59;
        }
    }else{
        timer[tim_req-1].seconds--;
    }
    if(timer[tim_req-1].hours == 0 && timer[tim_req-1].minutes == 0 && timer[tim_req-1].seconds == 0)   //定时器结束判断
    {
        global_state = 0;
    }
}

//pwm周期完成结束回调函数
void HAL_TIM_PWM_PulseFinishedCallback(TIM_HandleTypeDef *htim)
{
    if(global_state == 2 && tim_run_pause == 0)    //running状态输出pwm占空比80%
        TIM3->CCR1 = 7999; 
    else{                                          //其他状态不输出
        TIM3->CCR1 = 0;
    }
}

//tim时基周期回调函数
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if(global_state == 2 && tim_run_pause == 0){   //running状态led闪烁
        tim2_base_1s++;
        led_flash ^= 1;
        HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, 1);
        GPIOC->ODR = 0xff00 ^ led_flash << 8;
        HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, 0);
        
    }else{                                        //其他状态led灭
        HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, 1);
        GPIOC->ODR = 0xff00;
        HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, 0);
    }
}

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

3.第九届题目