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

1.题目解析

十三届的第二套题和第一套，代码结构一样但是多了一个IIC。

1.1 分而治之，藕断丝连

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

1.2 模块化思维导图

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

1.3 模块解析

1.3.1 KEY模块

还是控制按一次处理一次。老朋友了我们就不多说了，题目限制了按键消抖和单次处理，所以我们要加上消抖，和前几届的处理一模一样。
正常按键逻辑：
开始按下—>按下—>释放；
但是题目要求得按一次处理一次，根据代码逻辑加了一种等待释放状态
根据机械按键的特性开始和结束都得消抖，加上按一次执行一次，所以我们的处理逻辑是：
开始按下—>按下消抖—>按下—>等待弹起—>弹起—>弹起消抖—>释放；
具体看源码

void gain_key_state()
{
    key_volt[0] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0);
    key_volt[1] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1);
    key_volt[2] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2);
    key_volt[3] = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0);
    for(uint8_t i=0;i<4;i++){
        if(!key_volt[i]){
            switch(key_state[i]){
                case key_released:
                    key_redu =uwTick;
                    key_state[i] = key_reduction;
                    break;
                case key_reduction:
                    if(uwTick - key_redu >=10){
                        key_state[i] = key_pressed;
                    }
                    break;
                case key_pressed:
                    key_state[i] = key_wait;
                    break;
                case key_wait:
                    break;
            }
        }
        else{
            switch(key_state[i]){
                case key_released:
                    break;
                case key_reduction:
                    if(uwTick - key_redu >=10){
                        key_state[i] = key_released;
                    }
                    break;
                default:
                    key_redu =uwTick;
                    key_state[i] = key_reduction;
                    break;
            }
        }
    }
}

1.3.2 LED模块

ld1：B4按下5s后熄灭
ld2：库存为0时，以0.1s间隔闪烁
解决办法，设置一个标志位代表ld1~ld8，改变对应位的的值，再将标志位写入ODR寄存器中来控制led的亮灭。
具体实现看源码

1.3.3 LCD模块

lcd显示三个界面，注意首次切换的时候得清屏。
根据B1进行三个界面的切换；
状态0：SHOP；

状态1：PRICE；

状态1：REP。

具体实现看源码

1.3.4 TIM模块

TIM3产生0.1s时基。PSC：1699，ARR：9999；
TIM2通道2产生2kHzPWM。PSC：16，ARR：4999；
PSC和ARR计算公式（计算周期就是频率的倒数）：

具体请看源码

1.3.5 UART模块

第二套比第一套多了一个接收，但是不做数据处理。
具体请看源码

1.3.6 IIC模块

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

具体实现看第二部分源码。

2.源码

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

2.1cubemx配置

/* 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 "usart.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "stdio.h"
#include "lcd.h"
#include "i2c_hal.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 */
typedef enum{
    key_released = 0U,
    key_reduction,
    key_pressed,
    key_wait,
}KEY_STATE;
KEY_STATE key_state[4] = {0};
uint8_t key_volt[4] = {0};
uint32_t key_redu = 0;

typedef enum{
    Xrep = 0U,
    Yrep,
    Xprise,
    Yprise,
}DATA_ADDR;
DATA_ADDR addr;

uint8_t lcd_conv_flag = 0;
uint8_t XYshop[2] = {0}, XYrep[2] = {10, 10}, XYprise[2] = {10, 10};

uint8_t lcd_clear_flag = 0;
char lcd_str[21] = {0};

uint8_t uart_rx_data = 0;
uint8_t uart_tx_data[20] = {0};

uint8_t at24c02_r_byte(DATA_ADDR addr);
void at24c02_w_byte(DATA_ADDR addr, uint8_t data);

uint8_t led_flag = 0,ld1_flag = 0,ld2_flag;
uint32_t ld1_5s_tim = 0, ld2_100ms_tim = 0;

void gain_key_state()
{
    key_volt[0] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0);
    key_volt[1] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1);
    key_volt[2] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2);
    key_volt[3] = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0);
    for(uint8_t i=0;i<4;i++){
        if(!key_volt[i]){
            switch(key_state[i]){
                case key_released:
                    key_redu =uwTick;
                    key_state[i] = key_reduction;
                    break;
                case key_reduction:
                    if(uwTick - key_redu >=10){
                        key_state[i] = key_pressed;
                    }
                    break;
                case key_pressed:
                    key_state[i] = key_wait;
                    break;
                case key_wait:
                    break;
            }
        }
        else{
            switch(key_state[i]){
                case key_released:
                    break;
                case key_reduction:
                    if(uwTick - key_redu >=10){
                        key_state[i] = key_released;
                    }
                    break;
                default:
                    key_redu =uwTick;
                    key_state[i] = key_reduction;
                    break;
            }
        }
    }
}


//float XYprise[2] = {1.0, 1.0};
void key_process()
{
    if(key_state[0] == key_pressed){
        lcd_conv_flag = lcd_conv_flag!=2 ? lcd_conv_flag+1 : 0;
    }
    else if(key_state[1] == key_pressed){
        switch(lcd_conv_flag){
            case 0:
                XYshop[0] = XYshop[0]!=XYrep[0] ? XYshop[0]+1 : 0;
                break;
            case 1:
                XYprise[0] = XYprise[0]!=20 ? XYprise[0]+1 : 10;
                at24c02_w_byte(2, XYprise[0]);
                HAL_Delay(3);
                break;
            case 2:
                XYrep[0] ++;
                at24c02_w_byte(0, XYrep[0]);
                HAL_Delay(3);
                break;
        }
    }
    else if(key_state[2] == key_pressed){
        switch(lcd_conv_flag){
            case 0:
                XYshop[1] = XYshop[1]!=XYrep[1] ? XYshop[1]+1 : 0;
                break;
            case 1:
                XYprise[1] = XYprise[1]!=20 ? XYprise[1]+1 : 10;
                at24c02_w_byte(3, XYprise[1]);
                HAL_Delay(3);
                break;
            case 2:
                XYrep[1] ++;
                at24c02_w_byte(1, XYrep[1]);
                HAL_Delay(3);
                break;
        }
    }
    else if(key_state[3] == key_pressed && lcd_conv_flag == 0){
        XYrep[0] -= XYshop[0];
        XYrep[1] -= XYshop[1];
        if(XYshop[0]>0){
            at24c02_w_byte(0, XYrep[0]);
            HAL_Delay(3);
        }
        if(XYshop[1]>0){
            at24c02_w_byte(1, XYrep[1]);
            HAL_Delay(3);
        }
        memset(uart_tx_data, 0, strlen((char*)uart_tx_data));
        sprintf((char*)uart_tx_data, "X:%hhu,Y:%hhu,Z:%.1f", XYshop[0],XYshop[1],
                                    (XYshop[0]*XYprise[0]*0.1)+(XYshop[1]*XYprise[1]*0.1));
        HAL_UART_Transmit_IT(&huart1, uart_tx_data, strlen((char*)uart_tx_data));
        XYshop[0] = 0;
        XYshop[1] = 0;
        ld1_5s_tim = uwTick;
        ld1_flag = 1;
    }
}

void lcd_process()
{
    switch(lcd_conv_flag)
    {
        case 0:
            if(lcd_clear_flag == 2){
                lcd_clear_flag = 0;
                LCD_Clear(Black);
            }
            LCD_DisplayStringLine(Line1, (uint8_t*)"        SHOP    ");
            sprintf(lcd_str, "     X:%hhu    ", XYshop[0]);
            LCD_DisplayStringLine(Line3, (uint8_t*)lcd_str);
            sprintf(lcd_str, "     Y:%hhu    ", XYshop[1]);
            LCD_DisplayStringLine(Line4, (uint8_t*)lcd_str);
            break;
        case 1:
            if(lcd_clear_flag == 0){
                lcd_clear_flag = 1;
                LCD_Clear(Black);
            }
            LCD_DisplayStringLine(Line1, (uint8_t*)"        PRISE    ");
            sprintf(lcd_str, "     X:%.1f    ", XYprise[0]*0.1);
            LCD_DisplayStringLine(Line3, (uint8_t*)lcd_str);
            sprintf(lcd_str, "     Y:%.1f    ", (float)XYprise[1]*0.1);
            LCD_DisplayStringLine(Line4, (uint8_t*)lcd_str);
            break;
        case 2:
            if(lcd_clear_flag == 1){
                lcd_clear_flag = 2;
                LCD_Clear(Black);
            }
            LCD_DisplayStringLine(Line1, (uint8_t*)"        REP    ");
            sprintf(lcd_str, "     X:%hhu    ", XYrep[0]);
            LCD_DisplayStringLine(Line3, (uint8_t*)lcd_str);
            sprintf(lcd_str, "     Y:%hhu    ", XYrep[1]);
            LCD_DisplayStringLine(Line4, (uint8_t*)lcd_str);
            break;
    }
}

uint8_t at24c02_r_byte(DATA_ADDR addr)
{
    uint8_t data;
    I2CStart();
    I2CSendByte(0xa0);
    I2CWaitAck();
    I2CSendByte(addr);
    I2CWaitAck();
    I2CStart();
    I2CSendByte(0xa1);
    I2CWaitAck();
    data = I2CReceiveByte();
    I2CSendNotAck();
    I2CStop();
    return data;
}

void at24c02_w_byte(DATA_ADDR addr, uint8_t data)
{
    I2CStart();
    I2CSendByte(0xa0);
    I2CWaitAck();
    I2CSendByte(addr);
    I2CWaitAck();
    I2CSendByte(data);
    I2CWaitAck();
    I2CStop();
}

void iic_read()
{
    uint8_t temp = 0;
    temp = at24c02_r_byte(0);
    XYrep[0] = temp;
    HAL_Delay(3);
    temp = at24c02_r_byte(1);
    XYrep[1] = temp;
    HAL_Delay(3);
    temp = at24c02_r_byte(2);
    XYprise[0] = temp-10<=10 ? temp : 10;
    HAL_Delay(3);
    temp = at24c02_r_byte(3);
    XYprise[1] = temp-10<=10 ? temp : 10;
    HAL_Delay(3);
}


void led_pwm_process()
{
    if(ld1_flag==1){
        TIM2->CCR2 = (uint32_t)(TIM2->ARR+1)*0.3-1;
        if(uwTick - ld1_5s_tim >= 5000){
            ld1_flag = 0; 
        }
    }
    else{
        ld1_flag = 0;
        TIM2->CCR2 = (uint32_t)(TIM2->ARR+1)*0.05-1;
    }
    led_flag = ld1_flag;
    if(XYrep[0]==0&&XYrep[1]==0){
        if(uwTick - ld2_100ms_tim>=100){
            ld2_100ms_tim = uwTick;
            ld2_flag ^= 1;
        }
    }
    else ld2_flag = 0;
    led_flag += ld2_flag<<1;
    HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2, 1);
    GPIOC->ODR = 0xffff ^ led_flag<<8;
    HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2, 0);
}

void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
{
    if(uart_rx_data == '?'){
        memset(uart_tx_data, 0, strlen((char*)uart_tx_data));
        sprintf((char*)uart_tx_data, "X:%.1f,Y:%.1f", XYprise[0]*0.1, (float)XYprise[1]*0.1);
        HAL_UART_Transmit_IT(huart, uart_tx_data, strlen((char*)uart_tx_data));
    }
}

/* 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_SetBackColor(Black);
    LCD_SetTextColor(White);
    LCD_Clear(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_USART1_UART_Init();
  MX_TIM2_Init();
  /* USER CODE BEGIN 2 */
  uint32_t period_start_IT = 0;
    HAL_UARTEx_ReceiveToIdle_IT(&huart1, &uart_rx_data, 1);
    HAL_TIM_PWM_Start_IT(&htim2, TIM_CHANNEL_2);
    iic_read();
  /* USER CODE END 2 */

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

    /* USER CODE BEGIN 3 */
    gain_key_state();
    key_process();
    lcd_process();
      led_pwm_process();
      if(uwTick - period_start_IT>=50){
          period_start_IT=uwTick;
        HAL_UARTEx_ReceiveToIdle_IT(&huart1, &uart_rx_data, 1);
      }
  }
  /* 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);

  /** 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_DIV3;
  RCC_OscInitStruct.PLL.PLLN = 20;
  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_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */

/* 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.第十三届题目