1. 从零开始：STM32G431RBT6与蓝桥杯嵌入式竞赛环境搭建

如果你正准备参加蓝桥杯嵌入式竞赛，手里拿着那块STM32G431RBT6的开发板，感觉有点无从下手，那咱们今天就来好好聊聊。我参加过好几届的评审和指导工作，见过太多同学在基础环境上栽跟头，比如时钟配不对、下载不了程序，一上来就卡住，非常打击信心。其实，只要把开头这几步走稳了，后面的路会顺畅很多。

STM32G431RBT6这颗芯片是意法半导体专门为高性能嵌入式应用设计的，基于Arm Cortex-M4内核，主频最高能达到170MHz，但蓝桥杯竞赛为了公平和统一，通常会要求大家将系统时钟配置在80MHz。这个频率对于竞赛题目中的LED控制、LCD显示、传感器数据采集和通信任务来说，性能是绰绰有余的。整个开发流程，我们主要会依赖两个工具：STM32CubeMX和Keil MDK（或者你习惯的IAR）。CubeMX是个图形化配置工具，像搭积木一样设置芯片的引脚、时钟和外设，它能自动生成初始化代码，能省下我们大量手动编写底层寄存器配置的时间，让我们更专注于应用逻辑。

第一步，用CubeMX新建工程，选择正确的芯片型号STM32G431RBTx。接下来最关键的就是时钟树配置，这也是很多新手的第一个“拦路虎”。你需要找到时钟配置（Clock Configuration）标签页。通常，我们会选择外部高速时钟（HSE）作为时钟源，比如接一个8MHz的晶振。然后在时钟树图中，你需要一步步地将系统时钟（SYSCLK）配置到80MHz。具体操作是：先将PLL源选为HSE，然后设置PLL的倍频因子。对于8MHz的HSE，你可以将PLL倍频设置为20倍，这样PLL输出就是160MHz，再经过AHB预分频器2分频，就得到了80MHz的系统时钟。配置的时候，CubeMX会用颜色提示你是否超频，确保所有路径都是绿色就对了。

另一个必须注意的配置是在System Core里的SYS调试接口。一定要把Debug选项设置为“Serial Wire”。这是因为STM32G431采用了SWD调试协议，如果你这里选错了或者没选，程序烧录进去后，很可能就无法再次连接和下载新的程序了，也就是常说的“芯片锁死”。我亲眼见过有同学比赛时因为这个问题急得满头大汗。所以，记住这个口诀：“新建工程先调钟，调试接口别忘设Serial Wire”。配置完时钟和调试接口后，你就可以根据题目需求，在图形界面上点点鼠标，配置GPIO、定时器、ADC等外设了，最后生成工程代码，用Keil打开，一个最基础的工程框架就准备好了。

2. 点亮你的第一盏灯：GPIO与LED模块的实战精讲

配置好环境，咱们就来点实在的，让板子上的LED亮起来。这不仅是“Hello World”式的第一步，更是理解STM32如何控制引脚输出的关键。蓝桥杯竞赛板上的LED通常是连接在GPIOC的一组引脚上，并通过一个锁存器芯片（比如74HC573）来控制，锁存器的使能脚可能连着PD2。这种设计是为了用较少的MCU引脚控制多个LED，在资源有限的比赛中很常见。

在CubeMX里配置时，找到对应的引脚，比如PC8-PC15，将它们设置为GPIO_Output模式。默认输出电平可以设为高电平（GPIO_PIN_SET），因为我们的电路可能是低电平点亮LED。那个关键的锁存器控制脚PD2，也同样需要配置为输出模式。配置完成后生成代码，CubeMX会帮我们生成MX_GPIO_Init()函数，完成引脚的初始化。

接下来就是写代码控制了。直接调用HAL库函数HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, GPIO_PIN_RESET)可以让PC8输出低电平，点亮对应的LED。但考虑到我们有锁存器，操作需要遵循一个时序：先准备好要输出的数据（即哪些LED亮，哪些灭），然后通过控制锁存器引脚的一个电平跳变（通常是一个上升沿或下降沿），把这个数据“锁存”到输出端。我参考并优化了一下常见的代码逻辑：

// 定义一个全局变量来记录LED状态，每个bit对应一个LED
uint8_t led_status = 0;

// LED显示函数，负责将led_status的值输出到LED，并控制锁存器
static void LED_Refresh(void) {
    // 1. 首先关闭所有LED（假设高电平熄灭）。这里向GPIOC所有引脚写1。
    HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11 |
                           GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15, GPIO_PIN_SET);

    // 2. 将新的状态值输出到GPIOC的低8位（实际连接的是PC8-PC15，需要左移）
    // 注意：我们的状态变量led_status的bit0对应第一个LED，但硬件上可能接在PC8，所以需要左移8位
    HAL_GPIO_WritePin(GPIOC, (uint16_t)(led_status << 8), GPIO_PIN_RESET);

    // 3. 产生一个锁存脉冲，将数据锁存。以PD2为例，先拉高再拉低。
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_SET);
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_RESET);
}

// 点亮特定LED的函数
void LED_On(uint8_t led_num) {
    if(led_num < 8) { // 假设我们有8个LED
        led_status |= (1 << led_num); // 将对应位置1
        LED_Refresh(); // 刷新显示
    }
}

// 熄灭特定LED的函数
void LED_Off(uint8_t led_num) {
    if(led_num < 8) {
        led_status &= ~(1 << led_num); // 将对应位清0
        LED_Refresh();
    }
}

这里有个细节需要注意，HAL_GPIO_WritePin函数在同时控制多个引脚时，第二个参数是引脚号的组合，我们通过led_status << 8来将8位状态值映射到PC8-PC15这8个引脚上。LED_Refresh函数里的操作顺序很重要，必须先设置好数据，再触发锁存器，这样才能确保LED同时变化，没有毛刺。你可以把LED_On和LED_Off函数封装得更友好，比如用LED_Toggle来实现闪烁，这在竞赛中实现跑马灯、状态指示等功能时非常有用。

3. 让信息跃然屏上：LCD显示模块的配置与驱动解析

在嵌入式竞赛中，LCD显示屏是人机交互的核心，用来显示参数、波形、菜单等。蓝桥杯提供的通常是基于SPI或8080并口的液晶屏，比如1.44寸的TFT屏。官方会提供一个完整的驱动包，里面包含了底层的引脚初始化、写命令、写数据、画点等函数。我们的任务不是从头写驱动，而是理解如何调用这些驱动，高效地在屏幕上显示我们需要的信息。

首先，在CubeMX中配置LCD相关的引脚。这些引脚通常包括复位脚（RST）、片选脚（CS）、数据/命令选择脚（DC）、写使能脚（WR）和数据线（D0-D15）。你需要根据屏幕的数据手册或竞赛资料，将这些引脚配置为GPIO_Output模式。生成代码后，将官方提供的LCD驱动文件（如lcd.c和lcd.h）添加到你的工程中。驱动包里一般会有一个LCD_Init()函数，它已经封装好了复位、初始化序列、设置扫描方式等所有底层操作，我们直接调用即可。

初始化完成后，就可以使用驱动包提供的高级API来显示了。一个清晰的显示流程是这样的：

#include "lcd.h"

void LCD_Display_Setup(void) {
    // 1. 初始化LCD
    LCD_Init();

    // 2. 清屏，通常用黑色
    LCD_Clear(Black);

    // 3. 设置背景色和文字颜色，这决定了后续字符显示的样式
    LCD_SetBackColor(Black);
    LCD_SetTextColor(White); // 白字黑底，对比度高

    // 4. 在指定位置显示字符串
    char display_buffer[30];
    float voltage = 3.3;
    sprintf(display_buffer, "Voltage: %.2f V", voltage); // 格式化字符串
    LCD_DisplayStringLine(Line1, (uint8_t*)display_buffer); // 在第一行显示

    // 也可以显示变量、数字等
    int count = 100;
    sprintf(display_buffer, "Count: %d", count);
    LCD_DisplayStringLine(Line2, (uint8_t*)display_buffer);
}

这里的关键是sprintf函数，它能把各种变量格式化成字符串，然后交给LCD驱动显示。竞赛中经常需要动态更新显示内容，比如实时刷新的ADC电压值。如果直接在主循环里不断调用LCD_Clear和LCD_DisplayStringLine，会导致屏幕严重闪烁。优化的方法是局部更新：只重写发生变化的那部分区域。例如，你可以先记录上一次显示的值，只有当新值不同时，才用背景色“覆盖”旧数字，再写上新的数字。另外，驱动包里通常还有画线、画矩形、显示图片的函数，在需要显示波形图或简单界面时非常有用。我建议你提前熟悉这些函数，并自己封装一些实用函数，比如一个在指定坐标显示带标签数值的函数，这能在紧张的比赛时间里为你节省大量编码时间。

4. 掌控时间的脉搏：定时器模块的全面应用指南

定时器是STM32里最强大、最灵活的外设之一，在竞赛中用途极广：精确延时、按键消抖、产生PWM波、测量输入信号频率和占空比等等。STM32G431拥有多个高级定时器和通用定时器，我们得把它们用活了。

4.1 基础定时与按键扫描

首先是最简单的定时中断，可以用来实现毫秒级的精确延时或作为系统时基。比如我们用TIM3做一个10ms中断的按键扫描。在CubeMX里，选择TIM3，时钟源选内部时钟，然后计算参数。系统时钟是80MHz，定时器挂载在APB1总线上。设置预分频器（PSC）为8000-1，这样定时器时钟就是80MHz / 8000 = 10kHz。设置自动重装载值（ARR）为100-1，那么中断频率就是10kHz / 100 = 100Hz，即每10ms中断一次。开启定时器更新中断。

在中断回调函数里，我们可以实现一个非常稳健的按键扫描状态机。直接扫描GPIO电平会有抖动问题，用定时器中断扫描则可以完美解决：

// 按键状态结构体
typedef struct {
    uint8_t is_pressed;      // 当前物理按下状态
    uint8_t last_state;      // 上一次的状态，用于检测边沿
    uint8_t press_cnt;       // 按下计时，用于长按判断
    uint8_t short_event;     // 短按事件标志
    uint8_t long_event;      // 长按事件标志
} Key_TypeDef;

Key_TypeDef keys[4]; // 假设有4个按键

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {
    if (htim->Instance == TIM3) { // 10ms定时器
        uint8_t pin_state;
        for (int i = 0; i < 4; i++) {
            // 读取按键引脚状态（假设低电平为按下）
            pin_state = (HAL_GPIO_ReadPin(KEY_GPIO_Port[i], KEY_Pin[i]) == GPIO_PIN_RESET);

            // 状态机处理
            if (pin_state != keys[i].last_state) { // 状态发生变化
                keys[i].last_state = pin_state;
                if (pin_state == 1) { // 检测到按下边沿
                    keys[i].is_pressed = 1;
                    keys[i].press_cnt = 0;
                } else { // 检测到释放边沿
                    keys[i].is_pressed = 0;
                    if (keys[i].press_cnt < 50) { // 按下时间小于500ms (50*10ms)
                        keys[i].short_event = 1; // 触发短按事件
                    }
                    keys[i].press_cnt = 0;
                }
            } else if (keys[i].is_pressed) { // 保持按下状态
                keys[i].press_cnt++;
                if (keys[i].press_cnt == 100) { // 按下时间达到1000ms
                    keys[i].long_event = 1; // 触发长按事件
                }
            }
        }
    }
}

在主循环里，你只需要检查short_event和long_event标志位，然后执行相应操作并清除标志即可。这种非阻塞式的按键处理，比用HAL_Delay做消抖要高效、专业得多。

4.2 PWM输出：呼吸灯与电机控制

PWM常用于控制LED亮度、电机转速、舵机角度。我们以PA6（TIM16_CH1）输出100Hz，占空比可调的PWM为例。在CubeMX中配置TIM16，选择PWM Generation CH1模式。时钟源为80MHz，要产生100Hz的PWM，我们先设定ARR值决定周期。周期T = (ARR+1) / F_TIM。为了方便调节占空比，我们通常先固定ARR为一个较大的值，比如1000-1。那么定时器频率F_TIM = 80MHz / (PSC+1)。为了得到100Hz，计算PSC = (F_TIM / (ARR+1)) - 1 = (80MHz / 1000) / 100 - 1 = 800 - 1。这样，PWM周期就是100Hz，一个计数周期对应1ms。

占空比由捕获/比较寄存器CCR的值决定，占空比 = CCR / (ARR+1)。在代码中，我们启动PWM并动态修改CCR：

// 启动PWM通道
HAL_TIM_PWM_Start(&htim16, TIM_CHANNEL_1);

// 设置占空比为50%
__HAL_TIM_SET_COMPARE(&htim16, TIM_CHANNEL_1, 500); // CCR设为500，占空比=500/1000=50%

// 或者直接操作寄存器（速度更快，适合频繁更新）
TIM16->CCR1 = 750; // 占空比变为75%

你可以写一个函数，让CCR值在0到ARR之间循环变化，就能做出呼吸灯的效果。这在竞赛中做状态指示或简单的演示非常直观。

4.3 输入捕获：测量频率与占空比

输入捕获功能可以用来测量外部脉冲信号的频率和占空比，比如测量超声波测距模块的回响脉冲宽度，或者分析一个未知信号的参数。我们以PA7（TIM17_CH1）测量PA6输出的PWM信号为例。

在CubeMX中配置TIM17为输入捕获模式，通道选择“Input Capture direct mode”。时钟配置和PWM定时器类似。关键是要开启捕获中断。其原理是：当检测到指定的边沿（如上升沿）时，定时器当前的计数值CNT会被锁存到CCR寄存器中，并产生中断。我们记录两次上升沿之间的时间差，就能算出周期和频率。

volatile uint32_t capture_rising_val = 0;
volatile uint32_t capture_period = 0;
volatile uint32_t signal_freq_hz = 0;

void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim) {
    if (htim->Instance == TIM17) {
        static uint32_t last_capture = 0;
        uint32_t current_capture;

        current_capture = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1); // 读取CCR1的值

        if (current_capture >= last_capture) {
            capture_period = current_capture - last_capture;
        } else {
            // 处理计数器溢出
            capture_period = (0xFFFF - last_capture) + current_capture;
        }

        last_capture = current_capture;

        // 计算频率。定时器时钟为80MHz/(PSC+1)，假设PSC=80-1，则定时器计数频率为1MHz。
        if (capture_period > 0) {
            signal_freq_hz = 1000000 / capture_period; // 单位Hz
        }
    }
}

要测量占空比，则需要同时捕获上升沿和下降沿。你可以将同一个定时器的两个通道分别设置为上升沿和下降沿捕获，或者在同一个通道上切换捕获边沿。通过计算高电平时间占整个周期的比例，就能得到占空比。这个功能在分析555定时器构成的信号发生器输出时特别有用，竞赛中经常出现。

5. 感知世界：ADC模块的配置与数据采集优化

ADC（模数转换器）是连接模拟世界与数字世界的桥梁，在竞赛中用于读取电位器电压、光敏电阻值、温度传感器输出等。STM32G431的ADC分辨率是12位，意味着能将0到3.3V的参考电压分成4096个等级，理论精度约为0.8mV。

在CubeMX中配置ADC很简单。以测量PB15（ADC1_IN15）的电压为例。在Analog标签下选择ADC1，然后启用IN15通道。配置参数里，需要注意采样时间（Sampling Time）。对于信号源内阻较大或需要高精度的场合，适当增加采样时间可以让ADC内部的采样电容充放电更充分，结果更准确。对于竞赛板上的电位器，设置12.5或19.5个时钟周期通常就够了。转换模式可以选择“单次转换”或“连续转换”。单次转换更省电，由软件触发；连续转换则自动循环进行，数据更新更快。

采集代码的核心是启动转换和读取值：

// 获取指定ADC通道的电压值（单位：伏特）
float Get_ADC_Voltage(ADC_HandleTypeDef* hadc) {
    uint32_t adc_raw_value = 0;
    float voltage = 0.0f;

    // 启动ADC转换
    HAL_ADC_Start(hadc);
    // 等待转换完成，超时时间可以设长一点，比如10ms
    if (HAL_ADC_PollForConversion(hadc, 10) == HAL_OK) {
        // 读取转换结果
        adc_raw_value = HAL_ADC_GetValue(hadc);
        // 将原始值转换为电压值。Vref = 3.3V, 12位分辨率 = 4096
        voltage = (float)adc_raw_value * 3.3f / 4096.0f;
    }
    HAL_ADC_Stop(hadc); // 停止转换
    return voltage;
}

如果你需要采集多个通道，可以使用扫描模式。但要注意，在扫描模式下，DMA是更好的帮手，它可以在不占用CPU的情况下自动将转换结果搬运到指定的内存数组中。对于需要快速、连续采集波形的题目，一定要学会使用DMA。另外，为了提高测量稳定性，软件上可以做软件滤波。最简单的就是多次采样取平均：

#define ADC_SAMPLE_TIMES 32 // 采样32次取平均

float Get_ADC_Voltage_Average(ADC_HandleTypeDef* hadc) {
    uint32_t sum = 0;
    for (int i = 0; i < ADC_SAMPLE_TIMES; i++) {
        HAL_ADC_Start(hadc);
        HAL_ADC_PollForConversion(hadc, 1);
        sum += HAL_ADC_GetValue(hadc);
        HAL_ADC_Stop(hadc);
    }
    return (float)sum / ADC_SAMPLE_TIMES * 3.3f / 4096.0f;
}

更高级一点的可以用中位值平均滤波法（去掉最大最小值再平均），能有效抵抗突发性干扰。竞赛中，ADC的稳定性和准确性直接关系到分数，多花点心思在滤波上是值得的。

6. 数据的持久化：EEPROM读写与I2C通信实战

EEPROM是一种断电后数据不会丢失的存储器，常用于保存系统配置参数、校准数据、运行记录等。蓝桥杯竞赛板上通常外挂了一片AT24C02之类的EEPROM芯片，通过I2C总线与单片机通信。STM32G431的硬件I2C配置起来相对复杂，时序要求严格，所以竞赛更常使用软件模拟I2C，官方提供的驱动包里也往往包含了模拟I2C的代码。

首先，在CubeMX中配置连接EEPROM的两个引脚，比如PB6（模拟SDA）和PB7（模拟SCL），设置为GPIO_Output Open Drain模式（开漏输出）。开漏模式配合外部上拉电阻，才能实现I2C总线的“线与”功能。然后，将官方驱动文件i2c_hal.c和i2c_hal.h添加到工程。这些文件里已经实现了I2C_Start()、I2C_Stop()、I2C_SendByte()、I2C_ReceiveByte()等底层时序函数。

基于这些底层函数，我们来编写针对AT24C02的读写函数。AT24C02的器件地址是0xA0（写）和0xA1（读），它内部有256字节，地址范围0x00-0xFF。写操作有一个需要注意的地方：写完一个字节后，EEPROM需要几毫秒的时间进行内部擦写，这段时间内它不会应答，所以必须延时。

// 向指定地址写入一个字节
void EEPROM_WriteByte(uint8_t addr, uint8_t data) {
    I2C_Start();
    I2C_SendByte(0xA0); // 发送器件地址（写）
    I2C_WaitAck();
    I2C_SendByte(addr);  // 发送内存地址
    I2C_WaitAck();
    I2C_SendByte(data);  // 发送要写入的数据
    I2C_WaitAck();
    I2C_Stop();
    HAL_Delay(5); // 必须延时，等待EEPROM内部写周期完成
}

// 从指定地址读取一个字节
uint8_t EEPROM_ReadByte(uint8_t addr) {
    uint8_t received_data;
    // 先发送要读取的地址（伪写操作）
    I2C_Start();
    I2C_SendByte(0xA0);
    I2C_WaitAck();
    I2C_SendByte(addr);
    I2C_WaitAck();
    I2C_Stop(); // 注意这里有个停止信号

    // 然后发起读操作
    I2C_Start();
    I2C_SendByte(0xA1); // 发送器件地址（读）
    I2C_WaitAck();
    received_data = I2C_ReceiveByte();
    I2C_SendNAck(); // 读取单个字节后发送非应答
    I2C_Stop();
    return received_data;
}

在实际使用中，我们经常需要保存多个字节的数据，比如一个结构体。你可以写一个EEPROM_WritePage函数来写入一页（AT24C02一页是8字节），但要注意不能跨页写入。更通用的方法是定义一个联合体（union），将你的数据结构与字节数组关联，然后循环调用EEPROM_WriteByte进行保存和读取。务必记住，EEPROM有写入寿命限制（通常10万次），不要在程序里疯狂地、不间断地写EEPROM，应该只在必要时（如参数修改后）才写入。

7. 与外界对话：USART串口通信的稳定实现技巧

串口是调试和通信的利器，可以向电脑发送数据查看变量，也可以与其他模块（如蓝牙、GPS）通信。STM32G431的USART配置不算难，但要做到稳定可靠地接收数据，尤其是接收不定长字符串，需要一些技巧。

在CubeMX中配置USART1，模式选择异步通信（Asynchronous）。根据题目要求设置波特率（常用9600）、数据位（8）、停止位（1）、无校验。打开中断（NVIC Settings中使能USART全局中断）。生成代码后，HAL库已经帮我们生成了初始化函数。

基础的发送数据很简单：

char tx_buffer[50];
float temperature = 25.6;
sprintf(tx_buffer, "Temp: %.1f C\r\n", temperature);
HAL_UART_Transmit(&huart1, (uint8_t*)tx_buffer, strlen(tx_buffer), 100); // 超时100ms

难点在于接收，尤其是接收一串长度不确定的数据，比如从电脑串口助手发送来的“SET:1234”。HAL库提供了中断接收函数HAL_UART_Receive_IT，但它需要你预先知道要接收多少个字节。对于不定长数据，一个经典的做法是：开启空闲中断（IDLE Interrupt），或者用定时器辅助判断。

利用定时器判断一帧数据接收完成是一个很实用的方法。思路是：每次收到一个字节，就重置定时器计数器。如果超过一定时间（比如1.5个字符传输时间）没有再收到新字节，就认为一帧数据接收完成了。

// 定义接收缓冲区及相关变量
#define RX_BUF_SIZE 64
uint8_t rx_byte; // 用于中断接收的单个字节变量
uint8_t rx_buffer[RX_BUF_SIZE]; // 接收缓冲区
uint16_t rx_index = 0; // 缓冲区索引
volatile uint8_t rx_complete_flag = 0; // 接收完成标志

// 在main函数初始化部分，启动串口接收中断和定时器
HAL_UART_Receive_IT(&huart1, &rx_byte, 1); // 启动，每次接收1个字节
HAL_TIM_Base_Start_IT(&htim4); // 启动一个定时器，比如TIM4，配置为1ms中断

// 串口接收中断回调函数
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {
    if (huart->Instance == USART1) {
        // 收到一个字节，存入缓冲区
        if (rx_index < RX_BUF_SIZE - 1) { // 防止溢出
            rx_buffer[rx_index++] = rx_byte;
        }
        // 重置定时器计数器，重新开始计时
        __HAL_TIM_SET_COUNTER(&htim4, 0);
        // 重新启动接收中断，等待下一个字节
        HAL_UART_Receive_IT(&huart1, &rx_byte, 1);
    }
}

// 定时器中断回调函数（假设TIM4为1ms中断）
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {
    if (htim->Instance == TIM4) {
        static uint16_t idle_counter = 0;
        // 如果缓冲区有数据且一段时间没收到新数据
        if (rx_index > 0) {
            idle_counter++;
            // 如果超过15ms（可根据波特率调整）没有新数据，认为一帧结束
            if (idle_counter > 15) {
                rx_buffer[rx_index] = '\0'; // 添加字符串结束符
                rx_complete_flag = 1; // 设置完成标志
                idle_counter = 0;
                // 这里不要清零rx_index，主函数处理完后再清
            }
        } else {
            idle_counter = 0;
        }
    }
}

// 在主循环中处理接收完成的数据
if (rx_complete_flag) {
    rx_complete_flag = 0;
    // 此时rx_buffer里就是接收到的完整字符串，rx_index是长度
    // 可以进行协议解析，例如sscanf
    char cmd[10];
    int value;
    if (sscanf((char*)rx_buffer, "%s %d", cmd, &value) == 2) {
        // 解析成功，执行相应命令
    }
    // 处理完成后，清空缓冲区，准备下一次接收
    rx_index = 0;
    memset(rx_buffer, 0, RX_BUF_SIZE);
}

这种方法稳定可靠，能适应不同的数据长度。在竞赛中处理串口指令时，记得做好缓冲区溢出保护和数据校验，比如判断帧头帧尾，或者计算校验和。

8. 记录时光流逝：RTC实时时钟的配置与应用

RTC模块可以提供一个独立的日历时钟，即使主电源断开，依靠后备电池（纽扣电池）也能继续走时。在需要记录数据产生时间的竞赛题目中非常有用，比如环境数据采集器。

在CubeMX中配置RTC很简单。在Pinout & Configuration标签页的Timers里找到RTC，勾选“Activate Clock Source”和“Activate Calendar”。然后在下方可以设置初始的年月日时分秒。你还可以配置闹钟，在特定时间产生中断。注意，RTC的时钟源通常选择LSE（外部低速晶振，32.768kHz），因为它精度高、功耗低。如果板子上没有焊接LSE晶振，也可以选择LSI（内部低速RC振荡器），但精度会差一些。

配置完成后，HAL库提供了完整的设置和获取时间的函数。这里有一个细节：RTC内部存储时间有两种格式，BIN（二进制）和BCD（二十进制）。BCD格式更便于显示，但计算时可能需要转换。

RTC_TimeTypeDef sTime = {0};
RTC_DateTypeDef sDate = {0};

// 设置时间：2024年5月27日，下午2点30分15秒
sTime.Hours = 14;
sTime.Minutes = 30;
sTime.Seconds = 15;
sTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
sTime.StoreOperation = RTC_STOREOPERATION_RESET;
if (HAL_RTC_SetTime(&hrtc, &sTime, RTC_FORMAT_BIN) != HAL_OK) {
    Error_Handler();
}

sDate.WeekDay = RTC_WEEKDAY_MONDAY;
sDate.Month = RTC_MONTH_MAY;
sDate.Date = 27;
sDate.Year = 24; // 年份是两位，2024年就是24
if (HAL_RTC_SetDate(&hrtc, &sDate, RTC_FORMAT_BIN) != HAL_OK) {
    Error_Handler();
}

// 获取当前时间
HAL_RTC_GetTime(&hrtc, &sTime, RTC_FORMAT_BIN);
HAL_RTC_GetDate(&hrtc, &sDate, RTC_FORMAT_BIN);

// 将时间格式化显示到LCD或串口
char time_str[20];
sprintf(time_str, "%02d-%02d-%02d %02d:%02d:%02d",
        sDate.Year + 2000, sDate.Month, sDate.Date,
        sTime.Hours, sTime.Minutes, sTime.Seconds);

闹钟功能可以在特定时间（比如每天凌晨）唤醒处于低功耗模式的单片机，或者触发一个事件。配置好闹钟时间和匹配模式（可以只匹配时、分、秒，或全部匹配）后，在闹钟中断回调函数HAL_RTC_AlarmAEventCallback里编写你的处理逻辑即可。

最后提一下代码优化。在Keil的Options for Target -> C/C++选项卡中，有一个“Optimization”选项。在开发调试阶段，建议选择-O0（不优化），这样程序代码和你的源代码是一一对应的，方便设置断点和单步调试。但在最终提交比赛工程前，可以尝试改为-O1或-O2优化等级。编译器优化会重新编排和精简你的代码，有时能显著减少程序体积并提高运行速度。但优化也可能带来一些意想不到的问题，比如某些延时循环被优化掉，或者变量在调试时观察不到。所以，一定要在优化后对整个程序功能进行完整的测试，确保其行为与优化前一致。