当前位置：首页 > news >正文

Using the CubeMX code (一)(GPIO,PWM ,Cube AI,手写数字识别 MNIST,Demo)

news 来源：原创 2025/8/19 3:49:24

该例程对使用CubeMX初始化GPIO做了示范，GPIO使用HAL库进行GPIO编程分为以下几个步骤：

一、例程简述

1. 包含必要的头文件和HAL库的相关头文件

CubeMX初始化会自动包含，对手敲HAL感兴趣的同学可以熟悉下生成的代码框架学习哦~

2. 初始化GPIO外设

 `GPIO_InitTypeDef GPIO_InitStructure;`

3. 配置GPIO引脚的模式和参数

 GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;    // 输出模式GPIO_InitStructure.Pull = GPIO_NOPULL;            // 不使用内部上下拉电阻GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_LOW;   // 低速GPIO_InitStructure.Pin = GPIO_PIN_13;             // 配置的引脚HAL_GPIO_Init(GPIOC, &GPIO_InitStructure);        // 初始化GPIOC外设

4. 设置GPIO引脚的电平

 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET);   // 设置引脚为高电平

5. 读取GPIO引脚的电平

 if (HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_13) == GPIO_PIN_SET)   // 判断引脚是否为高电平{// 做一些操作...}

6. GPIO应用示例代码

下面是一个简单的示例，说明如何使用HAL库配置一个GPIO引脚并控制其电平：

 #include "stm32f4xx.h"#include "stm32f4xx_hal.h"void GPIO_Config(void){GPIO_InitTypeDef GPIO_InitStructure;// 初始化GPIOC外设__HAL_RCC_GPIOC_CLK_ENABLE();GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;GPIO_InitStructure.Pull = GPIO_NOPULL;GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_LOW;GPIO_InitStructure.Pin = GPIO_PIN_13;HAL_GPIO_Init(GPIOC, &GPIO_InitStructure);}int main(void){// 初始化HAL库HAL_Init();// 配置GPIO引脚GPIO_Config();// 此处范例为500ms翻转一次PC13，对应炸鸡板的用户灯引脚，效果为闪光灯。while (1){// 设置引脚为高电平HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET);// 延时一段时间HAL_Delay(500);// 设置引脚为低电平HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);// 延时一段时间HAL_Delay(500);}}

二、工程创建

（仅本次进行完全示范，之后例程README.md仅演示新内容）

1.打开CubeMX，选择ACCESS TO MCU SELECTOR

2.选择对应炸鸡板MCU--STM32F411RET6

3.初始化时钟（配置时钟树）

4.初始化GPIO（用于控制炸鸡板用户灯）

5.生成初始化工程

三、GPIO扩展知识（该部分摘自尝试使用CubeMX做stm32开发之四：GPIO配置）

1）GPIO output level：只有当引脚设置为“GPIO output”时才需要设置

     High：GPIO输出初始化为高电平Low：GPIO输出初始化为低电平

2）GPIO mode

     Output Push Pull：推挽输出，能输出高低电平，且高低电平都有驱动能力。以PB13引脚为例，若需要通过其控制LED灯，则该引脚应配置为“Output Push Pull”模式，对应标准库函数中的“GPIO_Mode_Out_PP”Output Open Drain：开漏输出，只能输出低电平，需要借助外部上拉电阻才能输出高电平，对应标准库函数中的“GPIO_Mode_Out_OD”Analog mode：模拟输入，ADC采样信号输入引脚的配置模式，对应标准库函数中的“GPIO_Mode_AIN”Alternate Function Push Pull：推挽式复用功能，对应标准库函数中的“GPIO_Mode_AF_PP”Input mode：输入模式，配合No pull-up/pull-down可形成GPIO_Mpde_IN_FLOATING、GPIO_Mode_IPD、GPIO_Mode_IPU等不同工作模式

3）GPIO Pull-up/Pul-down

     No pull-up/pull-down：无内部上拉或下拉Pull-up：内部上拉Pull-down：内部下拉

4）Maximum output speed

     Low：低速，对应标准库函数中的“GPIO_Speed_2MHz”Medium：中速，对应标准库函数中的“GPIO_Speed_10MHz”High：高速，对应标准库函数中的“GPIO_Speed_50MHz”

5）User Label：用户标签，可以按照需要给引脚命名

普通GPIO口配置（用于控制LED灯）

ADC引脚配置

串行烧录引脚配置

TIM比较输出引脚配置

UART引脚配置

使用了如下函数进行了print重定向，记得勾选use Mirco LIB

int fputc(int ch, FILE *f)
{
HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xffff);
return ch;
}

如果需要不定长发送，可以看一下如何使用Idel空闲标志位如何使用，结合DMA一起使用

PWM Demo

1. 示例一：PWM_base例程

cubemx配置好后，在main函数中启动pwm。这里使用的是TIM2 channel3。

 //Start the pwmHAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_3);//PA2

如果要更改占空比，更改MX_TIM2_Init()中的pulse即可，这里预分频设置为99，那么每加一个count则需要1÷(100÷(99+1))s，为1MHz，1us，这里再设置htim2.Init.Period为999，那么定时器的周期则为1ms了。

sConfigOC.Pulse = 300为设置载波的数值，调节此处可以调节占空比。原理详见手册。

 void MX_TIM2_Init(void){/* USER CODE BEGIN TIM2_Init 0 *//* USER CODE END TIM2_Init 0 */TIM_MasterConfigTypeDef sMasterConfig = {0};TIM_OC_InitTypeDef sConfigOC = {0};/* USER CODE BEGIN TIM2_Init 1 *//* USER CODE END TIM2_Init 1 */htim2.Instance = TIM2;htim2.Init.Prescaler = 99;htim2.Init.CounterMode = TIM_COUNTERMODE_UP;htim2.Init.Period = 999;htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;if (HAL_TIM_PWM_Init(&htim2) != HAL_OK){Error_Handler();}sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK){Error_Handler();}sConfigOC.OCMode = TIM_OCMODE_PWM1;sConfigOC.Pulse = 300;sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_3) != HAL_OK){Error_Handler();}/* USER CODE BEGIN TIM2_Init 2 *//* USER CODE END TIM2_Init 2 */HAL_TIM_MspPostInit(&htim2);}

第一张图是pulse设置为300，第二张图是设置为800。

2.示例二： PWM互补输出，带死区

PWM互补输出带死区的通俗解释

一、PWM互补输出：一开一闭的“双人舞”

想象有两个开关（比如H桥的上下桥臂），它们的动作必须完全相反：当开关A打开时，开关B必须关闭，反之亦然。
PWM互补输出就是通过定时器生成两路完全反向的PWM信号，分别控制这两个开关。例如：

主信号高电平 → 上桥臂导通（电流流向负载）
互补信号低电平 → 下桥臂关闭（避免短路）
主信号低电平 → 下桥臂导通（电流反向流动）

这种互补关系就像两个人交替开合门，确保电流始终有正确的流动路径，常用于电机正反转、逆变器等场景。

二、死区时间：防止“打架”的安全间隔

虽然理论上互补信号应该无缝切换，但现实中开关元件（如MOSFET、IGBT）存在物理延迟：

关闭需要时间（比如0.1微秒）
开启也需要时间（比如0.05微秒）

问题：如果两路信号切换时没有间隔，可能出现短暂的上下桥同时导通 → 电源直接短路 → 烧毁元件！
解决：在两路信号切换时插入一段死区时间（Dead Time），让两个开关都短暂关闭，确保安全。

示例：

主信号从高变低 → 上桥开始关闭
死区时间开始（比如1微秒）→ 上下桥都强制关闭
死区结束后 → 互补信号变高，下桥才开启

三、死区的影响与设置要点

必要性：
- 避免短路和元件损坏（核心作用）
- 减少电流突变导致的电磁干扰
副作用：
- 实际输出波形会有微小中断 → 可能影响控制精度（占空比需补偿）
- 死区时间越长，系统效率越低（需平衡安全与性能）
设置规则：
- 根据元件开关延迟（参考元件手册）
- 高温环境需延长死区（元件关闭更慢）
- 典型值：IGBT常用3微秒以上，MOSFET约1微秒

四、实际应用场景

电机驱动：H桥电路控制电机正反转（互补信号驱动上下桥臂）
逆变器：将直流电转为交流电（互补PWM生成正弦波）
电源转换：防止开关电源中上下管直通短路

技术细节补充：

STM32实现：高级定时器（如TIM1）可直接配置互补输出和死区时间，通过寄存器TIMx_BDTR设置死区时钟周期数。
死区计算公式：
- 死区时间 = 关闭延迟时间 - 开启延迟时间 + 安全余量

1. H桥的基本工作逻辑

H桥由四个开关（如MOS管）组成，形状像字母H，中间的横杠是电机。

正转：左上和右下开关导通（Q1和Q4），电流从左上→电机→右下→地，电机正转。
反转：右上和左下开关导通（Q2和Q3），电流方向相反，电机反转。

问题根源：如果同一侧的两个开关（如左上和左下Q1和Q2）同时导通，电流会直接从电源正极→Q1→Q2→地，形成短路！这就像把电源正负极用导线直接连起来，瞬间电流极大，烧毁元件。

2. 为什么会发生上下桥短路？

原因①：开关的物理延迟

MOS管或三极管不是“瞬间开关”，关闭需要时间（比如0.1微秒）。例如：

切换方向时：假设正转切换为反转，Q1和Q4需要关闭，Q2和Q3需要开启。
实际场景：如果Q1还没完全关闭，Q2就已经开启，电流会从Q1→Q2→地，形成短路。

原因②：控制信号不同步

如果用普通PWM信号控制，可能因软件逻辑错误或信号干扰，导致同一侧的两个开关同时收到“开启”信号。

3. 如何避免短路？

方案①：死区时间（安全间隔）

在切换开关时，插入一段“双方都关闭”的时间（比如1微秒），确保上一个开关完全关闭后，再开启下一个开关。

类似场景：交通信号灯切换时，红灯和绿灯之间会有黄灯作为过渡，防止两方向车流相撞。

方案②：互锁电路（硬件保护）

用逻辑电路（如与非门）保证同一侧的开关信号永远互斥，一个开启时另一个强制关闭。

类似场景：电梯门的开关按钮，按“开”时“关”自动失效。

方案③：专用驱动芯片

例如L298N、HIP4081等芯片，内置死区时间和互锁逻辑，直接输出安全信号。

4. 实际应用中的典型错误

案例1：用分立元件搭建H桥，忘记设置死区时间，切换方向时烧毁MOS管。
案例2：使用低端MOS管驱动大电流电机，关断延迟过长，死区时间不足导致短路。

总结：H桥设计的核心安全法则

时序为王：死区时间必须覆盖开关元件的物理延迟。
硬件兜底：用互锁电路或专用芯片强制避免信号冲突。
测试验证：用示波器观察信号切换时的实际间隔，确保无重叠。

一句话记忆：H桥切换方向时，一定要“关完再开”，否则电流狂欢，元件火葬场！🔥

通过这种机制，系统既能高效控制功率，又能避免硬件损毁，是电力电子设计的核心保护措施。

详细设置见代码和cubemx工程，下图为带死区的PWM互补输出。

在MX_TIM1_Init()中设置如下代码，即可更改死区时间

 sBreakDeadTimeConfig.DeadTime = 20;

死区的计算方式如下图所示，详细见参考手册。

1. 死区时间的作用

死区时间就是防止H桥上下管同时导通的“安全间隔”，就像红绿灯切换时中间的黄灯时间，避免两方向的车（电流）相撞。

核心目标：确保上管完全关闭后，下管才开启，防止短路烧毁元件。

2. DTG[7:0]：调节死区时间的“档位旋钮”

DTG[7:0] 是一个8位的二进制数值（范围0~255），用来控制死区时间的长短。
如何计算时间：根据DTG的最高3位（DTG[7:5]）的不同值，选择不同的计算公式，类似“档位切换”：
- 档位1（DTG[7:5]=0xx）：死区时间 = DTG[7:0] × 单个时间单位（如125ns）。
- 档位2（DTG[7:5]=10x）：死区时间 = [64 + DTG[5:0]] × 2 × 时间单位。
- 档位3（DTG[7:5]=110）：死区时间 = [32 + DTG[4:0]] × 时间单位。
- 档位4（DTG[7:5]=111）：死区时间 = [32 + DTG[4:0]] × 2 × 时间单位。

示例（假设时间单位=125ns）：

若DTG[7:0]=100（二进制），且档位1：
死区时间 = 100 × 125ns = 12.5微秒。
若DTG[7:0]=10100000（二进制，DTG[7:5]=101），则进入档位2：
死区时间 = [64 + 32] × 2 × 125ns = 24微秒。

1. DTG寄存器：死区时间的“多档调节器”

DTG寄存器就像一个多档位的旋钮开关，用8位二进制数（0~255）控制死区时间的长短。它的核心原理是：根据最高3位的值（DTG[7:5]）选择不同计算公式，从而适配不同的时间范围和精度需求。
类比：就像汽车的档位（1档低速高精度，4档高速低精度），DTG的四个档位对应不同的时间范围和调节方式。

2. 四档位的具体规则

档位1（DTG[7:5]=0xx）

条件：最高3位是0xx（例如000、001等）。
公式：死区时间 = DTG[7:0] × 时间单位（如125ns）。
特点：小范围高精度，适合精细调节。
示例：
若DTG=100（二进制），时间单位=125ns：
死区时间 = 100 × 125ns = 12.5微秒。

档位2（DTG[7:5]=10x）

条件：最高3位是10x（例如100、101等）。
公式：死区时间 = [64 + DTG[5:0]] × 2 × 时间单位。
特点：中等范围中精度，适合常规需求。
示例：
若DTG=10100000（二进制），最高3位是101，时间单位=125ns：
DTG[5:0]=32（低6位），死区时间 = (64+32) × 2 × 125ns = 24微秒。

档位3（DTG[7:5]=110）

条件：最高3位是110。
公式：死区时间 = [32 + DTG[4:0]] × 8 × 时间单位。
特点：大范围低精度，适合粗调。
示例：
若时间单位=13.89ns（72MHz时钟），DTG[4:0]=31：
死区时间 = (32+31) × 8 × 13.89ns ≈ 7微秒。

档位4（DTG[7:5]=111）

条件：最高3位是111。
公式：死区时间 = [32 + DTG[4:0]] × 16 × 时间单位。
特点：超大范围粗糙调节，适合极端需求。
示例：
若时间单位=13.89ns，DTG[4:0]=31：
死区时间 = (32+31) × 16 × 13.89ns ≈ 14微秒。

3. 时间单位与时钟频率的关系

时间单位 = 1/系统时钟频率。例如：
- 72MHz时钟 → 时间单位=1/72MHz≈13.89ns。
- 若示例中使用125ns，可能是外部时钟或分频后的结果。
调节范围：从几纳秒到上百微秒，覆盖常见硬件需求。

4. 实际配置技巧

根据硬件需求选档位：
- 小死区时间（3微秒以内）→ 档位1或2。
- 大死区时间（7微秒以上）→ 档位3或4。
计算DTG值：
- 先确定所需死区时间，再反推DTG二进制值（如示例中的24微秒对应DTG=0xAC）。
验证：用示波器观察PWM信号，确保死区无重叠。

总结

DTG寄存器通过分档位+公式组合，灵活适配不同场景的死区时间需求。就像调节音量旋钮时选择“精细微调”或“快速粗调”，既能保护硬件安全，又能平衡控制精度和效率。

3. 时间范围和步长（类似“量程切换”）

当时间单位=125ns时，不同档位对应不同的时间范围和调节精度：

小范围高精度：0~15.875微秒，步长125ns（适合精细调节）。
中等范围中精度：16~31.75微秒，步长250ns。
大范围低精度：32~63微秒，步长1微秒。
超大范围粗糙调节：64~126微秒，步长2微秒。

类比：像手表调节时间的旋钮，有的档位适合调秒（精确），有的档位适合调小时（快速）。

4. LOCK位：死区时间的“防误触锁”

LOCK位（在TIMx_BDTR寄存器中）是保护开关，设置为1、2或3时，禁止修改死区时间设置。
作用：防止程序跑飞或误操作意外修改死区时间，导致硬件损坏。
使用方法：先配置好死区时间，最后再设置LOCK位锁定。

5. 配置步骤总结

选档位：根据需要的死区时间范围，确定DTG[7:5]的取值（0xx/10x/110/111）。
算数值：用公式计算DTG[7:0]的二进制值。
写寄存器：将DTG值写入TIMx_BDTR寄存器的DTG[7:0]位。
上锁：设置LOCK位（如LOCK=1）保护配置。

避坑指南：

死区时间必须大于开关元件的关闭延迟（参考元件手册）。
测试时用示波器观察实际信号间隔，验证配置是否正确。

一句话总结

这段说明书教你如何用“档位+数值”精确调节H桥的安全间隔（死区时间），并提醒配置后要上锁，防止误改引发炸管！

3. 作业

这里仅展示了PWM的部分功能，更多详细的可以看官方的手册和官方的例程。

感兴趣可以尝试下如何生成SPWM，完成呼吸灯的效果。

Cube AI Demo

该例程使用Cube AI套件，在STM32上运行一个神经网络，功能实现分为以下几个步骤：

一、搭建一个神经网络

1. 模型搭建

这里是我们的目标是预测正弦函数。给定一个输入，范围(0, 180)，输出其对应的正弦值范围(0, 1)。搭建的网络结构如下图所示：

2. 生成sin(x)数据，进行模型的训练

在./python_code文件夹中已经给出所有的文件，请自行查看。在这里生成sin(x)的一系列数据后，使用keras框架搭建模型进行训练，激活函数使用tanh，没有使用sigmod是因为其不能表达负数的部分。学习率设置为0.001，epoch设置为2000。最后生成.h5和.tflite文件。

 #导入工具包import tensorflow as tfimport pandas as pdimport numpy as np#读取数据data = pd.read_csv('./Embedded_things/sin_values.csv', sep=',', header=None)raw_x = data.iloc[:,0].astype(float)sinex = data.iloc[:,1].astype(float)print(sinex.shape)#建立模型model = tf.keras.Sequential()model.add(tf.keras.layers.Dense(units=10, activation='tanh', input_shape=(1,)))model.add(tf.keras.layers.Dense(units=5, activation='tanh'))model.add(tf.keras.layers.Dense(units=1))model.summary()model.compile(optimizer=tf.keras.optimizers.AdamW(0.001),loss=tf.keras.losses.mse,                      #loss使用均方差，刚才的分类用的交叉熵metrics=[tf.keras.metrics.mse])history = model.fit(x=raw_x, y=sinex, epochs=2000)print(model.evaluate(raw_x, sinex))#保存模型model.save('./Embedded_things/sine_calcu.h5')#转换模型为tf lite格式 不量化load_model = tf.keras.models.load_model('./Embedded_things/sine_calcu.h5')converter = tf.lite.TFLiteConverter.from_keras_model(load_model)tflite_model = converter.convert()open("./Embedded_things/sine_calcu.tflite", "wb").write(tflite_model)

如果想测试一下模型，可以看一下test.py，这里就不过多进行阐述。以下是在./python_code中所有的文件，读者请自行查阅。

二、STM32工程创建

1.打开CubeMX，把常规的设置都设置好，打开串口等

2.打开select components，选上X-CUBE-AI

3.添加网络，选择你的模型（.h5或.tflite），再进行验证

4.生成工程

5.更改代码

在main中，找到MX_X_CUBE_AI_Process()函数，然后更改其中的aiSystemPerformanceProcess()函数，更改为如下内容，其具体含义读者可以阅读手册或看API深入了解，这里不过多阐述。

 int aiSystemPerformanceProcess(void){int idx = 0;int batch = 0;float y_pred;ai_buffer ai_input[AI_MNETWORK_IN_NUM];ai_buffer ai_output[AI_MNETWORK_OUT_NUM];ai_float input[1] = {0};  // initialai_float output[1] = {0};if (net_exec_ctx[idx].handle == AI_HANDLE_NULL){printf("E: network handle is NULL\r\n");return -1;}ai_input[0] = net_exec_ctx[idx].report.inputs[0];ai_output[0] = net_exec_ctx[idx].report.outputs[0];//ai_float test_data[] = {0, 1, 2, 3, 4, 5, 6, 7};uint16_t i=0;while(i<=180){i++;if(i == 180){i=0;}input[0] = i;output[0] = 0;ai_input[0].data = AI_HANDLE_PTR(input);ai_output[0].data = AI_HANDLE_PTR(output);batch = ai_mnetwork_run(net_exec_ctx[idx].handle, &ai_input[0], &ai_output[0]);if (batch != 1){aiLogErr(ai_mnetwork_get_error(net_exec_ctx[idx].handle),"ai_mnetwork_run");break;}y_pred = sin(input[0]*acos(-1)/180);printf("input, y_pre, y_ture: %.2f, %.2f, %.2f\r\n", input[0], output[0], y_pred);HAL_Delay(100);}}

整个代码就像钟表齿轮生产线

int 智能校时系统(void)
{// 初始化生产线int 当前工位 = 0;                // 只启用第一条生产线float 标准时间;                  // 瑞士天文台认证时间时间原料 待加工角度 = {0};        // 待组装的齿轮角度（0-180度）成品表针 预测结果 = {0};          // 组装完成的表针位置// 检查精密机床是否就绪if (校时机床.状态 == 未启动) {printf("精密校准仪故障！\n");return -1;                   // 紧急停止生产线}// 连接加工设备进料传送带 = 校时机床.原料入口;成品出口 = 校时机床.成品出口;// 启动永动流水线uint16_t 当前角度=0;while(持续运转){当前角度++;                  // 齿轮转动1度if(当前角度 == 180) 当前角度=0; // 完成半圈自动复位// 原料装载待加工角度 = 当前角度;         // 装入待加工的齿轮角度成品表针 = 0;                // 清空成品托盘// 精密加工（AI预测）加工状态 = 启动校时机床(进料传送带, 成品出口);if(加工异常){触发警报(校时机床.故障代码);break;}// 天文台认证标准时间 = 正弦函数(角度转弧度(当前角度)); // 获取瑞士标准printf("角度:%03d° | AI指针:%.2f | 天文台标准:%.2f\n", 当前角度, 成品表针, 标准时间);维持流水线节奏(100ms);       // 控制每分钟60转}
}

核心环节详解

设备检查：
- 如同钟表厂每日开机前的设备巡检，确保校时机床（神经网络）已正确加载

流水线运转：

齿轮持续转动0°→180°→0°，模拟钟表运作：

while(当前角度 <= 180) {当前角度++;if(当前角度 == 180) 复位归零;  // 类似钟表走到6点位置后回弹
}

AI校时机制：
- 进料：将当前齿轮角度送入传送带（input[0] = i）
- 加工：校时机床用神经网络"打磨"角度（ai_mnetwork_run）
- 出料：获得表针预测位置（output[0]）
双重认证系统：
- 同时用数学公式计算标准值，如同：
  - 普通手表 VS 瑞士天文台认证
  - 预测结果 VS 真实正弦值
- 实时打印对比，像质检员在流水线终点比对：
```
角度:090° | AI指针:1.00 | 天文台标准:1.00
角度:123° | AI指针:0.84 | 天文台标准:0.83
```
精密节奏控制：
- HAL_Delay(100) 如同瑞士钟表的摆轮擒纵机构，确保每100ms处理1度，维持精准节奏

这个比喻的巧妙之处

动态演示：像观赏透明机械表，直观看到齿轮联动过程
误差可视化：表针位置偏差类似机械表的日误差显示
嵌入式特性：
- 单一加工程序对应简单结构（0-180度循环）
- 异常处理如同防震装置，遇到剧烈震动自动停摆
- 内存管理像高效利用表壳内的有限空间

实际运行效果

当连接示波器时，会看到如同时光机般的场景：

角度:000° | AI指针:0.00 | 标准:0.00  ← 12点位置
角度:030° | AI指针:0.50 | 标准:0.50  ← 1点位置
角度:090° | AI指针:1.00 | 标准:1.00  ← 3点位置（顶端）
角度:150° | AI指针:0.50 | 标准:0.50  ← 5点位置
角度:180° | AI指针:0.00 | 标准:0.00  ← 6点位置

就像有个隐形的瑞士制表师，在芯片内部持续校准着这个"AI机械表"，既展示科技之美，又暗藏传统钟表匠的精密追求。

5.验证

通过串口传数据到上位机VAFA，其中蓝色的线为准确的sin(x)的值，绿色的为模型输出的值，可以看到拟合的比较好，但是在接近sin(x)=0的附近，拟合的比较不好。

一、神经网络部分（相当于训练"计算器"）

目标：输入一个角度（0-180度），输出对应的正弦值（0-1）
模型结构：
- 类似三层过滤网：
  1. 第一层：10个"计算单元"（神经元）
  2. 第二层：5个"计算单元"
  3. 第三层：输出结果
- 使用tanh激活函数（既能处理正数也能处理负数，比sigmoid更适合）
训练数据：
- 用0-180度的正弦值作为训练数据（类似给计算器输入标准答案）
- 训练2000遍（相当于反复做题直到学会）
输出结果：
- 生成两个文件：.h5（完整模型文件）和.tflite（精简版，专为嵌入式优化）

二、STM32运行部分（把"计算器"装进硬件）

硬件配置：
- 使用STM32CubeMX（图形化配置工具）设置芯片功能
- 添加X-CUBE-AI插件（相当于给STM32安装AI运行环境）
部署模型：
- 导入训练好的.tflite文件
- 自动生成可在STM32上运行的C代码（把数学计算转换成芯片能理解的指令）

核心代码逻辑：

循环0-180度 {输入当前角度 → 神经网络计算 → 输出预测值同时计算真实正弦值（用于对比）通过串口发送数据到电脑显示
}

三、实际效果

在电脑上看到两条曲线：
- 蓝色：真实的正弦曲线（数学计算）
- 绿色：神经网络预测的曲线
整体拟合良好，但在接近0度/180度时误差较大（可能因为数据分布不均匀或模型容量有限）

四、类比理解

想象训练一个"智能计算器"：

先让它在电脑上学会计算正弦函数（训练模型）
然后把这个计算器的"大脑"移植到STM32芯片里
最后通过串口观察它的计算是否准确

整个过程展示了如何把人工智能算法落地到真实的硬件设备上，是嵌入式AI开发的典型流程。

手写数字识别 MNIST Demo

该例程使用触摸屏p169h002-ctp，在LCD上进行手写数字，再进行手写数字的识别。动态演示图如下所示：

MNIST是一个非常经典的机器学习的入门案例，本demo将会使用keras进行训练，导出模型部署到FryPie炸鸡派上。

一、文件夹组成

 ├─python_codes│  │  mnist.npz│  │  mnist.h5│  │  train.py│     └─stm32_codes├─MNIST

文件夹大致如上，python_codes存放的是：train.py用于训练网络，mnist.npz为网上找的下载的MNIST数据集，用于网络的训练和测试，最后训练好的模型保存为mnist.h5。

二、触摸屏手写显示在LCD

屏幕的大小是240×280，使用上240×240部分作为绘制板，用于手写显示，下面240×40的部分用于显示识别的结果。读取点与绘制如下代码所示。由于CST816读取频率问题，绘制的触摸点与点的距离会有一定距离，同时1×1的点非常小，因此，需要对点进行膨胀，都变为8×8的黑点绘制到LCD上，其中SCALL_RATE为8。同时，这里也要完成originalImage数组的填充，作为原始的图片数据。

当然，还有一个问题，如果手写滑动速度太快，就算扩充成了8×8，点与点的距离远了看起来还是很明显，所以推荐再做处理，将没相连的黑点连接在一起。

时间采样率低（触摸点采集频率）和空间膨胀（8x8 方块）是两个维度的处理，但它们通过互补解决了同一个问题。我来拆解背后的原理：

1. 时间采样率低导致的问题

假设触摸屏每秒采样 10 次（实际可能更高，但原理相同）：

快速滑动时：比如手指以 20像素/毫秒 的速度移动，两次采样间隔 100ms，手指移动了 20px/ms * 100ms = 2000px（远超屏幕宽度）。
实际场景：极端情况下，两次采样点可能相距很远（比如点 A 和点 B 相隔 100 像素），形成断裂的轨迹。

2. 空间膨胀如何弥补时间间隔

将每个采样点膨胀为 8x8 的方块，本质是 用空间覆盖时间不足：

假设两次采样点相距 15 像素（比如点 A 在 (10,10)，点 B 在 (25,10)）：
- 未膨胀时：两个点独立，中间有 15 像素的空白。
- 膨胀后：点 A 的 8x8 方块覆盖 (10±4, 10±4)，点 B 的方块覆盖 (25±4,10±4)。
- 结果：两个方块在 X 轴上的覆盖范围是 6~14 和 21~29，中间仍有间隙（14~21 之间空白）。
但如果点间距 ≤ 膨胀尺寸：
- 比如点间距 8 像素，膨胀后的方块会边缘重叠，覆盖中间空白。

3. 为什么实际中能“看起来连续”

人类书写速度有限：正常手写数字时，手指移动速度不会极快（比如每秒滑动 1000 像素）。
膨胀尺寸的巧妙设计：
- 8x8 方块的尺寸（约屏幕的 3.3%）是根据典型书写速度和设备采样率平衡后的结果。
- 在大多数实际书写场景中，两次采样点的间距会被膨胀后的方块覆盖或部分重叠，视觉上形成连续线条。

4. 数学视角：覆盖间隙的条件

设：

采样时间间隔：Δt 秒
手指移动速度：v 像素/秒
膨胀方块边长：s 像素

两次采样点间距：d = v * Δt
覆盖间隙的条件：s ≥ d
如果满足此条件，膨胀后的方块会完全覆盖两次采样点之间的间隙。

实际设计：

假设 Δt = 0.01秒（100Hz 采样率），v = 500像素/秒（极快滑动），则 d = 5像素。
若 s = 8像素，则 8 ≥ 5，可以覆盖间隙。

5. 为什么不用插值算法？

插值算法（比如在两点间补全线段）是更精确的方案，但：

计算资源消耗大：嵌入式设备（如 STM32）的算力有限，插值需要实时计算线段上的所有点。
膨胀法简单粗暴：直接填充方块只需极低计算量，适合资源受限的设备。

总结：时空互补的工程思维

时间不足（低采样率） → 空间来补（膨胀覆盖）
用空间换时间：通过扩大每个点的空间影响范围，弥补时间采样间隔的不足。
平衡设计：膨胀尺寸 (s=8) 是根据设备性能（采样率）和典型使用场景（手写速度）综合权衡的结果。

 if(CST816_Get_FingerNum()!=0x00 && CST816_Get_FingerNum()!=0xFF){if(!reg_state){CST816_Get_XY_AXIS();if(CST816_Instance.X_Pos > SCALL_RATE/2 && CST816_Instance.Y_Pos > SCALL_RATE/2){for(uint8_t i=0; i<SCALL_RATE; i++){for(uint8_t j = 0; j < SCALL_RATE; j++){originalImage[(CST816_Instance.X_Pos - SCALL_RATE/2 + j) + (CST816_Instance.Y_Pos - SCALL_RATE/2 + i)*240] = 0xFF;}}LCD_Fill(CST816_Instance.X_Pos - SCALL_RATE/2, CST816_Instance.Y_Pos - SCALL_RATE/2,CST816_Instance.X_Pos + SCALL_RATE/2, CST816_Instance.Y_Pos + SCALL_RATE/2, BLACK);}} }

三、模型训练

搭建的模型如下所示，使用的手写数字MNIST数据集在网上很多，可以在kaggle上直接找数据集。训练完生成.h5模型最后需要部署到STM32上。

 #------------------------------【搭模型】---------------------------------model = tf.keras.models.Sequential([tf.keras.layers.Conv2D(filters=3, kernel_size=(5, 5), padding='valid', activation=tf.nn.relu, input_shape=(30, 30, 1)),tf.keras.layers.MaxPool2D(pool_size=(2, 2), padding='same'),tf.keras.layers.Flatten(),tf.keras.layers.Dense(units=32, activation=tf.nn.relu),tf.keras.layers.Dense(units=16, activation=tf.nn.relu),tf.keras.layers.Dense(units=10, activation=tf.nn.softmax)])model.summary()

四、数据处理，模型部署

由于数据量的问题，需要吧240×240的数据压缩成30×30的数据，不然模型的参数量会非常的庞大，STM32上根本跑不了。下采样如下代码所示，这里是一个平均值池化，将240×240的图像数据压缩为30×30，原来的originalImage[]为uint8_t类型，压缩的compressedImage[]为float型。最后再将compressedImage[]输入到模型的API接口，得到输出找到最大值对应的index即为识别到的数字。

 void downsample(uint8_t * originalImage, float * compressedImage) {for (int i = 0; i < COMPRESSED_SIZE; i++) {// 计算原始图片区域的左上角坐标int start_x = (i % 30) * (8); // 每行240个像素压缩成30个像素int start_y = (i / 30) * (8); // 每列240个像素压缩成30个像素// 计算原始图片区域的右下角坐标int end_x = start_x + 8; // 30 / 240 = 0.125，8 = 240 * 0.125int end_y = start_y + 8;// 计算原始图片区域内像素的平均值int sum = 0;for (int x = start_x; x < end_x; x++) {for (int y = start_y; y < end_y; y++) {sum += originalImage[x + y * 240];}}compressedImage[i] = sum / 64; // 8*8=64//normcompressedImage[i] /= 255;}}

场景设定

想象你有一幅巨大的 240x240像素 的壁画（originalImage），现在需要把它缩小成 30x30像素 的马赛克小画（compressedImage）。每个马赛克小块是原画的 8x8像素区域，颜色取这个小块的平均色。这段代码就是完成这个缩小的魔法咒语。

分步拆解：制作马赛克壁画

1. 划分马赛克格子

// 第i个马赛克块对应原画的位置
int start_x = (i % 30) * 8; // 马赛克列号 × 8 → 原画起始列
int start_y = (i / 30) * 8; // 马赛克行号 × 8 → 原画起始行

比喻：把原画分成30行30列的格子（共900格），每格大小8x8像素。
- 比如第5行第3列的马赛克块，对应原画的位置是：
  - 起始列：3 * 8=24
  - 起始行：5 * 8=40
  - 范围：原画的第40-47行，24-31列（共8x8=64像素）。

2. 计算小格子的平均颜色

int sum = 0;
for (int x = start_x; x < start_x+8; x++) {for (int y = start_y; y < start_y+8; y++) {sum += originalImage[x + y*240]; // 累加这64个像素的值}
}
compressedImage[i] = sum / 64; // 计算平均值

比喻：
- 你带一群助手统计这个小块的颜色：
  - 黑色像素（0xFF）算255分，白色（0x00）算0分，灰色按深浅打分。
- 所有人报数后，计算平均分 → 这就是马赛克块的颜色。
- 例如：64个像素中有32个全黑（255），32个全白（0），平均分是 (32×255 + 32×0)/64 = 127.5。

3. 归一化：把分数转换成标准比例

compressedImage[i] /= 255; // 0-255 → 0-1

比喻：
- 原来分数是0-255分，现在统一除以255，变成0-1分。
- 比如127.5 → 127.5/255 = 0.5，表示中灰色。
- 为什么：AI模型习惯处理0-1的小数，就像人习惯用百分比（0%-100%）而不是具体数值。

动态示例：缩小数字“7”

原画：240x240的手写“7”，笔画粗细约8像素。
马赛克处理：
- 某马赛克块覆盖“7”的竖笔部分，其中50个像素是黑色（255），14个是灰色（127）。
- 平均分：(50×255 + 14×127)/64 ≈ 209.3 → 归一化后 209.3/255 ≈ 0.82。
结果：马赛克小画中这个块显示深灰色，代表这里原本是较黑的区域。

为什么是8x8？数学对应

原画240x240 → 压缩后30x30
- 每边缩小比例：240/30 = 8
- 因此每个马赛克块对应原画的8x8区域。

总结：三步完成“视觉压缩”

切块：把大画切成900个8x8的小豆腐块。
算平均：给每个豆腐块打平均分。
标准化：把分数压缩到0-1之间，方便AI处理。

就像把高清照片变成乐高积木拼图——保留轮廓，丢掉细节，但依然能认出图案！ 🧩

场景设定

想象你有一块电子白板（LCD屏幕），和一个魔法印章（触摸屏传感器CST816）。当你用手指按印章时，它会在白板上盖一个 8x8的黑色方块（而不是只画一个点）。这段代码就是控制盖章过程的魔法咒语。

代码拆解：分步解释

1. 魔法印章检测手指

if(CST816_Get_FingerNum()!=0x00 && CST816_Get_FingerNum()!=0xFF)

行为：检查魔法印章是否被按下。
比喻：
- 0x00：印章完全没被碰到（手指离开）。
- 0xFF：印章坏了或数据错误（比如被猫踩了）。
- 条件：只有当手指真实按压时（既不是未触碰，也不是错误状态），才执行盖章。

2. 防重复盖章（状态锁）

if(!reg_state)

行为：检查是否已经处理过这次按压（防止一次按压重复盖章多次）。
比喻：
- reg_state 像一把锁：
  - 锁打开（reg_state=0）→ 允许盖章。
  - 锁关闭（reg_state=1）→ 禁止重复操作。

3. 获取盖章位置

CST816_Get_XY_AXIS();

行为：读取手指按压的坐标（X_Pos和Y_Pos）。
比喻：魔法印章通过感应，告诉你手指按在白板的哪个位置（比如坐标(50,100)）。

4. 检查边界（防止盖章出界）

if(CST816_Instance.X_Pos > 4 && CST816_Instance.Y_Pos > 4)

假设SCALL_RATE=8，则SCALL_RATE/2=4。
行为：确保盖章位置距离白板边缘至少4像素，避免8x8方块越界。
比喻：不让印章盖到白板的边框上（比如坐标(3,5)太靠左，8x8方块会超出左边界）。

5. 在白板上画8x8方块（盖章！）

// 循环画8x8的方块
for(uint8_t i=0; i<8; i++) {for(uint8_t j=0; j<8; j++) {// 计算方块中每个点的位置int x = 手指X坐标 - 4 + j; // j从0到7，覆盖X方向8个点int y = 手指Y坐标 - 4 + i; // i从0到7，覆盖Y方向8个点// 在内存中标记这些点为黑色（0xFF）originalImage[x + y*240] = 0xFF;}
}
// 在LCD上显示这个方块
LCD_Fill(手指X-4, 手指Y-4, 手指X+4, 手指Y+4, BLACK);

关键点：
- originalImage数组：相当于白板的“数字底稿”，记录哪里被涂黑（240x240像素）。
- x + y*240：因为屏幕每行有240个像素，y*240跳到第y行，x是行内的横向位置。
- LCD_Fill：在屏幕上实际绘制黑色方块，让人眼能看到。

场景设定

想象你有一张巨大的方格纸（240行 x 240列），每个格子代表一个像素。当你用手指触碰某个位置时，你需要在纸上以这个位置为中心，用黑色蜡笔涂满 8x8的方格区域。这段代码就是实现这个填色规则的魔法咒语。

拆解代码：方格纸的坐标计算

originalImage[ (X中心 -4 + j) + (Y中心 -4 + i)*240 ] = 0xFF;

假设：

手指触碰中心坐标为 (X_Pos=50, Y_Pos=100)
SCALL_RATE=8（8x8区域），所以 SCALL_RATE/2=4

1. 确定涂色区域的左上角起点

X方向起点：50 - 4 = 46
Y方向起点：100 - 4 = 96

这相当于在方格纸上，从第96行、第46列开始涂色。

2. 遍历8x8的每个小格子

i 控制行（从0到7），j 控制列（从0到7）
对于每个小格子，计算它在方格纸上的坐标：
- X坐标：46 + j（j从0到7 → 46到53列）
- Y坐标：96 + i（i从0到7 → 96到103行）

3. 将二维坐标转换为一维索引

方格纸在内存中是一维数组originalImage，总共有 240x240=57,600 个格子。转换规则如下：

每行有240列：第Y行的起始索引是 Y*240
第X列的偏移量：直接加上X
最终索引：X + Y*240

举例：涂第96行、第46列的格子：

索引 = 46 + 96 * 240
计算过程：96行 x 每行240格 = 23,040 → 23,040 + 46 = 23,086
originalImage[23086] = 0xFF（涂黑这个格子）

动态演示：涂满8x8区域

i=0, j=0 → 涂(46,96) → 索引=46+96 * 240
i=0, j=1 → 涂(47,96) → 索引=47+96 * 240
...
i=7, j=7 → 涂(53,103) → 索引=53+103 * 240

最终效果：以(50,100)为中心，涂满从(46,96)到(53,103)的8x8区域。

比喻：快递仓库的货架编号

仓库：一个超长货架（一维数组originalImage），有57,600个位置。
货架规则：
- 每行有240个箱子（列），共240行（行）。
- 第Y行的箱子从编号Y*240开始，比如第0行是0-239号，第1行是240-479号，依此类推。
涂色任务：找到第96行第46列的箱子，它的编号是 46 + 96 * 240 = 23,086，然后贴上黑色标签（0xFF）。

为什么这样设计？

一维数组更节省内存：计算机内存本质是一维的，二维数组需要转换。
快速计算：乘法和加法比二维数组的嵌套循环更快，适合嵌入式设备。

总结

这行代码就像在说：
“从(X-4, Y-4)开始，把接下来8行8列的所有格子，在内存的一维货架中找到对应编号，全部贴上黑色标签！”

完整流程比喻

检测按压：你用手指按了一下魔法印章。
检查状态：确认这是新的一次按压（而不是上次的残留信号）。
读取坐标：印章告诉你按在了(50,100)位置。
检查边界：发现50-4=46 >0，100-4=96 >0，位置合法。
盖章动作：
- 在内存的originalImage数组中，把(46到53, 96到103)区域全部标记为黑色。
- 让白板立刻显示这个8x8的黑色方块。

为什么用8x8？

防断线：如果只画1x1的点，快速移动时点之间会有空隙。8x8方块像“粗笔头”，即使两次盖章位置相隔几个像素，方块边缘也会重叠，看起来像连续线条。
简化计算：8x8的膨胀和下采样（后面压缩成30x30）配合，刚好能被模型处理。

终极总结

这段代码就是：当你触摸屏幕时，系统以触点为中心，盖一个8x8的“墨水章”，同时记录墨水位置到内存，并显示在屏幕上。就像用粗头印章在白板上连续盖章画线！

参考:

FryPi/2.software/1.Basic at master · No-Chicken/FryPi

一、例程简述

1. 包含必要的头文件和HAL库的相关头文件

2. 初始化GPIO外设

3. 配置GPIO引脚的模式和参数

4. 设置GPIO引脚的电平

5. 读取GPIO引脚的电平

6. GPIO应用示例代码

二、工程创建

1.打开CubeMX，选择ACCESS TO MCU SELECTOR

2.选择对应炸鸡板MCU--STM32F411RET6

3.初始化时钟（配置时钟树）

4.初始化GPIO（用于控制炸鸡板用户灯）

5.生成初始化工程

三、GPIO扩展知识（该部分摘自 尝试使用CubeMX做stm32开发之四：GPIO配置）

PWM Demo

1. 示例一：PWM_base例程

2.示例二： PWM互补输出，带死区

PWM互补输出带死区的通俗解释

一、PWM互补输出：​​一开一闭的“双人舞”​​

二、死区时间：​​防止“打架”的安全间隔​​

三、死区的影响与设置要点

四、实际应用场景

1. H桥的基本工作逻辑​​

​​2. 为什么会发生上下桥短路？​​

​​原因①：开关的物理延迟​​

​​原因②：控制信号不同步​​

​​3. 如何避免短路？​​

​​方案①：死区时间（安全间隔）​​

​​方案②：互锁电路（硬件保护）​​

​​方案③：专用驱动芯片​​

​​4. 实际应用中的典型错误​​

​​总结：H桥设计的核心安全法则​​

​​1. 死区时间的作用​​

​​2. DTG[7:0]：调节死区时间的“档位旋钮”​​

1. DTG寄存器：死区时间的“多档调节器”​​

​​2. 四档位的具体规则​​

​​档位1（DTG[7:5]=0xx）​​

​​档位2（DTG[7:5]=10x）​​

​​档位3（DTG[7:5]=110）​​

​​档位4（DTG[7:5]=111）​​

​​3. 时间单位与时钟频率的关系​​

​​4. 实际配置技巧​​

​​总结​​

​​3. 时间范围和步长（类似“量程切换”）​​

​​4. LOCK位：死区时间的“防误触锁”​​

​​5. 配置步骤总结​​

​​一句话总结​​

3. 作业

Cube AI Demo

一、搭建一个神经网络

1. 模型搭建

2. 生成sin(x)数据，进行模型的训练

二、STM32工程创建

1.打开CubeMX，把常规的设置都设置好，打开串口等

2.打开select components，选上X-CUBE-AI

3.添加网络，选择你的模型（.h5或.tflite），再进行验证

4.生成工程

整个代码就像钟表齿轮生产线​​

​​核心环节详解​​

​​这个比喻的巧妙之处​​

​​实际运行效果​​

5.验证

一、神经网络部分（相当于训练"计算器"）

二、STM32运行部分（把"计算器"装进硬件）

三、实际效果

四、类比理解

手写数字识别 MNIST Demo

一、文件夹组成

二、触摸屏手写显示在LCD

​​1. 时间采样率低导致的问题​​

​​2. 空间膨胀如何弥补时间间隔​​

​​3. 为什么实际中能“看起来连续”​​

​​4. 数学视角：覆盖间隙的条件​​

​​5. 为什么不用插值算法？​​

​​总结：时空互补的工程思维​​

三、模型训练

四、数据处理，模型部署

场景设定​​

​​分步拆解：制作马赛克壁画​​

​​1. 划分马赛克格子​​

三、GPIO扩展知识（该部分摘自尝试使用CubeMX做stm32开发之四：GPIO配置）

一、PWM互补输出：一开一闭的“双人舞”

二、死区时间：防止“打架”的安全间隔

1. H桥的基本工作逻辑

2. 为什么会发生上下桥短路？

原因①：开关的物理延迟

原因②：控制信号不同步

3. 如何避免短路？

方案①：死区时间（安全间隔）

方案②：互锁电路（硬件保护）

方案③：专用驱动芯片

4. 实际应用中的典型错误

总结：H桥设计的核心安全法则

1. 死区时间的作用

2. DTG[7:0]：调节死区时间的“档位旋钮”

1. DTG寄存器：死区时间的“多档调节器”

2. 四档位的具体规则

档位1（DTG[7:5]=0xx）

档位2（DTG[7:5]=10x）

档位3（DTG[7:5]=110）

档位4（DTG[7:5]=111）

3. 时间单位与时钟频率的关系

4. 实际配置技巧

总结

3. 时间范围和步长（类似“量程切换”）

4. LOCK位：死区时间的“防误触锁”

5. 配置步骤总结

一句话总结

整个代码就像钟表齿轮生产线

核心环节详解

这个比喻的巧妙之处

实际运行效果

1. 时间采样率低导致的问题

2. 空间膨胀如何弥补时间间隔

3. 为什么实际中能“看起来连续”

4. 数学视角：覆盖间隙的条件

5. 为什么不用插值算法？

总结：时空互补的工程思维

场景设定

分步拆解：制作马赛克壁画

1. 划分马赛克格子

2. 计算小格子的平均颜色

3. 归一化：把分数转换成标准比例

动态示例：缩小数字“7”

为什么是8x8？数学对应

总结：三步完成“视觉压缩”

场景设定

代码拆解：分步解释

1. 魔法印章检测手指

2. 防重复盖章（状态锁）

3. 获取盖章位置

4. 检查边界（防止盖章出界）

5. 在白板上画8x8方块（盖章！）

场景设定

拆解代码：方格纸的坐标计算

1. 确定涂色区域的左上角起点

2. 遍历8x8的每个小格子

3. 将二维坐标转换为一维索引

动态演示：涂满8x8区域

比喻：快递仓库的货架编号

为什么这样设计？

总结

完整流程比喻

为什么用8x8？

终极总结