氵工的博客

校区2 录取名单多维度分析报告

Sun, 21 Jun 2026 16:40:00 GMT

校区 2 录取名单多维度分析报告

2 个专业 · 37 名报考考生 · 32 名录取 · 初试四科拆解 + 复试综合分析

数据校验

光电信息工程： 报考 19 人，录取 17 人，初试名单中有复试成绩的 17 人与录取名单 17 人完全匹配。

仪器仪表工程： 报考 18 人，录取 15 人。初试名单中有复试成绩的 15 人中，有一位考生的复试总分存在微小差异（a.xlsx 记录为 364.72，ss.xlsx 记录为 394.72），可能是数据录入笔误，建议核实。其余 14 人完全匹配。

未录取考生共 5 人（仪器仪表 3 人、光电信息 2 人），均为初试名单中有记录但无复试总分。

一、核心指标汇总

专业	报考	录取	录取率	政治均分	英语均分	数学均分	专业课均分	初试均分	初试标准差	初试最高	初试最低
仪器仪表工程	18	15	83.3%	56.9	78.2	120.0	117.8	372.9	25.7	424	344
光电信息工程	19	17	89.5%	54.8	74.2	110.9	120.4	360.3	27.8	404	320

二、各科目成绩分布箱线图

箱线图展示中位数、四分位距和极端值。箱体越窄说明成绩越集中。

要点：

仪器仪表工程的数学中位数明显高于光电信息工程（约 125 vs 110），但离散度也更大
光电信息工程的专业课整体偏高，中位数约 125 分
两个专业的政治和英语分布较为接近

三、各科目均分对比

要点：

仪器仪表工程的数学均分（120.0）比光电信息工程（110.9）高出近 10 分
光电信息工程的专业课均分（120.4）略高于仪器仪表工程（117.8）
政治和英语两科差异不大，政治仪器仪表略高、英语仪器仪表也略高
总体来看，仪器仪表工程初试均分更高（372.9 vs 360.3），主要由数学拉开差距

四、各专业综合实力雷达图

将各维度归一化后对比，面积越大代表综合实力越强。

要点：

仪器仪表工程在数学和英语维度上明显领先
光电信息工程在专业课维度上稍有优势
两者政治水平接近

五、各科成绩分布直方图

要点：

政治成绩两个专业都集中在 50-65 分区间
英语集中在 70-85 分
数学分布范围最广（74-145），是拉开差距的关键科目
专业课集中在 105-135 区间
数学的标准差最大，是区分考生水平的核心科目

六、各科成绩堆叠柱状图

每位考生的四科成绩堆叠展示，按初试总分降序排列，× 标记未录取考生。

要点：

可以直观看出数学和专业课是初试总分的最大贡献项
未录取考生（×标记）往往出现在初试总分较低的区间，但也有个别初试成绩不低却未录取的情况（可能复试表现不佳）

七、初试各科占比分析

要点：

两个专业的科目占比结构非常相似——数学和专业课各占约 31-32%，是初试的两大支柱
英语占约 20-21%
政治占比最小，仅约 15%
这意味着数学和专业课是决定初试排名最重要的科目

八、各科目相关系数热力图

颜色越绿表示正相关越强，越红表示负相关越强。

要点：

数学与初试总分的相关性最高（约 0.78），再次印证数学是拉分关键
专业课与总分的相关性也较强（约 0.69）
政治和英语与总分的相关性较弱
值得注意的是，数学与专业课呈中等正相关（约 0.3），说明数学好的考生专业课往往也不差

九、初试总分 vs 复试总分散点图

每个点代表一名录取考生，× 代表未录取考生（仅有初试成绩）。

要点：

整体呈正相关趋势——初试分高的考生复试总分也倾向于更高
但散布程度较大，说明复试确实能显著改变排名
光电信息工程中出现了一些初试分不高但复试总分较高的案例（逆袭者）

十、初试分数段人数分布

浅色柱表示所有报考考生，深色柱表示最终录取考生。

要点：

仪器仪表工程在 390-410 高分段录取率 100%
370-390 分段是竞争最激烈的区间
光电信息工程的分布更加均匀，从 320 到 404 都有录取，低分段（320-330）也有考生成功录取（可能复试逆袭）

十一、初试/复试对总成绩的贡献占比

基于公式 总成绩 ≈ 初试×0.5 + 复试×2.5 推算。

要点：

两个专业的初试和复试贡献占比非常接近（初试约 48-50%，复试约 50-52%），复试权重略高
说明在这个校区，复试表现对最终录取的影响与初试几乎同等重要，甚至略占上风

十二、复试”逆袭”分析

绿色=复试后排名提升，红色=复试后排名下降。

要点：

仪器仪表工程中有考生排名变化幅度达 5 位以上，复试逆袭空间较大
光电信息工程的排名变化相对温和，多数在±3 名以内，初试高分的”护城河”更稳固

十三、推算复试成绩分布

假设 总成绩 = 初试×0.5 + 复试×2.5，反推复试面试得分。

要点：

推算的复试成绩集中在 78-90 分区间
仪器仪表工程复试均值约 84 分，光电信息工程复试均值约 84 分，两者非常接近
复试分数分布相对集中，区分度不如初试大

十四、录取 vs 未录取考生各科对比

要点：

由于未录取样本量较小（各 2-3 人），统计意义有限
但可以观察到：未录取考生并非所有科目都弱，往往是个别科目（尤其是数学或专业课）拖了后腿

综合分析结论

1. 数学是拉分之王

数学与初试总分相关性最高（~0.78），标准差最大，是决定初试排名的核心科目。仪器仪表工程数学均分（120.0）显著高于光电信息（110.9），直接拉开了初试差距。

2. 专业课紧随其后

专业课与总分相关性约 0.69，是第二大拉分科目。光电信息工程的专业课均分（120.4）略高于仪器仪表（117.8）。

3. 政治英语是”稳定器”

政治和英语的分数区间窄、标准差小，很难靠这两科拉开差距，但如果严重偏低会成为短板。

4. 复试权重与初试相当甚至略高

复试对总成绩的贡献约 50-52%，说明复试表现至关重要。仪器仪表工程的复试逆袭空间更大，排名变动幅度可达 5 位以上。

5. 录取率较高

仪器仪表工程录取率 83.3%（15/18），光电信息工程录取率 89.5%（17/19），整体录取率较高，竞争烈度中等。

6. 备考建议

如果目标是仪器仪表工程，应重点攻克数学（拉开差距）同时保证专业课不拖后腿
如果目标是光电信息工程，数学同样是关键，但专业课也很重要，需要均衡发展
复试准备不可忽视，尤其是仪器仪表工程方向

7. 与另一校区对比

该校区仅有 2 个专业（vs 另一校区 4 个专业），招生规模更小（32 人 vs 94 人），但数据结构相似——复试占比均在 50%以上，体现了统一的录取评价体系。

本报告由 Python + matplotlib 自动生成

录取名单多维度分析报告

Sun, 21 Jun 2026 07:30:00 GMT

录取名单多维度分析报告

4 个专业 · 94 名录取考生 · 初试/复试/总成绩全面拆解

数据概览

本报告基于录取名单中 4 个专业的 94 名考生数据（已排除 1 名强军计划考生）进行分析。

经回归验证，总成绩计算公式为：总成绩 = 初试 × 0.5 + 复试 × 2.5，即初试和复试各占总成绩的 50%。

“仪器科学技术”（1 人）已合并入”仪器科学与技术”（16 人），共 17 人。

专业	录取人数	初试均分	复试均分	总均分	初试占比	复试占比
光学工程	30	376.7	81.7	392.6	48.0%	52.0%
光电信息工程	31	400.5	81.0	402.8	49.7%	50.3%
仪器科学与技术	17	353.6	78.2	372.4	47.5%	52.5%
仪器仪表工程	15	382.9	81.1	394.3	48.6%	51.4%

一、各专业成绩分布箱线图

箱线图展示了三个维度的分数分布。箱体越窄说明成绩越集中，须线越长说明极端值越多。

要点：

光电信息工程初试分数跨度最大（372~439），复试分布也最分散
光学工程和仪器仪表工程的初试和复试分布都相对集中
仪器科学与技术的初试标准差最大（24.4 分），说明该专业录取考生的初试水平差异最为悬殊

二、成绩密度分布曲线（KDE）

核密度估计图能更直观地看出各专业分数的”集中地带”和”多峰”现象。

要点：

光电信息工程的初试成绩明显偏向高分段（集中在 390~410），形成了”高分密集”的特征
仪器科学与技术的初试密度曲线偏向低分段（340~360 区间），峰值明显左移
复试方面各专业分布较为接近，但仪器科学与技术的复试密度峰值也略低于其他专业

三、初试 vs 复试散点图

每个点代表一名考生，虚线为等总成绩线。位于图上方的考生复试表现相对更强，位于右侧的考生初试更强。

要点：

光电信息工程的考生散布在更高初试分数段（右侧），其中一位初试 439 分的考生极为突出
仪器科学与技术则集中在左下方（初试相对较低）
各专业的星号（均值点）显示初试和复试成绩之间并没有强烈的线性关系，说明复试成绩并非初试的简单”复制”

四、初试/复试对总成绩的贡献占比

由于公式是 初试×0.5 + 复试×2.5，初试满分 250、复试满分 250，权重相等。但实际录取考生的初试/复试比例因人而异。

要点：

所有专业的初试占比在 47.5%~49.7% 之间，复试占比 50.3%~52.5%，差异非常小
仪器科学与技术的复试占比最高（52.5%），说明该专业录取考生的复试表现在总成绩中贡献更大——如果复试发挥好，在总排名中更有优势
光电信息工程初试占比最高（49.7%），初试高分考生更占优势

五、各专业初试/复试成绩直方图

将复试成绩×5 对齐到初试的 500 分制进行对比。虚线为各专业均值。

要点：

光学工程的初试分布呈近似正态，集中在 365~385 区间
光电信息工程则明显右偏，高分考生占比大
仪器科学与技术的初试分布最”扁平”，低分段和高分段都有人
仪器仪表工程虽然人数最少，但初试集中在 370~400 区间，较为均匀

六、初试分数段人数对比

将初试成绩分段，对比各专业在不同分数段的人数分布。

要点：

390~410 分段是”黄金区间”，光电信息工程在此段人数最多
410+高分段几乎只有光电信息工程
仪器科学与技术主要集中在 330~370 的中低分段
光学工程则均匀分布在 350~410 区间

七、各专业综合实力雷达图

综合初试均分、复试均分、总均分、成绩集中度、录取规模等维度进行归一化对比。

要点：

光电信息工程在初试均分、总均分上明显领先，面积最大
光学工程在复试均分上表现最好
仪器科学与技术各维度均处于较低水平，但录取人数（17 人）在四个专业中排第三
仪器仪表工程的各项指标处于中间水平

八、复试”逆袭”分析

横向条形图展示每位考生因复试表现导致的排名变化。绿色=复试后排名提升，红色=排名下降。

要点：

仪器科学与技术的排名变化幅度最大，有考生的排名提升或下降了 7-8 位，说明复试对该专业的最终录取排名影响最大
光电信息工程的排名变化相对小，初试高分考生的”护城河”更深

九、初试排名 vs 最终排名变化

对角线表示初试排名=最终排名（复试没有改变排名）。绿色区域=复试后排名提升，红色=下降。

要点：

如果蓝点大幅偏离对角线，说明复试显著改变了排名
仪器科学与技术中排名变化最剧烈，部分初试排名靠后的考生通过复试”翻盘”进入了前列

十、复试翻盘率

定义”翻盘”为最终排名比初试排名提升 ≥ 3 名。翻盘率越高，说明复试对最终结果的影响越大。

要点：

仪器科学与技术的翻盘率最高，复试改变命运的概率最大
光电信息工程翻盘率最低，初试高分考生优势稳固，复试难以大幅改变排名

十一、成绩离散度与竞争强度

变异系数(CV)衡量分数的相对分散程度；极差(最高-最低)反映录取考生的分差。

要点：

仪器科学与技术的初试变异系数和极差都最大（初试极差达 88 分），说明该专业录取门槛相对灵活，高低分差距大
光电信息工程的复试极差较小（14.7 分），复试打分相对集中、区分度有限

十二、核心指标汇总表

综合分析结论

1. 初试与复试权重

从公式上看，初试和复试各占 50%，但实际效果因专业而异：

光电信息工程的初试均分最高（400.5），初试优势更难被复试翻盘
仪器科学与技术初试均分最低（353.6），复试对排名的影响最大

2. 光电信息工程：“初试为王”

该专业录取考生的初试分数段极高（均分 400.5），初试占比也最大（49.7%），且翻盘率最低。如果你初试能拿到 400+，在该专业的优势非常稳固。

3. 仪器科学与技术：“复试决胜”

该专业初试均分最低但复试翻盘率最高，成绩分布最分散，说明复试发挥对最终录取至关重要。初试不理想但复试出色的考生有机会逆袭。

4. 光学工程：“均衡稳定”

初试和复试分布都较为集中和均匀，没有明显的偏科特征，竞争相对公平和可预测。

5. 仪器仪表工程：“中间路线”

各项指标处于中等水平，初试集中度高（标准差 14.6），复试表现中等，整体波动较小。

6. 整体趋势

四个专业的复试占比均在 50%~52.5%之间，说明复试成绩在实际录取中的权重略高于初试（因为复试满分 100×2.5=250，而大多数考生初试在 350-410 之间，×0.5 后只有 175-205 分，复试的边际影响力更大）。

本报告由 Python + matplotlib 自动生成

STM32N657X0H3Q Nucleo VSCode 调试配置记录

Mon, 08 Jun 2026 03:39:51 GMT

STM32N657X0H3Q Nucleo VSCode 调试配置记录

问题回顾

在前一篇文章中，我已经完成了程序的编译、签名以及使用 STM32 Programmer 下载的完整流程。LRUN 模式下可以分别单独下载 FSBL 和 Application，且均能正常运行。但有一个关键问题未能解决——无法在 VSCode 中进行源码级调试。

调试时，程序自动断点停在一个库函数内部，位置在 RETR=Map Memory 附近。按照 ST 社区论坛的教程，此处应该能够正常停在断点处并进入单步调试模式。但实际情况并非如此：断点命中后不久，调试器便与板子断开连接，调试会话自动退出。

起初怀疑是安全域（TrustZone）配置导致的问题——是否因为 RIF 资源隔离配置不当，导致调试器无法在安全状态下进行调试？但后来逐步排查后排除了这个可能性。

根因分析

仔细检查 launch.json 后发现，stldr 文件配置错误是导致无法调试的根本原因。

当前使用的是 New Clone 板（NUCLEO-N657X0-Q），但配置文件中误写为 DK 开发板（STM32N6570-DK）的对应设置。stldr（External Loader）文件是调试器与外部 Flash 通信的桥梁，加载器不匹配时调试器无法正确访问外部存储，导致连接失败。

launch.json 配置详解

修正 stldr 配置后，又对整体配置进行了调整。以下是最终的完整配置及各字段说明：

{
    "version": "0.2.0",
    "configurations": [
        {
            "type": "stlinkgdbtarget",          // 调试器类型：ST-Link GDB 目标
            "request": "launch",
            "name": "NUCLEO-N657X0-Q Debug (FSBL + Appli)",
            "origin": "snippet",
            "cwd": "${workspaceFolder}",
            "preBuild": "${command:st-stm32-ide-debug-launch.build}",   // 编译命令
            "runEntry": "BOOT_Application",                             // 入口函数名
            // SVD 文件路径（请将路径前缀替换为 STM32CubeProgrammer 实际安装目录）
            "svdPath": "...\\STM32CubeProgrammer\\SVD\\STM32N657.svd",
            "imagesAndSymbols": [
                {
                    // Application 镜像：symbol 用于源码映射，image 用于烧录
                    "symbolFileName": "${workspaceFolder}/Appli/build/Template_FSBL_LRUN_Appli.elf",
                    "imageFileName": "${workspaceFolder}/Appli/build/Appli-trusted.elf"
                },
                {
                    // FSBL 镜像：两者都指向同一 ELF（FSBL 无需 separate trusted 文件）
                    "symbolFileName": "${workspaceFolder}/FSBL/build/Template_FSBL_LRUN_FSBL.elf",
                    "imageFileName": "${workspaceFolder}/FSBL/build/Template_FSBL_LRUN_FSBL.elf"
                }
            ],
            "serverExtLoader": [
                {
                    // External Loader：NUCLEO-N657X0-Q 对应的 stldr 文件（New Clone 板，非 DK 板）
                    "loader": "...\\STM32CubeProgrammer\\bin\\ExternalLoader\\MX25UM51245G_STM32N6570-NUCLEO.stldr",
                    "initialize": false
                }
            ]
        }
    ]
}

路径说明：上文中 ...\\STM32CubeProgrammer\\ 表示 STM32CubeProgrammer 的安装目录，请替换为你电脑上的实际路径，例如 C:\\Program Files\\STMicroelectronics\\STM32Cube\\STM32CubeProgrammer\\ 或自行指定的目录。

关键配置项说明

配置项	作用	注意事项
`runEntry`	指定调试器入口函数	NUCLEO-N657X0-Q 的 LRUN 模式需设为 `BOOT_Application`
`svdPath`	SVD 文件路径，提供外设寄存器描述	路径指向 STM32CubeProgrammer 安装目录下的 SVD 文件夹
`symbolFileName`	ELF 符号文件，用于源码级调试	需与编译产物路径一致
`imageFileName`	烧录镜像文件	Appli 用 `Appli-trusted.elf`（已签名），FSBL 直接用编译生成的 `.elf`
`serverExtLoader`	外部 Flash 加载器配置	务必选择与板子匹配的 stldr 文件

配置要点与经验

FSBL 与 Appli 的 ELF 配置差异

FSBL 和 Application 的镜像配置有一个值得注意的区别：

FSBL：symbolFileName 和 imageFileName 都指向同一个 .elf 文件，因为 FSBL 直接使用编译生成的 ELF 进行签名和调试
Application：symbolFileName 指向编译生成的 ELF（含调试符号），而 imageFileName 指向 Appli-trusted.elf（签名后的镜像）

这是因为 Application 需要经过签名（添加 V2.3 Header）才能被 Boot ROM 或 FSBL 识别，而调试时需要的是符号未剥离的原始 ELF 文件来映射源码位置。

签名相关注意事项

之前的配置中，签名生成的文件名也有一些混乱。关键在于区分：

.elf — 编译器直接生成的 ELF 文件，含调试符号
-trusted.elf — 经签名工具处理后添加了 Header 的镜像文件
-trusted.bin — 经签名工具处理后添加了 Header 的纯二进制文件

Application 使用 Appli-trusted.elf 作为镜像文件，而 FSBL 不需要单独生成 trusted 版本。

调试流程总结

修正配置后，完整的 VSCode 调试流程如下：

确保 BOOT1 = 2-3（DEV 模式）
在 VSCode 中选择 NUCLEO-N657X0-Q Debug (FSBL + Appli) 配置
在 Application 代码中设置断点
按 F5 启动调试
FSBL 自动运行 → 加载 Appli 到 SRAM → 跳转执行 → 断点命中

踩坑总结

现象	可能原因	解决方法
调试连接后立即断开	stldr 文件不匹配（DK 板 vs New Clone 板）	检查并修正 `serverExtLoader` 中的 stldr 路径
断点停在库函数中后退出	安全域配置导致调试器被阻断	检查 RIF 配置中调试相关权限
`Appli-trusted.elf` 找不到	编译后未正确生成签名镜像	检查 CMake POST_BUILD 签名脚本
调试时无法单步	符号文件路径不正确	确认 `symbolFileName` 指向正确的 `.elf` 文件

STM32N657X0H3Q Nucleo 开发板开发记录

Sat, 06 Jun 2026 16:00:00 GMT

STM32N657X0H3Q Nucleo 开发板开发记录

这破板子真服了——又是什么 TrustZone、又是 FSBL、又是 OTP，怎么这么难……

一、调试记录

第一次调试：SRAM 模式

第一次当然顺其自然，想着按照以往 F1 跟 F4 的经验，直接在 CubeMX 里面配置项目，然后加载到 VS Code 进行调试。不过神奇的是，其实是可以调试的。

但是它运行不了，Reset 之后代码直接消失不见了。从现在来看应该是在调试的时候用的是 SRAM 模式，直接加载到 SRAM 之后进行的运行。好处是能直接看到结果，可以调试，但问题就是它其实完全没有记住代码。记住代码这个过程其实是需要让它记到 Flash 里面去配置这个 XSPI 的。

踩坑：NUCLEO-N657X0-Q 没有内部 Flash，代码必须存放在外部 XSPI Flash 中。调试模式下加载到 SRAM 后，Reset 一旦断电代码就没了，这就是为什么 Reset 后代码”消失”了。

XSPI + XIP 模式尝试

XIP 模式意思就是 Execute In Place，直接在外部 Nor Flash 里面进行运行程序，也就是说 SRAM 其实是没有进行任何工作的。XSPI 的意思是这个板子、这个芯片它的一个特殊的 SPI 协议，它用于和外部这个 Nor Flash 进行通信，配置过程还挺复杂的。

然后进行了 XSPI 的尝试，但是完全不能做，不知道是哪里出问题了，有源源不断的问题，下载代码和调试全都是报错。而且官方论坛这个帖子是根据 DK 版进行配置的，我不太清楚 DK 版跟 New Clone 板子是否有什么区别，所以还是放弃了。

踩坑：XIP 模式配置极其复杂，需要：

配置 Memory-Mapped Mode，让 CPU 能直接总线访问外部 Flash

外部 Flash 的 .stldr 加载器文件（STM32CubeProgrammer 需要加载正确的 External Loader）

正确的 linker 脚本（STM32N657XX_ROMxspi*.ld）

签名时需要加上 -align 参数

DK 版（开发套件）和 NUCLEO 板的配置可能有差异，官方教程按照 DK 版来，很多配置在 NUCLEO 板上不适用。

LRUN 模式：成功

LRUN 模式就是 Load and Run，它是通过 FSBL 以及 Application 进行配合。FSBL 进行初始化，并把 Application 的代码转移到 SRAM。我的理解是，把 PC 指针最后在进入死循环之前就转移到了 Application。所以需要注意的是，死循环是不会执行的。我把亮灯放到了死循环之前，进入 Application 之前。

然后倒是挺顺利的，直接编译烧录。编译完之后给它加签名，加签名之后直接各自烧录就可以了。理论上来说应该是先去烧录 FSBL，再去烧录 Application 的。不过实际上它板载的程序应该是 LRUN 模式，所以不管烧哪个进行替换其实都完全可以的。因为这只不过是 FSBL 的指针问题，Application 是各自的程序，其实没有什么区别。

还有需要注意的是，在烧录的时候需要选择外部存储设置，也就是那个 STLDR 文件，选择它这个板子对应的设置，然后才能进行烧录。我在烧录的时候它最后弹出来了内核被锁定，之前以及会弹出一个写入保护 PROTECTION，不太清楚是为什么。

踩坑：烧录时弹出”内核被锁定”（Core locked）或者”写入保护 PROTECTION”，通常是 Option Bytes 配置问题。可以尝试：

按住 Reset 再烧录

使用 Mass Erase 擦除整片芯片

检查 BOOT 跳线是否正确设置（DEV 模式下 BOOT1 = 2-3）

另外，烧录前需要在 CubeProgrammer 中加载正确的 External Loader（.stldr 文件），否则无法识别外部 Flash。

二、硬件平台与关键概念

2.1 芯片与开发板

芯片：STM32N657X0H3QU
开发板：NUCLEO-N657X0-Q (MB1940)
架构：ARM Cortex-M55 with Helium (MVE) + TrustZone
主频：600 MHz
Flash：无内部 Flash，依赖外部 XSPI Nor Flash
RAM：2MB AXISRAM (0x3400_0000 ~ 0x3420_0000)

STM32N6 与以往 F1/F4 系列最大的区别在于：

无内部 Flash：代码必须存放在外部 XSPI Flash 中
TrustZone：安全世界与非安全世界隔离，需要正确配置 RIF
双域架构：Secure 域和 Non-Secure 域分离
OTP Fuses：一次性可编程熔丝，用于配置高速模式
FSBL 机制：First Stage Boot Loader

2.2 LED 引脚

LED 颜色	引脚	备注
绿色 LED	PG.00 (LED_GREEN)	Appli 主循环控制
蓝色 LED	PG.08 (LED_BLUE)	Appli 主循环控制
红色 LED	PG.10 (LED_RED)	FSBL 调试指示

勘误：之前笔记把 PG.08 写成黄色，实际是蓝色（LED_BLUE）。NUCLEO-N657X0-Q 板上丝印标注的颜色和 BSP 定义一致。 |

2.3 启动模式（Boot Pin）

板上 Boot 引脚有 3 个位置（排针 1、2、3），通过跳线帽选择：

Boot 引脚配置

引脚	排针 1-2 短路	排针 2-3 短路
BOOT0	0（低电平）	1（高电平）
BOOT1	0（低电平）	1（高电平）

启动模式

模式	BOOT0	BOOT1	说明
DEV（调试）	任意（0 或 1 都可以）	1（排针 2-3 短路）	IDE 加载程序到 RAM，可源码调试
Boot from Flash	0（排针 1-2 短路）	0（排针 1-2 短路）	从外部 XSPI Flash 启动，独立运行
Reserved	1	0	保留
System ROM	0	0	芯片内置 ROM（一般不用）

注意：DEV 模式下 BOOT0 任意，只要求 BOOT1 = 1（跳线帽接 2-3）。

2.4 Boot ROM 启动顺序

STM32N6 芯片上电后，Boot ROM 按以下顺序查找可启动代码：

顺序	地址	说明
1	`0x7000 0000`	首选：外部 XSPI Flash（FSBL 或带 header 的程序）
2	内部 ROM	芯片出厂自带的 BootLoader（如有）
3	RAM	如果其他地方都没有，尝试从 RAM 启动

注意：地址 0x7000 0000 是外部 Flash 的镜像起始地址，实际物理 Flash 通过 XSPI 接口访问。带签名的程序放在这里，Boot ROM 才能识别并加载。

2.5 名词解释

缩写	全称	含义
LRUN	Load & Run	代码从外部 Flash 复制到内部 RAM 后执行
XIP	eXecute In Place	代码直接在外部 Flash 原地执行，不复制到 RAM
XSPI	eXtended SPI	ST 的串行外设接口协议，用于与外部 Flash 通信
FSBL	First Stage Boot Loader	第一阶段引导加载程序
OTP	One-Time Programmable	一次性可编程熔丝

2.6 链接文件命名规则

格式：ROM在哪里_RUN_RAM在哪里

链接文件	含义
`STM32N657XX_LRUN`	Appli 放在内部 RAM（由 FSBL 加载）
`STM32N657XX_ROMxspi1`	Appli 在外部 XSPI1 Flash，原地执行
`STM32N657XX_ROMxspi2`	Appli 在外部 XSPI2 Flash，原地执行
`STM32N657XX_LRUN_RAMxspi2`	Appli 放 RAM，但从 XSPI2 的 Flash 加载
`STM32N657XX_ROMxspi1_RAMxspi3`	Appli 在 XSPI1，RAM 用 XSPI3

三、FSBL Load & Run 模式

3.1 架构概述

FSBL LRUN 模式将系统分为两个独立的子项目：

子项目	职责	运行位置
FSBL	初始化 OTP、配置 XSPI2、读取并复制 Appli、跳转执行	内部 RAM (0x3400_0000)
Appli	用户应用程序，控制 LED 等外设	内部 RAM (0x3400_0400)

3.2 FSBL 代码分析

FSBL 的核心代码在 FSBL/Src/main.c：

int main(void)
{
    SCB_EnableICache();
    SCB_EnableDCache();
    HAL_Init();
    SystemClock_Config();  // 配置 600MHz 系统时钟

    // OTP 配置（第一次必须）
#ifndef NO_OTP_FUSE
    if(OTP_Config() != 0){
        Error_Handler();
    }
#endif

    MX_GPIO_Init(); // 初始化 LED (PG.10)
    MX_XSPI2_Init(); // 初始化 XSPI2 接口
    MX_EXTMEM_Init();
    BOOT_Application();   // 复制 Appli 到 RAM 并跳转

    while (1) { __NOP(); }  // 永远不会执行到这里
}

FSBL 执行流程：

使能缓存：ICache + DCache
配置时钟：600MHz 主频
OTP 配置：设置 VDDIO3_HSLV 等熔丝（仅第一次需要）
初始化 GPIO：配置 LED 引脚 PG.10（调试用）
初始化 XSPI2：与外部 Flash 通信
初始化外部存储：MX_EXTMEM_Init()
跳转执行：BOOT_Application() 复制 Appli 到 RAM 并跳转

3.3 OTP 配置详解

OTP_Config() 函数配置 VDDIO3_HSLV 熔丝位：

#define BSEC_HW_CONFIG_ID    124U
#define BSEC_HWS_HSLV_VDDIO3 (1U<<15)  // VDDIO3 高速模式使能

⚠️ 注意：OTP 熔丝一次写入，不可逆，配置前请确认。第一次烧录时需要禁用 NO_OTP_FUSE 宏。

3.4 Appli 代码分析

Appli 的代码在 Appli/Src/main.c：

int main(void)
{
    SystemCoreClockUpdate();
    MPU_Config();
    SCB_EnableICache();
    SCB_EnableDCache();
    HAL_Init();
    BSP_LED_Init(LED_GREEN);
    SystemIsolation_Config();  // 配置 RIF 资源隔离
    MX_GPIO_Init();

    while (1)
    {
        HAL_GPIO_TogglePin(GPIOG, GPIO_PIN_0);  // 绿色 LED
        HAL_GPIO_TogglePin(GPIOG, GPIO_PIN_8);  // 蓝色 LED
        HAL_Delay(750);
    }
}

Appli 中的 SystemIsolation_Config() 配置 TrustZone 资源隔离：

static void SystemIsolation_Config(void)
{
    __HAL_RCC_RIFSC_CLK_ENABLE();
    HAL_GPIO_ConfigPinAttributes(GPIOG, GPIO_PIN_0, GPIO_PIN_SEC|GPIO_PIN_NPRIV);
    HAL_GPIO_ConfigPinAttributes(GPIOG, GPIO_PIN_8, GPIO_PIN_SEC|GPIO_PIN_NPRIV);
    HAL_GPIO_ConfigPinAttributes(GPIOG, GPIO_PIN_10, GPIO_PIN_SEC|GPIO_PIN_NPRIV);
}

3.5 跳过 FSBL 直接运行 Appli

如果满足以下条件之一，可以跳过 FSBL 直接烧录 Appli：

OTP 已经配置好（VDDIO3_HSLV 已设置）
芯片出厂自带 FSBL 在 0x7000 0000
Boot ROM 支持直接从 0x7010 0000 加载

操作步骤：

签名 Appli：Appli-trusted.bin
烧录到 0x7010 0000
Reset，芯片会从外部 Flash 启动

踩坑：如果芯片没有自带 FSBL 且 Boot ROM 不支持直接加载，跳过 FSBL 会导致芯片找不到可执行代码而停住。

四、编译配置

4.1 工具链

工具	路径
GCC ARM Compiler	`C:\Users\Q\AppData\Local\stm32cube\bundles\gnu-tools-for-stm32\14.3.1+st.2`
STM32Cube Firmware	`C:\Users\Q\STM32Cube\Repository\STM32Cube_FW_N6_V1.3.0\`
Signing Tool	`C:\APPS\Programmer\bin\STM32_SigningTool_CLI.exe`

4.2 编译命令

cd build/Debug
cube-cmake --build . --target clean
cube-cmake --build . --target all

4.3 CMake POST_BUILD 配置（自动签名）

find_program(OBJCOPY arm-none-eabi-objcopy PATHS
    C:/Users/Q/AppData/Local/stm32cube/bundles/gnu-tools-for-stm32/14.3.1+st.2/bin
    NO_DEFAULT_PATH
)

add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD
    COMMAND ${OBJCOPY} -O binary $<TARGET_FILE:${CMAKE_PROJECT_NAME}> 
            ${CMAKE_BINARY_DIR}/${CMAKE_PROJECT_NAME}.bin
    COMMENT "Generating binary"
)

add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD
    COMMAND ${OBJCOPY} -O ihex $<TARGET_FILE:${CMAKE_PROJECT_NAME}> 
            ${CMAKE_BINARY_DIR}/${CMAKE_PROJECT_NAME}.hex
    COMMENT "Generating HEX"
)

# 自动签名（编译后自动执行，无需手动签名）
find_program(SIGNING_TOOL C:/APPS/Programmer/bin/STM32_SigningTool_CLI.exe)
add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD
    COMMAND ${SIGNING_TOOL} -bin ${CMAKE_BINARY_DIR}/${CMAKE_PROJECT_NAME}.bin 
            -nk -of 0x80000000 -t fsbl
            -o ${CMAKE_BINARY_DIR}/${CMAKE_PROJECT_NAME}-trusted.bin 
            -hv 2.3 -align -s
    COMMENT "Signing ${CMAKE_PROJECT_NAME}.bin"
)

4.4 NO_OTP_FUSE 宏配置

FSBL 的编译宏在 FSBL/mx-generated.cmake 中定义：

set(MX_Defines_Syms 
    USE_HAL_DRIVER 
    STM32N657xx 
    NO_OTP_FUSE # 注释掉此行以启用 OTP 配置
)

配置	说明
禁用 `NO_OTP_FUSE`	第一次烧录时必须，FSBL 会自动配置 OTP 熔丝
启用 `NO_OTP_FUSE`	后续开发使用，跳过 OTP 配置步骤

4.5 编译产物

文件	位置
FSBL.elf / .bin / .hex	`FSBL/build/Template_FSBL_LRUN_FSBL.*`
Appli.elf / .bin / .hex	`Appli/build/Template_FSBL_LRUN_Appli.*`
FSBL-trusted.bin	`FSBL/build/Template_FSBL_LRUN_FSBL-trusted.bin`
Appli-trusted.bin	`Appli/build/Template_FSBL_LRUN_Appli-trusted.bin`

五、签名与烧录

5.1 为什么要签名

STM32N6 的外部 Flash 存储了关键固件，芯片的 Boot ROM 只会加载带有正确签名 Header 的镜像。签名工具为 .bin 文件添加一个 V2.3 格式的头部。

5.2 签名命令（手动）

# Appli 签名
& "C:\APPS\Programmer\bin\STM32_SigningTool_CLI.exe" `
    -bin "C:\APPS\COPRO\MCU\CUBEMX\N6_MX\Template_FSBL_LRUN\Appli\build\Template_FSBL_LRUN_Appli.bin" `
    -nk -of 0x80000000 -t fsbl `
    -o "C:\APPS\COPRO\MCU\CUBEMX\N6_MX\Template_FSBL_LRUN\Appli\build\Template_FSBL_LRUN_Appli-trusted.bin" `
    -hv 2.3 -align -s

# FSBL 签名
& "C:\APPS\Programmer\bin\STM32_SigningTool_CLI.exe" `
    -bin "C:\APPS\COPRO\MCU\CUBEMX\N6_MX\Template_FSBL_LRUN\FSBL\build\Template_FSBL_LRUN_FSBL.bin" `
    -nk -of 0x80000000 -t fsbl `
    -o "C:\APPS\COPRO\MCU\CUBEMX\N6_MX\Template_FSBL_LRUN\FSBL\build\Template_FSBL_LRUN_FSBL-trusted.bin" `
    -hv 2.3 -align -s

5.3 签名参数说明

参数	说明
`-bin`	输入的 .bin 文件路径
`-nk`	No Key，开发模式，不做真正签名验证
`-of 0x80000000`	Option flags 地址偏移
`-t fsbl`	Binary type：FSBL 类型
`-hv 2.3`	Header version（N6 必须用 2.3）
`-align`	必须加，payload 对齐到 0x400
`-s`	静默模式，不弹出覆盖确认提示

5.4 烧录地址

文件	地址
`Appli-trusted.bin`	`0x7010_0000`
`FSBL-trusted.bin`	`0x7000_0000`（可选）

5.5 烧录后现象

阶段	现象
FSBL 初始化	红灯（PG.10）闪烁 3 次
跳转 Appli	绿灯（PG.00）和蓝灯（PG.08）交替闪烁

5.6 External Loader (.stldr)

烧录外部 XSPI Flash 时，CubeProgrammer 需要加载对应的 External Loader 文件：

开发板	Loader 文件
NUCLEO-N657X0-Q	`NUCLEO_N657X0_Q.stldr`（通常在 CubeProgrammer 安装目录下）

位置：通常在 C:\Program Files\STMicroelectronics\STM32Cube\STM32CubeProgrammer\ExternalLoader\ 下。

踩坑：如果不加载正确的 .stldr 文件，CubeProgrammer 无法识别外部 Flash，烧录时会报错或无法写入。

六、调试方法

6.1 DEV 模式调试（推荐）

设置 BOOT1 = 2-3（DEV 模式）
IDE 加载 FSBL/build/Template_FSBL_LRUN_FSBL.elf 到 RAM
在 Appli 代码打断点
Debug/Run
FSBL 运行 → 加载 Appli → 断点生效

6.2 Flash 模式

无法源码调试，只能靠 LED / UART / ITM。

七、项目文件结构

Template_FSBL_LRUN/
├── CLAUDE.md              # 项目说明文档
├── SKILL.md              # 技能文档
├── README.md              # 官方说明
├── Template_FSBL_LRUN.ioc # CubeMX 配置文件
│
├── FSBL/                  # FSBL 子项目
│   ├── Src/
│   │   ├── main.c         # FSBL 主程序
│   │   ├── extmem.c       # 外部存储初始化
│   ├── Inc/
│   │   ├── main.h
│   │   └── extmem.h
│   ├── mx-generated.cmake # 编译宏定义
│   ├── CMakeLists.txt
│   └── STM32N657XX_LRUN.ld
│
├── Appli/                 # Appli 子项目
│   ├── Src/
│   │   ├── main.c # Appli 主程序
│   ├── Inc/
│   │   ├── main.h
│   │   └── stm32n6xx_nucleo_conf.h
│   ├── mx-generated.cmake
│   ├── CMakeLists.txt
│   └── STM32N657XX_LRUN.ld
│
├── Drivers/               # HAL 驱动（项目内）
├── Secure_nsclib/          # 安全非安全调用库
├── gcc-arm-none-eabi.cmake # 工具链配置
└── mx-generated.cmake       # 主 CMake 配置

八、参考文献

ST 官方社区帖子

ST 官方 PDF

rm0486 — STM32N657xx ARM-based 32-bit MCUs
um3234 — How to proceed with Boot ROM on STM32N6 MCUs
an6265 — Getting started with STM32N6 MCUs in STM32CubeIDE
an5967 — Getting started with hardware development for STM32N6 MCUs
um3249 — Getting started with STM32CubeN6 for STM32N6 series
pm0273 — STM32 Cortex-M55 MCUs Programming Manual
Nucleo-N657X0-Q 原理图 (en.mb1940-n657x0q-c02-schematic)
um3417 — STM32N6 Nucleo144 board MB1940

九、常见问题速查

现象	可能原因	解决方法
烧录报错”内核被锁定”	Option Bytes 锁定	按住 Reset 再烧录，或 Mass Erase
烧录报错”写入保护”	读保护 RDP 开启	使用 Mass Erase 擦除
Flash 模式不运行	没有 `-align` 签名	重新签名，加 `-align`
Flash 模式不运行	OTP 未配置	第一次禁用 NO_OTP_FUSE，让 FSBL 配置 OTP
芯片无响应	调试器断开	按 Reset，重新连接
调试时断点不生效	用了 Flash 模式	切回 DEV 模式，BOOT1=2-3
编译后无 .bin 文件	CMakeLists.txt 缺少 post-build	添加 objcopy 命令
签名报”binary not found”	PowerShell 引号问题	用 `& "..."` 或在 CMD 里运行

STM32 SimpleFOC 位置伺服：从零到稳，2个Hard Bug的排查与修复全记录

Mon, 01 Jun 2026 02:30:00 GMT

一、项目背景

用 STM32F103C8T6 (Blue Pill) 从零搭建一个 FOC 位置伺服系统，驱动 2804 云台电机。

这套系统的”从零”不是从 SimpleFOC 库开始——而是从 CubeMX 生成的 HAL 代码开始，手写 FOC 核心算法、PID 控制器、编码器驱动、串口命令解析。整个开发周期约两周，其中调试占了 80% 的时间。

最终效果：电机锁位稳如磐石，推两圈松手原路倒两圈回来，PID 参数可在线调节无瞬态冲击。而这背后，是 2 个真实 bug 的定位与修复——以及几个”以为是根因”的误报记录。

硬件架构

STM32F103C8T6 (72MHz)
├── TIM1 CH1/CH2/CH3 (PA8/PA9/PA10) → SimpleFOC Mini IN1/IN2/IN3
├── PA11 GPIO OUT → SimpleFOC Mini ENABLE
├── I2C1 PB8(SCL) / PB9(SDA) → AS5600 磁编码器 (0x36)
├── USART1 PB6(TX) / PB7(RX) → USB-TTL (115200 8N1)
└── TIM2 (1098Hz 中断) → 控制循环节拍

MCU: STM32F103C8T6, 72MHz, 64KB Flash, 20KB RAM
驱动板: SimpleFOC Mini (3 路半桥)
编码器: AS5600 12-bit 磁编码器 (I2C 接口)
电机: 2804 云台电机, 12 槽 14 极 (7 极对), 低内阻

软件架构

main loop (110Hz)
  ├─ TIM2 中断 → foc_tick 标志
  ├─ 传感器读取 → AS5600 (软 I2C)
  ├─ 角度展开 → 单圈绝对值 → 累计角度
  ├─ PID 控制 → D-on-measurement + 低通滤波
  ├─ SVPWM → 三相正弦波 (中心对齐 PWM)
  └─ UART 命令解析 → ? T90 Kp0.1 ...

二、误报：硬件 I2C 卡死？

现象

电机正常运行 30~60 秒后突然”失力”——编码器读数冻结在某一个值，用手转电机完全无回正力矩，串口自动打印也停了。断电重插恢复，运行一段时间又复现。

排查过程

D 命令（编码器诊断）在某次故障中读出了和 ? 状态命令不同的值——? 报 Raw=1445, D 报 Raw=4030。排除编码器硬件故障。
I2C Err 始终为 0——HAL 没有报错，但返回的是旧寄存器值，说明 I2C 外设可能进入了”假成功”状态。
查阅 STM32F103 Errata：I2C 外设在特定总线时序下会卡死在 BUSY 状态，软件无法通过正常方式恢复，只能复位外设。

尝试过的修复

// 检测到读数连续 100 次不变时，尝试复位 I2C 外设
__HAL_RCC_I2C1_FORCE_RESET();
__HAL_RCC_I2C1_RELEASE_RESET();
HAL_I2C_Init(&hi2c1);

结果

改完软 I2C 之后，问题依然存在。后续发现真正的根因是 uint16_t tick 溢出，改了之后就稳定了。软件 I2C 的改动留下了（更可靠），但 I2C 本身不是这个症状的根因。

教训: 一个症状可能有多个”嫌疑人”，改了 A 不代表修好了。当无法确认根因时，先找最直接的可重现线索（时间规律）。

三、误报：PID 正反馈？

现象

上电后电机不锁位，持续旋转。发 T90 后电机加速跑而不是停下来。

排查过程

检查 PID 的 setpoint/measurement 传参——逻辑看起来可能有问题。

结果

实际检查代码后发现 PID 符号传参本身没有反转，这并不是真正的 bug。症状的真正原因同样是 uint16_t tick 溢出——控制循环根本没在跑。

教训: 在没有 trace 工具的情况下，容易把”没跑”当成”跑错了”。先确认代码是否真的在运行，再分析运行时的行为。

四、误报：栈溢出？

现象

电机每隔几十秒”突然死机”——自动打印停，电机吸附在磁极位，串口命令也没反应。

排查过程

检查栈大小：STM32F103XX_FLASH.ld 中 _Min_Stack_Size = 0x400（仅 1KB）
snprintf + %f 会拉入 _printf_float，单条调用链栈消耗 >700 字节
尝试扩栈到 2KB + 大 buf 改 static

结果

改了之后问题依然存在。真正的根因依然是 uint16_t tick 溢出。

教训: 嵌入式里 snprintf + %f 确实吃栈，但这题里不是它干的。猜测 + 修 + 验证，而不是修完没效果还接着信。

五、Bug #1 — uint16_t Tick 溢出 + C 整型提升陷阱

这是真正解决问题的那个 bug。改了之后系统稳定运行。

现象

电机每隔约 60 秒就”卡死”——自动打印停，电机不响应，但串口命令还能处理。观察到 tick_count 从 65535 跳回 0（uint16_t 溢出），和故障时间点完全吻合。

根因分析

这是 C 语言的整型提升规则（Integer Promotion） 导致的隐蔽 bug：

volatile uint16_t tick_count = 0;
static uint16_t last_ctrl_tick = 65530;

// 你看到的：
if (tick_count - last_ctrl_tick >= 10)

// 编译器实际生成的：
// uint16_t - uint16_t → 提升为 signed int (32-bit)
if ((int)tick_count - (int)last_ctrl_tick >= 10)
//  当 tick_count 溢出归零时:
//  (int)0 - (int)65530 = -65530
//  -65530 >= 10 ? → false → 控制更新不再触发！

C11 标准 §6.3.1.1：当 uint16_t（比 int 窄）参与算术运算时，先提升为 int（有符号）。无符号环绕特性在提升过程中被破坏了。

这是一个非常隐蔽的 bug——代码逻辑看起来正确（无符号减法天然支持环绕），但编译器把它变成了有符号运算，溢出时得到负数，比较永远不成立。

修复

将 tick_count 和相关变量改为 uint32_t：

volatile uint32_t tick_count = 0;       // 49 天溢出, 不再在运行时触发
static uint32_t last_ctrl_tick = 0;
static uint32_t print_tick = 0;

在 32 位 ARM 上, uint32_t = unsigned int, 与 signed int 同级。C 标准的 “usual arithmetic conversions” 规定同级时 unsigned 优先，所以 uint32_t - uint32_t 保持在无符号域。这才是原理修复——不是推迟溢出，而是保证减法永远在无符号域完成。

教训: 嵌入式 C 中, uint8_t 和 uint16_t 的减法不可信——要么强转 (uint16_t)(a - b), 要么直接用 uint32_t。这个 bug 花了两天才定位到编译器层面。确认有效的修复：把 uint16_t 改成 uint32_t。

六、Bug #2 — PID_Reset 后 D 项速度尖峰

这个 bug 也是真实存在的，调 PID 参数时会触发瞬态冲击。

现象

串口发 kp0（把 Kp 设为 0），电机突然猛踹一脚飞出去。之后即使恢复 Kp，电机已漂到未知位置。

根因

PID_Reset 将 prev_measurement 清零。下一个控制周期：

velocity = (measurement - 0) / 0.009s
         = (155° - 0°) / 0.009s
         = 17,200°/s

D_out = -Kd × 300 → 瞬间饱和 → 电机被 40% 占空比猛踹一脚

修复：哨兵值

#define PID_MEAS_UNINIT (-1e10f)  // 合法角度 0~2π 不可能在此

void PID_Init(...) {
    pid->prev_measurement = PID_MEAS_UNINIT;
}

void PID_Reset(...) {
    pid->integral = 0.0f;
    pid->prev_measurement = PID_MEAS_UNINIT;  // 哨兵
    // deriv_filtered 不清零, 首帧 D 被跳过, 从零重新累积
}

float PID_Update(...) {
    if (pid->prev_measurement < -1e9f) {
        // 首帧 → 跳过 D, 仅记录当前值
        pid->prev_measurement = measurement;
        D_out = 0.0f;
    } else {
        // 正常 D 计算
    }
}

效果：调 PID 参数不再产生瞬态冲击。

教训: Reset 函数不能盲清零。任何有记忆性的状态量在 Reset 时都要用哨兵值标记”未初始化”状态。

七、教训总结

#	问题	类别	结论
1	I2C BUSY	误报	改了软 I2C，但症状的根因是 uint16_t 溢出
2	PID 符号	误报	传参实际没有反转；真正原因是控制循环没有跑
3	栈溢出	误报	改了大 buf/扩了栈，但根因还是 uint16_t 溢出
4	uint16_t 整型提升	真实 bug	确认有效修复：改为 uint32_t
5	PID Reset D 尖峰	真实 bug	确认有效修复：哨兵值

两个真实 bug 都定位到了根因并修复。三个”嫌疑人”其实是症状的副产品而非根因——当 uint16_t 溢出导致控制循环停止时，所有”控制不工作”的表现都会被误认为各自有独立的根因。

不找到根因就不算修好。 同一个症状可能有多个人在喊，但你只能信第一个（最准时）的线索——时间规律是最好的 debug 信息。

完整源码：GitHub - simpleFOC_1

Delta 并联机器人 — 从零搭建运动学库

Thu, 14 May 2026 23:00:00 GMT

最近把 Delta 并联机器人的运动学库写完了，记录一下过程和关键数据。

机械参数

参数	值	说明
Rb	115 mm	静平台半径（中心到电机轴）
Re	75 mm	动平台半径（中心到球铰，150/2）
L1	125 mm	驱动臂（大臂）长度
L2	338 mm	从动臂（小臂/拉杆）长度

运动学核心

逆解 (IK)

给定末端位置 (x, y, z)，求三个电机角度 θ₁, θ₂, θ₃。

对每个支链，将问题转换到局部坐标系，简化为平面 2R 连杆逆运动学：

x_local·sin(θ) - z_local·cos(θ) = (d² + L1² - L2²) / (2·L1)

解为：

θ = φ + π/2 + α

其中 φ = atan2(z_local, x_local)，α = acos((L1² + d² - L2²) / (2·L1·d))。

关键细节：从动臂在旋转平面外的投影要处理为有效长度 L2_eff = sqrt(L2² - y_local²)。

正解 (FK)

给定 θ₁, θ₂, θ₃，求末端位置。用牛顿迭代法求解三球交汇点，收敛到误差 < 1e-6 mm。

MATLAB 验证结果

用 MATLAB 验证 IK→FK 一致性，在所有测试点误差均为 0.0000 mm。

工作空间

扫描范围 20mm 网格，共 5928 个可达点：

Z (mm)	最大半径 (mm)
-460	14
-440	103
-400	192
-360	247
-300 ~ -200	247
-100	247

工作空间呈穹顶形，Z 范围约 -460 ~ -100 mm，最大水平半径约 250mm。

代码组织

deltarobot/
├── inc/
│   ├── delta_common.h        → 向量、角度、工具
│   ├── delta_param.h         → 机械参数结构体
│   ├── delta_kinematics.h    → IK/FK/雅可比
│   ├── delta_trajectory.h    → 轨迹规划（插补+S曲线）
│   └── delta_control.h       → 三轴协调控制接口
├── src/
│   ├── delta_kinematics.cpp
│   ├── delta_trajectory.cpp
│   └── delta_control.cpp
├── scripts/
│   ├── verify_delta.m         → 运动学验证 + 工作空间计算
│   └── workspace.m            → 工作空间可视化
└── README.md

下一步

在 STM32F407 上跑通 IK 计算
配合步进电机 DRV8825/TMC2209 做开环位置控制
后来再加编码器闭环

STM32 库设计笔记2

Wed, 13 May 2026 16:05:13 GMT

第一阶段：新手村——硬编码

场景

我们有一个小车的底盘控制程序，需要控制两个直流电机。

代码

// 新手写法：每次用到就写具体操作
void main(void) {
    // 左轮前进
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_SET);
    __HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_1, 500);
    
    HAL_Delay(1000);
    
    // 右轮前进
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, GPIO_PIN_SET);
    __HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_1, 500);
    
    HAL_Delay(1000);
    
    // 停止左轮
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_RESET);
    __HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_1, 0);
    
    // 停止右轮
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, GPIO_PIN_RESET);
    __HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_1, 0);
}

问题

代码重复：每个操作都要写一堆寄存器/库函数
不可移植：换 MCU 要改所有文件
不可读：看代码不知道是在“控制电机”，只知道在“操作 GPIO 和 PWM”
不可维护：要改电机逻辑，需要找遍所有调用的地方

核心痛点

业务逻辑（让车前进）和硬件操作（拉高 GPIO、写 PWM）混在一起

第二阶段：函数封装（把重复代码收起来）

思路

把硬件操作包成函数，上层调用函数名，不看内部实现。

代码

// motor_hw.c - 硬件操作封装
void motor_left_forward(uint16_t speed) {
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_SET);
    __HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_1, speed);
}

void motor_left_stop(void) {
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_RESET);
    __HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_1, 0);
}

void motor_right_forward(uint16_t speed) {
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, GPIO_PIN_SET);
    __HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_1, speed);
}

void motor_right_stop(void) {
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, GPIO_PIN_RESET);
    __HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_1, 0);
}

// main.c - 业务逻辑变清晰了
void main(void) {
    motor_left_forward(500);
    motor_right_forward(500);
    HAL_Delay(1000);
    motor_left_stop();
    motor_right_stop();
}

优点

代码可读性提升
硬件操作集中在一个文件，换 MCU 只改这个文件

新问题

函数泛滥：每个动作一个函数（左转、右转、前进、后退、带加速度…），函数数量爆炸
参数不统一：有的函数用 uint16_t speed，有的用 float duty
扩展性差：增加新电机需要写 4 个新函数

第三阶段：传参驱动（用参数代替函数名）

思路

不要为每个动作单独写函数，而是写一个“通用函数”，用参数区分动作。

代码

// 用一个函数代替多个
void motor_control(uint8_t id, uint8_t action, int16_t speed) {
    switch(id) {
        case 0:  // 左轮
            if (action == FORWARD) {
                HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_SET);
                __HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_1, speed);
            } else if (action == STOP) {
                HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_RESET);
                __HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_1, 0);
            }
            break;
        case 1:  // 右轮
            // 类似...
            break;
    }
}

// 使用
motor_control(0, FORWARD, 500);
motor_control(1, FORWARD, 500);
HAL_Delay(1000);
motor_control(0, STOP, 0);
motor_control(1, STOP, 0);

优点

函数数量从 电机数 × 动作数 减少到 1 个
新增动作只需加 case，不用加函数

新问题

参数越来越多：要支持加速度？加参数 uint8_t accel；要支持方向？加参数 uint8_t dir… 参数列表越来越长
类型不安全：action 参数传错值（传了 255 而不是 FORWARD），编译器不报错
可读性变差：motor_control(0, 1, 500) 是什么意思？要看文档或函数定义

进化：用结构体传参

// 把多个参数打包成一个结构体
typedef struct {
    uint8_t motor_id;      // 0=左轮, 1=右轮
    uint8_t action;        // FORWARD, BACKWARD, STOP
    int16_t speed;         // -1000 ~ 1000
    uint8_t accel_rate;    // 0-10
    uint32_t duration_ms;  // 持续时间
} MotorCommand_t;

void motor_control(MotorCommand_t* cmd) {
    // 根据 cmd 里的字段执行
}

// 使用
MotorCommand_t cmd = {.motor_id=0, .action=FORWARD, .speed=500, .accel_rate=5, .duration_ms=1000};
motor_control(&cmd);

优点

参数清晰，有字段名
扩展参数只需改结构体，不用改函数签名

第四阶段：状态机 + 非阻塞（让 CPU 能干别的事）

问题

前面的写法都是阻塞的：HAL_Delay(1000) 会让 CPU 傻等 1 秒，啥也不能做。

思路

把“等待”变成“周期性检查”：每次调用只做一小步，然后返回。主循环不断调用，直到完成。

代码

typedef struct {
    int16_t target_speed;
    int16_t current_speed;
    uint32_t start_time;
    uint32_t duration;
    uint8_t is_active;
} MotorState_t;

MotorState_t motors[2];

void motor_start(uint8_t id, int16_t speed, uint32_t ms) {
    motors[id].target_speed = speed;
    motors[id].duration = ms;
    motors[id].start_time = get_tick_ms();  // 获取当前时间
    motors[id].is_active = 1;
}

void motor_update(void) {
    for (int i = 0; i < 2; i++) {
        if (!motors[i].is_active) continue;
        
        uint32_t elapsed = get_tick_ms() - motors[i].start_time;
        
        if (elapsed >= motors[i].duration) {
            // 时间到，停止
            motors[i].is_active = 0;
            set_pwm(i, 0);
        } else {
            // 还在运行中
            set_pwm(i, motors[i].target_speed);
        }
    }
}

// 主循环（非阻塞）
void main(void) {
    motor_start(0, 500, 1000);  // 左轮转1秒
    motor_start(1, 500, 1000);  // 右轮转1秒
    
    while (1) {
        motor_update();  // 每10ms调用一次
        
        // 这10ms间隙可以做其他事
        read_sensors();
        check_emergency();
        
        delay_ms(10);
    }
}

核心变化

阻塞式	非阻塞式
`HAL_Delay(1000)`	`motor_start(..., 1000)` + 主循环轮询
CPU 空转 1 秒	CPU 每 10ms 检查一次，其他时间干活
只能顺序执行动作	可以同时处理多个任务

第五阶段：结构体封装多实例（为多态做准备）

问题

目前每个电机是全局状态，要加新电机需要手动复制粘贴代码。

思路

把电机相关的数据和方法打包成一个结构体，用指针操作。

代码

// 电机"类"
typedef struct Motor_t {
    // 属性（数据）
    int16_t target_speed;
    int16_t current_speed;
    uint32_t start_time;
    uint32_t duration;
    uint8_t is_active;
    uint8_t id;
    
    // 方法（函数指针）
    void (*start)(struct Motor_t* self, int16_t speed, uint32_t ms);
    void (*update)(struct Motor_t* self);
} Motor_t;

// 方法实现
void motor_start_impl(Motor_t* self, int16_t speed, uint32_t ms) {
    self->target_speed = speed;
    self->duration = ms;
    self->start_time = get_tick_ms();
    self->is_active = 1;
}

void motor_update_impl(Motor_t* self) {
    if (!self->is_active) return;
    
    if (get_tick_ms() - self->start_time >= self->duration) {
        self->is_active = 0;
        set_pwm(self->id, 0);
    } else {
        set_pwm(self->id, self->target_speed);
    }
}

// 创建实例
Motor_t left_motor = {
    .id = 0,
    .start = motor_start_impl,
    .update = motor_update_impl,
};

Motor_t right_motor = {
    .id = 1,
    .start = motor_start_impl,
    .update = motor_update_impl,
};

// 使用
void main(void) {
    left_motor.start(&left_motor, 500, 1000);
    right_motor.start(&right_motor, 500, 1000);
    
    while (1) {
        left_motor.update(&left_motor);
        right_motor.update(&right_motor);
        delay_ms(10);
    }
}

关键点：`self` 指针

每个方法第一个参数都是 self，指向调用它的实例。这样同一个 motor_update_impl 函数可以操作不同的电机数据。

第六阶段：硬件抽象（换 MCU 不改上层代码）

问题

目前 set_pwm() 函数里还是直接调用 HAL 库，换 MCU 需要改这个函数内部。

思路

把硬件操作也抽象成操作表（函数指针集合），上层只调用操作表，不直接调用 HAL。

代码

// 硬件操作表（抽象层）
typedef struct {
    void (*pwm_set)(uint8_t channel, uint16_t duty);
    uint32_t (*get_tick)(void);
    void (*delay_ms)(uint32_t ms);
} Hardware_t;

// STM32 实现
static void stm32_pwm_set(uint8_t ch, uint16_t duty) {
    __HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_1 + ch, duty);
}

static uint32_t stm32_get_tick(void) {
    return HAL_GetTick();
}

Hardware_t STM32_Hardware = {
    .pwm_set = stm32_pwm_set,
    .get_tick = stm32_get_tick,
    .delay_ms = HAL_Delay,
};

// 上层代码依赖抽象，不依赖具体
Hardware_t* HW = &STM32_Hardware;  // 换平台只改这一行

// 电机控制代码改为
void motor_update_impl(Motor_t* self) {
    // ...
    HW->pwm_set(self->id, self->target_speed);
}

效果

平台	需要改的代码
STM32	`stm32_pwm_set` 等函数的实现
ESP32	写一套 `esp32_pwm_set` 等函数，然后 `HW = &ESP32_Hardware`
模拟测试	写一套 mock 函数，在 PC 上跑

上层业务逻辑（电机控制、底盘控制）一行代码都不用改！

第七阶段：多态（同一个接口，不同行为）

场景

现在有两种电机：

直流电机：需要 PID 闭环控制
步进电机：需要发脉冲控制

问题

它们的行为完全不同，但我们希望上层能用统一的接口：motor_update()

解决方案：操作表 + 派生结构体

// ========== 第一步：定义通用接口 ==========
typedef struct Motor_t Motor_t;
typedef struct {
    void (*update)(Motor_t* self);
    void (*set_speed)(Motor_t* self, int16_t speed);
} MotorOps_t;

struct Motor_t {
    MotorOps_t* ops;  // 操作表（告诉怎么操作）
    uint8_t id;
    // 其他通用属性...
};

// ========== 第二步：实现直流电机 ==========
typedef struct {
    Motor_t base;           // 继承通用部分
    int16_t target_speed;
    int16_t current_speed;
    float kp, ki, kd;       // PID参数
} DCMotor_t;

static void dc_update(Motor_t* self) {
    DCMotor_t* dc = (DCMotor_t*)self;
    // PID 计算
    int16_t error = dc->target_speed - dc->current_speed;
    int16_t output = error * dc->kp;
    HW->pwm_set(self->id, output);
}

static void dc_set_speed(Motor_t* self, int16_t speed) {
    DCMotor_t* dc = (DCMotor_t*)self;
    dc->target_speed = speed;
}

static MotorOps_t dc_ops = {
    .update = dc_update,
    .set_speed = dc_set_speed,
};

// ========== 第三步：实现步进电机 ==========
typedef struct {
    Motor_t base;           // 继承通用部分
    int32_t target_steps;
    int32_t current_steps;
} StepperMotor_t;

static void stepper_update(Motor_t* self) {
    StepperMotor_t* stepper = (StepperMotor_t*)self;
    if (stepper->current_steps < stepper->target_steps) {
        // 发一个脉冲
        HW->gpio_toggle(self->id);
        stepper->current_steps++;
    }
}

static void stepper_set_speed(Motor_t* self, int16_t speed) {
    StepperMotor_t* stepper = (StepperMotor_t*)self;
    stepper->target_steps = speed;  // 这里 speed 实际表示步数
}

static MotorOps_t stepper_ops = {
    .update = stepper_update,
    .set_speed = stepper_set_speed,
};

// ========== 第四步：创建对象 ==========
DCMotor_t dc_motor_obj = {
    .base = { .ops = &dc_ops, .id = 0 },
    .target_speed = 0,
    .kp = 1.5,
};

StepperMotor_t stepper_obj = {
    .base = { .ops = &stepper_ops, .id = 1 },
    .target_steps = 0,
};

Motor_t* motors[2] = {
    (Motor_t*)&dc_motor_obj,
    (Motor_t*)&stepper_obj,
};

// ========== 第五步：统一调用 ==========
void main(void) {
    motors[0]->ops->set_speed(motors[0], 500);
    motors[1]->ops->set_speed(motors[1], 1000);
    
    while (1) {
        for (int i = 0; i < 2; i++) {
            motors[i]->ops->update(motors[i]);  // 同一个调用，不同行为！
        }
        delay_ms(10);
    }
}

多态的魔力

motors[0]（直流电机）:
    motors[0]->ops->update → 执行 dc_update() → PID 计算 → 设 PWM

motors[1]（步进电机）:
    motors[1]->ops->update → 执行 stepper_update() → 发脉冲 → 走一步

同样的代码 motors[i]->ops->update(motors[i])，做的是完全不同的事情！

总结：架构演化路线图

阶段	核心思想	关键代码特征	解决的问题
1. 硬编码	写到哪算哪	寄存器操作散落各处	无
2. 函数封装	硬件操作打包	`motor_left_forward()`	可读性、集中修改
3. 传参驱动	用参数区分行为	`motor_control(id, action, speed)`	减少函数数量
4. 非阻塞	状态机 + 轮询	`motor_start()` + `motor_update()`	CPU 不空转
5. 多实例	结构体封装	`Motor_t` + `self` 指针	支持多个对象
6. 硬件抽象	操作表	`Hardware_t` + 函数指针	跨平台移植
7. 多态	每个对象有自己的操作表	`MotorOps_t` + 派生结构体	同一接口，不同行为

最后：什么时候用哪种？

项目规模	推荐阶段	理由
1-2 个文件，个人玩具	阶段 2-3	够用，不折腾
多个模块，团队开发	阶段 4-5	可维护性重要
需要换平台的产品	阶段 6	硬件抽象是刚需
有多种设备类型（电机、灯、传感器）	阶段 7	多态让扩展变得简单

轮腿机器人二自由度闭式连杆机构正逆运动学推导

Mon, 04 May 2026 06:00:00 GMT

1. 问题背景

轮腿式机器人（wheel-legged robot）的每条腿需要同时具备 轮式滚动 和 腿部越障 两种能力。本文讨论的机构设计采用两个同轴电机，通过一套 8 字形双平行四边形连杆将动力传递到轮端，实现腿部摆动与轮子转向的解耦控制。

与传统带传动或齿轮传动方案相比，这种全连杆机构具有 零回程差、结构刚度高、无磨损件 等优点，特别适合需要高精度末端位置控制的轮腿机器人应用。

flowchart TD
  M["电机 A (θa)"] --> A["bar_a（三副杆 O-P1-P2）"]
  M2["电机 B (θb)"] --> B["bar_b（二副杆 O-P3）"]
  A --> D["bar_d（三副直杆 P1-P4-P5）"]
  B --> C["bar_c（二副杆 P3-P4）"]
  C --> D
  D --> E["bar_e（二副杆 P5-P6）"]
  A --> F["bar_f（三副直杆 P2-P6-P7）"]
  E --> F
  F --> W["P7 — 轮毂电机（末端）"]

两个平行四边形嵌套成 8 字形：

平行四边形 1：O – P1 – P4 – P3，边长 48.4 × 57.3 mm
平行四边形 2：P1 – P2 – P6 – P5，边长 59 × 32.4 mm

关键之处在于：所有三副杆（bar_a、bar_d、bar_f）都是直杆（三点共线）。这个几何约束是后续解析简化的核心前提。

2. 正运动学推导

正运动学的目标是：给定电机转角 θa,θb\theta_a, \theta_bθa,θb，求末端 P7P_7P7 的位置。

2.1 点坐标逐步求解

Step 1 — bar_a 上的 P1、P2

以 O 为原点，绕 θa\theta_aθa 旋转：

P1=LOP1[cos⁡θasin⁡θa]=48.4[cos⁡θasin⁡θa]P2=LOP2[cos⁡θasin⁡θa]=107.4[cos⁡θasin⁡θa]\begin{aligned} P_1 &= L_{OP1} \begin{bmatrix}\cos\theta_a \\ \sin\theta_a\end{bmatrix} = 48.4 \begin{bmatrix}\cos\theta_a \\ \sin\theta_a\end{bmatrix} \\[6pt] P_2 &= L_{OP2} \begin{bmatrix}\cos\theta_a \\ \sin\theta_a\end{bmatrix} = 107.4 \begin{bmatrix}\cos\theta_a \\ \sin\theta_a\end{bmatrix} \end{aligned}P1P2=LOP1[cosθasinθa]=48.4[cosθasinθa]=LOP2[cosθasinθa]=107.4[cosθasinθa]

这里 LOP2=48.4+59=107.4L_{OP2} = 48.4 + 59 = 107.4LOP2=48.4+59=107.4，因为 bar_a 是直杆，P1 在 O–P2 连线上。

Step 2 — bar_b 上的 P3

P3=Lb[cos⁡θbsin⁡θb]=57.3[cos⁡θbsin⁡θb]P_3 = L_b \begin{bmatrix}\cos\theta_b \\ \sin\theta_b\end{bmatrix} = 57.3 \begin{bmatrix}\cos\theta_b \\ \sin\theta_b\end{bmatrix}P3=Lb[cosθbsinθb]=57.3[cosθbsinθb]

Step 3 — bar_d 上的 P4（两圆相交）

由平行四边形 1 可知 ∣P1P4∣|P_1P_4|∣P1P4∣、∣P3P4∣|P_3P_4|∣P3P4∣ 为固定值，故 P4 是两圆的交点：

圆心 P1P_1P1，半径 LP1P4=57.3L_{P1P4} = 57.3LP1P4=57.3
圆心 P3P_3P3，半径 Lc=48.4L_c = 48.4Lc=48.4

两圆相交的解析求解过程如下。令向量 v=P3−P1\mathbf{v} = P_3 - P_1v=P3−P1，两圆心距离 d=∥v∥d = \|\mathbf{v}\|d=∥v∥，则：

a=LP1P42−Lc2+d22dh=LP1P42−a2P4=P1+adv±hdRv\begin{aligned} a &= \frac{L_{P1P4}^2 - L_c^2 + d^2}{2d} \\[4pt] h &= \sqrt{L_{P1P4}^2 - a^2} \\[4pt] P_4 &= P_1 + \frac{a}{d}\mathbf{v} \pm \frac{h}{d}\mathbf{R}\mathbf{v} \end{aligned}ahP4=2dLP1P42−Lc2+d2=LP1P42−a2=P1+dav±dhRv

其中 R=[0−110]\mathbf{R} = \begin{bmatrix}0 & -1 \\ 1 & 0\end{bmatrix}R=[01−10] 为 90∘90^\circ90∘ 旋转矩阵，±\pm± 号的选择对应两种装配模式，记作 branch_d=±1\mathrm{branch}\_d = \pm 1branch_d=±1。

2.2 核心简化：直杆约束

得到 P4 后，bar_d 的方向角为：

θd=atan2(P4−P1)\theta_d = \text{atan2}(P_4 - P_1)θd=atan2(P4−P1)

因为 bar_d 是直杆，P5 与 P1、P4 共线，且 ∣P1P5∣=32.4|P_1P_5| = 32.4∣P1P5∣=32.4，所以：

P5=P1+32.457.3(P4−P1)P_5 = P_1 + \frac{32.4}{57.3} (P_4 - P_1)P5=P1+57.332.4(P4−P1)

代入平行四边形 2 的关系 P6=P2+P5−P1P_6 = P_2 + P_5 - P_1P6=P2+P5−P1，消去 P5：

P6=P2−32.457.3(P4−P1)P_6 = P_2 - \frac{32.4}{57.3} (P_4 - P_1)P6=P2−57.332.4(P4−P1)

注意 P4−P1P_4 - P_1P4−P1 的方向与 P3P_3P3 相同（平行四边形对边平行），而 P3=Lb[cos⁡θb,sin⁡θb]TP_3 = L_b[\cos\theta_b, \sin\theta_b]^TP3=Lb[cosθb,sinθb]T，于是：

P6=P2−32.4[cos⁡θbsin⁡θb]P_6 = P_2 - 32.4 \begin{bmatrix}\cos\theta_b \\ \sin\theta_b\end{bmatrix}P6=P2−32.4[cosθbsinθb]

bar_f 同样是直杆，P7 在 P2→P6 的反方向延长线上，∣P2P7∣=128|P_2P_7| = 128∣P2P7∣=128：

P7=P2+128[cos⁡θbsin⁡θb]P_7 = P_2 + 128 \begin{bmatrix}\cos\theta_b \\ \sin\theta_b\end{bmatrix}P7=P2+128[cosθbsinθb]

2.3 最终解析式

将 P2=107.4[cos⁡θa,sin⁡θa]TP_2 = 107.4[\cos\theta_a, \sin\theta_a]^TP2=107.4[cosθa,sinθa]T 代入，得：

P7=[107.4cos⁡θa+128cos⁡θb107.4sin⁡θa+128sin⁡θb]\boxed{P_7 = \begin{bmatrix} 107.4\cos\theta_a + 128\cos\theta_b \\ 107.4\sin\theta_a + 128\sin\theta_b \end{bmatrix}}P7=[107.4cosθa+128cosθb107.4sinθa+128sinθb]

infographic list-grid-badge-card
data
  title 物理意义
  desc 机构等价于一个标准 2R 平面机械臂
  items
    - label 第一连杆
      desc O → P₂，长 L₁ = 107.4 mm，角度 θa
      icon mdi/link-variant
    - label 第二连杆
      desc P₂ → P₇，长 L₂ = 128 mm，角度 θb
      icon mdi/link-variant
    - label 末端
      desc 轮毂电机位置 P₇
      icon mdi/wheel

这个结论非常优雅：无论双平行四边形如何弯折，末端 P₇ 的位置始终只依赖于两个电机的转角，与中间所有连杆的姿态无关。这得益于直杆约束和嵌套平行四边形的几何特性——中间关节的运动学被完全"消化"掉了。

3. 逆运动学推导

逆运动学：给定末端位置 P7=(x,y)P_7 = (x, y)P7=(x,y)，求 θa,θb\theta_a, \theta_bθa,θb。

3.1 余弦定理

令 r=x2+y2r = \sqrt{x^2 + y^2}r=x2+y2（P7 到原点的距离），ϕ=atan2(y,x)\phi = \text{atan2}(y, x)ϕ=atan2(y,x)。

由 2R 机械臂的几何关系：

cos⁡α=r2+L12−L222L1r\cos\alpha = \frac{r^2 + L_1^2 - L_2^2}{2 L_1 r}cosα=2L1rr2+L12−L22 α=arccos⁡(r2+107.42−12822×107.4×r)\alpha = \arccos\left(\frac{r^2 + 107.4^2 - 128^2}{2 \times 107.4 \times r}\right)α=arccos(2×107.4×rr2+107.42−1282)

3.2 两个解

θa=ϕ±α\theta_a = \phi \pm \alphaθa=ϕ±α

正号对应 elbow-down，负号对应 elbow-up（两种臂型）。

θb=atan2(y−L1sin⁡θa, x−L1cos⁡θa)\theta_b = \text{atan2}\left( y - L_1\sin\theta_a,\; x - L_1\cos\theta_a \right)θb=atan2(y−L1sinθa,x−L1cosθa)

3.3 工作空间与奇异位形

工作空间是一个圆环：

∣L1−L2∣≤r≤L1+L2|L_1 - L_2| \leq r \leq L_1 + L_2∣L1−L2∣≤r≤L1+L2

即 20.6 mm≤r≤235.4 mm20.6 \text{ mm} \leq r \leq 235.4 \text{ mm}20.6 mm≤r≤235.4 mm。

三种奇异位形：

条件	含义	解的情况
r=L1+L2=235.4r = L_1 + L_2 = 235.4r=L1+L2=235.4	完全伸展	单解（θa=θb\theta_a = \theta_bθa=θb）
r=∥L1−L2∥=20.6r = \\|L_1 - L_2\\| = 20.6r=∥L1−L2∥=20.6	完全收缩	单解
r=0r = 0r=0	末端与原点重合	无穷多解

在奇异位形附近，机构的传力性能会急剧下降——微小的末端力就可能在关节处产生很大的力矩。这也是 2R 机械臂的固有问题，在轨迹规划时需要避开奇异区域。

4. 代码实现

4.1 两圆相交

这是整个数值求解的几何基础——给定两个圆心和半径，求交点。

def circle_intersection(c1, r1, c2, r2):
    """返回 (p_left, p_right)，无解时返回 (None, None)。"""
    v = c2 - c1
    d = np.linalg.norm(v)

    if d < 1e-12:          # 同心圆
        return None, None
    if d > r1 + r2 + 1e-10 or d < abs(r1 - r2) - 1e-10:
        return None, None  # 无交点

    a = (r1**2 - r2**2 + d**2) / (2.0 * d)
    h = np.sqrt(max(r1**2 - a**2, 0.0))
    p_mid = c1 + (a / d) * v

    if h < 1e-10:
        return p_mid.copy(), p_mid.copy()  # 相切

    perp = np.array([-v[1], v[0]]) / d
    return p_mid + h * perp, p_mid - h * perp

通过 perp 向量的正负号区分两个解——对应两种装配模式。

4.2 正运动学求解器

def solve_linkage(theta_a, theta_b, params, prev_theta_d=None, prev_theta_f=None):
    # 1. bar_a 上的 P1, P2
    P1 = rotate_vec(np.array([params.L_OP1, 0.0]), theta_a)
    P2 = rotate_vec(params._a2_local, theta_a)

    # 2. bar_b 上的 P3
    P3 = params.L_b * np.array([np.cos(theta_b), np.sin(theta_b)])

    # 3. 两圆相交求 P4
    p4_left, p4_right = circle_intersection(P1, params.L_P1P4, P3, params.L_c)
    # prev_theta_d 用于轨迹跟踪时保持分支连续性

    # 4. bar_d 方向 → P5
    theta_d = np.arctan2((P4 - P1)[1], (P4 - P1)[0])
    P5 = P1 + rotate_vec(params._d5_local, theta_d)

    # 5. 两圆相交求 P6
    p6_left, p6_right = circle_intersection(P2, params.L_P2P6, P5, params.L_e)

    # 6. bar_f 方向 → P7（末端）
    theta_f = np.arctan2((P6 - P2)[1], (P6 - P2)[0])
    P7 = P2 + rotate_vec(params._f7_local, theta_f)

    return {'P7': P7, 'theta_d': theta_d, 'theta_f': theta_f, ...}

整个求解过程全部由三角函数和开方完成，无需任何迭代，属于纯解析正解。

4.3 逆运动学

def solve_inverse(P7_target, params, elbow=1):
    L1, L2 = params.L_OP2, params.L_P2P7
    x, y = P7_target
    r = np.hypot(x, y)

    if r > L1 + L2 + 1e-6 or r < abs(L1 - L2) - 1e-6:
        return []  # 超出工作空间

    cos_alpha = (r**2 + L1**2 - L2**2) / (2.0 * L1 * r)
    alpha = np.arccos(np.clip(cos_alpha, -1.0, 1.0))
    phi = np.arctan2(y, x)

    solutions = []
    for sgn in ([-1, 1] if elbow == 0 else [elbow]):
        theta_a = phi + sgn * alpha
        theta_b = np.arctan2(
            y - L1 * np.sin(theta_a),
            x - L1 * np.cos(theta_a),
        )
        solutions.append({'theta_a': theta_a, 'theta_b': theta_b})

    return solutions

elbow 参数控制返回哪个逆解：+1 肘向上、-1 肘向下、0 返回全部两个解。

5. 四种装配模式

两圆相交的 ±\pm± 选择带来了 四种装配模式（branch_d × branch_f），对应实际机构的不同组装方式：

infographic list-grid-badge-card
data
  title 四种装配模式
  desc 两圆相交 ± 解的组合 → 四种装配模式
  items
    - label "凸凸 (−1, −1)"
      desc P₄ 在 P₁→P₃ 左侧，P₆ 在 P₂→P₅ 左侧
    - label "凸凹 (−1, +1)"
      desc P₄ 在 P₁→P₃ 左侧，P₆ 在 P₂→P₅ 右侧
    - label "凹凸 (+1, −1)"
      desc P₄ 在 P₁→P₃ 右侧，P₆ 在 P₂→P₅ 左侧（★ 默认模式）
    - label "凹凹 (+1, +1)"
      desc P₄ 在 P₁→P₃ 右侧，P₆ 在 P₂→P₅ 右侧

其中 branch_d=+1, branch_f=−1\mathrm{branch}\_d = +1,\ \mathrm{branch}\_f = -1branch_d=+1, branch_f=−1（凹凸）对应两个平行四边形均为凸四边形的情况，这也是 2R 简化成立的默认模式。

其余三种模式中平行四边形会出现不同程度的凹陷，但正逆运动学的解析推导框架仍然相同——仅在求解时选择对应的 ±\pm± 分支即可。不过需要注意，非默认模式下的末端 P₇ 与电机轴的相对方位会发生变化，在轨迹规划时应与默认模式区分对待。

5.1 轨迹跟踪中的分支保持

轨迹跟踪时，每一帧的 solve_linkage 会传入上一帧的 θd,θf\theta_d, \theta_fθd,θf，在两圆相交的两个解中选取与上一帧更接近的那个。这样就能在连续运动中保持同一装配模式，避免跳跃。

# 选取与上一帧更接近的 P4（保持 branch_d 连续性）
P4 = p4_left if norm(p4_left - P4_prev) <= norm(p4_right - P4_prev) else p4_right

同理，P6 的分支选择也采用相同的近邻判定策略。完整的分支保持逻辑如下：

def select_branch(p_left, p_right, p_prev):
    """从两个交点中选取与上一帧更接近的那个"""
    if p_prev is None:
        return p_left  # 首帧，默认取第一个
    d_left = norm(p_left - p_prev)
    d_right = norm(p_right - p_prev)
    return p_left if d_left <= d_right else p_right

这两个分支选择算法共同保证了轨迹跟踪过程中两个平行四边形都能保持连续的装配状态，不会出现"跳帧"导致的运动不连续或机构卡死。

5.2 装配模式的选择依据

默认模式（凹凸, +1, −1）是物理装配最自然的方案——两个平行四边形均保持外凸，机构受力状态最佳，且与 2R 简化模型直接对应，便于运动学规划。

在某些特殊运动需求下（如需要避开障碍物、改变末端姿态范围或优化传力角度），可以选择其他装配模式。装配模式的切换需要在机构经过奇异位形（两圆相切，h=0h = 0h=0）时自然过渡——此时两个解重合，分支可以安全切换。

6. 验证

θa\theta_aθa	θb\theta_bθb	P7P_7P7（解析）	P7P_7P7（数值）
0°	90°	(107.4, 128.0)	(107.4, 128.0) ✓
30°	120°	(29.0, 164.6)	(29.0, 164.6) ✓
0°	0°	(235.4, 0.0)	(235.4, 0.0) ✓
−30°	45°	(183.5, 36.8)	(183.5, 36.8) ✓

以上验证表明，解析推导与数值求解完全一致，正逆运动学求解器正确可靠。

7. 总结

这套 8 字形双平行四边形机构巧妙地利用了 直杆共线 约束，使得看似复杂的连杆传动链最终简化为一个 2R 平面机械臂。正逆运动学均有闭式解析解，无需数值迭代，非常适合嵌入式实时控制场景。

如果你对完整代码感兴趣，项目在 GitHub 上开源：

GitHub - 729DHS/linkage-2dof

https://github.com/729DHS/linkage-2dof

# 快速体验
git clone https://github.com/729DHS/linkage-2dof.git
cd linkage-2dof
uv sync
python main.py interactive   # 交互式滑块
python main.py anim          # 生成动画
python main.py ik            # 逆运动学演示

这世界即残酷也温柔-感触

Tue, 21 Apr 2026 06:52:26 GMT

这世界既残酷也温柔笔记

对于孙割这本书早有耳闻，最近些天看了看，确实有点感触

现在人们总是说什么稳定，稳定反而是最大的谎言，及其难得。依我的观察，也就只有说那种十几二十万年薪的体制内才算这要求，但是显然这要求是极其的高。

人们畏惧不确定性，比尔盖茨十二岁就打电话给惠普公司，第一步极其难以迈出，人们害怕被拒绝，害怕丢脸，失败，害怕事情不向自己预期发展。

我为什么从不找一份稳定的工作

但是谁在意呢？报酬按字数给钱，翻译得越快、字数越多，便能拿到更多的钱。而且翻译者也不认识他们的读者，绝大多数人的态度就是敷衍过关，加快速度交稿了事，根本不在意出版质量，不在意给读者带来的麻烦、误导、偏差。很少有人理会翻译的职业尊严，理会你在翻译时的纠结痛苦。你渐渐发现译好译坏一个样，完全没有任何差别；也没人理会认真、努力、天赋的价值。一个认真的人待在这个环境里会觉得尴尬，而一个混吃等死、喜欢稳定的人则如同找到了组织。当时，我埋头翻译。听到《欢乐颂》里提到过的这类职场老油条们的讨论，他们成天讨论的梦想就是何时能够混入一个更稳定、对工作质量要求更低、对行业尊严更不在乎的行业；他们成天想得最多的事情就是如何能在此基础上，再偷一点工再减一点料再轻松一点，没有最懒，只有更懒；他们成天最大的爱好就是打击那些认为自己能够改变什么、能够有所作为、能够认真对待工作的新人。

所谓的“稳定”，更像是士兵突击里，草原五班那群混日子的兵，无所事事，拿点工资混，就是所谓的稳定，当看到许三多日复一日坚持，他们会感到不安。就像宿舍一群人打游戏，认真学习的人就是异类，因为他打破了群体的稳定。

尤其是现在这低迷的社会环境，人们更倾向于躺平，似乎你作为奋斗者就是异类。他们不仅想混吃等死，还想拉你下水，作为奋斗者，会被称为傻逼，但是显然，成功仍然是属于少数人的，那些躺平的人永远无法成功

90%的人做出 99%的选择，却想要那 1%的结果，显然不行的。那些日复一日认真学习的人，凭什么成功不属于他们呢？

在我看来孙割更是一种典型，为了一件事可以不顾一切坚持下去，我总认为我运气不好，做的事情没有好的结果，不过细想一下，还是没有真正的认真，也许只是做了五分工而已。

做从未来看正确的事

勇气和格局是成功必备的前置条件

如果一个企业家见过了比尔盖茨马斯克，将不再满足于仅仅是一个县里的优秀企业家。配得感十分重要，有些人会觉得自己不配，或者下意识认为不配。人人生而平等，都是两条胳膊两条腿，没有什么不同，出生所带来的便利不是把人分类分级的理由

关注增量而非存量

目光不只局限于眼下的利益，长期投入即使亏损，如果能够换来未来更大回报，那它就是值得的。

ALL IN 一个波澜壮阔的事业

互联网开启了一个新的时代，人与人的联系变得前所未有便捷。同时也开启了一个虚拟的平行空间。

当要决定做一番大事业时，一定要有 ALL IN 的决心

ALL IN，不是没有退路，也不是盲目冲动，要对未来有敏锐的判断力和感受，有七八成把握，并且要相信自己的判断。尤其是当转行，创业，从零开始的时候。

嘉立创筑基派FreeRTOS 点灯demo

Thu, 02 Apr 2026 14:48:50 GMT

实验教程：FreeRTOS 多任务基础与 GPIO 控制

0. 实验概述

本实验是嵌入式实时操作系统 (RTOS) 的入门必修课。通过构建两个不同优先级的任务，控制两颗 LED 以不同频率闪烁，直观地展示 FreeRTOS 的多任务调度、优先级抢占以及时间管理机制。

学习目标

理解 FreeRTOS 中“任务 (Task)“的概念及其与裸机 while(1) 的区别。

掌握使用 STM32CubeMX 配置 FreeRTOS 任务的方法。

深入理解 osThreadNew 创建任务时各参数的含义。

学会分析不同优先级任务的调度行为。

1. 预备知识

1.1 什么是 FreeRTOS 任务？

在裸机程序中，我们通常在一个死循环 while(1) 中顺序执行代码。而在 RTOS 中，程序被拆分为多个独立的“任务”。每个任务看起来像是在独占 CPU，但实际上操作系统内核（Scheduler）会根据优先级和时间片快速切换任务，实现宏观上的“并行”。

1.2 硬件基础

主控: STM32F407 (Cortex-M4)
LED 连接:
- LED1 -> PB2 (推挽输出)
- LED2 -> PB8 (推挽输出)
时钟: 系统主频 168MHz，SysTick 或 TIM14 提供心跳节拍。

2. 原理解析

2.1 任务优先级与调度

本实验创建了兩個任务：

Task PB2: 优先级 Normal (较高)
Task PB8: 优先级 Low (较低)

调度规则： FreeRTOS 采用基于优先级的抢占式调度。

当高优先级任务就绪时，CPU 会立即执行高优先级任务。
只有当高优先级任务进入阻塞状态（如调用 osDelay）时，低优先级任务才有机会运行。
在本实验中，两个任务大部分时间都在 osDelay 阻塞中，因此它们会交替运行，互不干扰。

2.2 时间延迟 (`osDelay`)

osDelay(1000)：表示任务挂起 1000 个系统节拍（Tick）。
假设系统节拍频率为 1000Hz (1ms)，则延迟时间为 1 秒。
关键点：在延迟期间，该任务不占用 CPU 资源，CPU 可以去执行其他就绪的低优先级任务。这是多任务高效运行的核心。

3. 代码深度解析

以下基于 Core/Src/main.c 进行教学拆解。

3.1 任务属性定义

在 main.c 全局变量区，定义了任务的“身份证”

嘉立创筑基派FreeRTOS编码器+PWM+LED

Thu, 02 Apr 2026 14:48:50 GMT

EC11 编码器控制 LED 亮度项目

1. 项目概述

本项目基于 STM32F407 微控制器和 FreeRTOS 操作系统，实现了使用 EC11 编码器控制 LED 亮度的功能。项目通过三个任务（线程）协同工作，实现了无阻塞的编码器读取、按键检测和 LED 亮度控制。

2. 技术框架

2.1 硬件平台

微控制器：STM32F407
编码器：EC11 旋转编码器（连接到 PD12 和 PD13）
按键：PC13（编码器自带的按下功能）
LED：PB8（通过 PWM 控制亮度）
定时器：TIM10（用于 PWM 输出）

2.2 软件架构

开发环境：STM32CubeMX + VScode
操作系统：FreeRTOS
库函数：STM32 HAL 库
代码结构：标准 STM32 HAL 项目结构 + FreeRTOS 任务管理

3. 代码结构分析

3.1 头文件和包含部分

#include "main.h"
#include "cmsis_os.h"

包含了主头文件和 CMSIS-OS 头文件，其中定义了 STM32 HAL 库的基本配置和 FreeRTOS 的相关函数。

3.2 全局变量定义

/* USER CODE BEGIN PV */
uint8_t led_enabled = 1;
uint16_t pwm_duty = 0;
const uint16_t pwm_arr = 65535;
const uint16_t pwm_step = 1000;
/* USER CODE END PV */

led_enabled：LED 使能状态（1=开启，0=关闭）
pwm_duty：PWM 占空比（0-65535）
pwm_arr：PWM 自动重载值（定时器周期）
pwm_step：每次旋转编码器的 PWM 变化步长

3.3 任务句柄定义

/* USER CODE BEGIN EV */
osThreadId_t EncoderTaskHandle;
osThreadId_t KEYTaskHandle;
osThreadId_t LEDTaskHandle;
/* USER CODE END EV */

定义了三个任务的句柄，用于任务管理。

3.4 任务函数原型

/* USER CODE BEGIN FunctionPrototypes */
void EncoderTask(void *argument);
void KEYTask(void *argument);
void LEDTask(void *argument);
/* USER CODE END FunctionPrototypes */

3.5 编码器状态表

const int8_t enc_table[16] = {
    0, -1,  1,  0,
    1,  0,  0, -1,
   -1,  0,  0,  1,
    0,  1, -1,  0
};

编码器旋转方向检测的状态表，用于查表法计算旋转方向。

4. 主要功能实现

4.1 主函数

int main(void)
{
  /* 系统初始化 */
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_TIM10_Init();
  MX_FREERTOS_Init();

  /* 启动PWM输出 */
  if (HAL_TIM_PWM_Start(&htim10, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }

  /* 启动任务调度器 */
  osKernelStart();

  /* 永远不会执行到这里 */
  while (1)
  {
  }
}

主函数首先进行系统初始化，然后配置 GPIO、TIM10 定时器和 FreeRTOS，启动 PWM 输出和任务调度器。

4.2 任务初始化

void MX_FREERTOS_Init(void)
{
  /* 创建任务 */
  EncoderTaskHandle = osThreadNew(EncoderTask, NULL, &EncoderTask_attributes);
  KEYTaskHandle = osThreadNew(KEYTask, NULL, &KEYTask_attributes);
  LEDTaskHandle = osThreadNew(LEDTask, NULL, &LEDTask_attributes);
}

使用osThreadNew函数创建三个任务，并设置任务属性。

4.3 Encoder 任务

void EncoderTask(void *argument)
{
  static uint8_t enc_last = 0;
  uint8_t enc_current;
  int8_t enc_dir;

  for (;;)
  {
    /* 读取编码器状态 */
    enc_current = ((GPIOE->IDR & GPIO_PIN_12) >> 12) | ((GPIOE->IDR & GPIO_PIN_13) >> 12);
    
    /* 计算旋转方向 */
    enc_dir = enc_table[(enc_last << 2) | enc_current];
    enc_last = enc_current;
    
    /* 根据方向调整PWM占空比 */
    if (enc_dir > 0 && pwm_duty < pwm_arr)
    {
      pwm_duty += pwm_step;
      if (pwm_duty > pwm_arr) pwm_duty = pwm_arr;
    }
    else if (enc_dir < 0 && pwm_duty > 0)
    {
      pwm_duty -= pwm_step;
      if (pwm_duty > pwm_arr) pwm_duty = 0; // 防止溢出
    }
    
    osDelay(10);
  }
}

Encoder 任务使用查表法检测编码器旋转方向，并根据方向调整 PWM 占空比。

4.4 KEY 任务

void KEYTask(void *argument)
{
  static uint8_t key_state = 0;
  static uint32_t key_time = 0;

  for (;;)
  {
    /* 按键防抖处理 */
    if (HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_13) == GPIO_PIN_RESET)
    {
      if (key_state == 0)
      {
        key_state = 1;
        key_time = osKernelGetTickCount();
      }
      else if (key_state == 1)
      {
        if (osKernelGetTickCount() - key_time > 50)
        {
          key_state = 2;
          /* 切换LED使能状态 */
          led_enabled = !led_enabled;
        }
      }
    }
    else
    {
      key_state = 0;
    }
    
    osDelay(10);
  }
}

KEY 任务实现了按键的防抖处理，当检测到按键按下时，切换 LED 的使能状态。

4.5 LED 任务

void LEDTask(void *argument)
{
  for (;;)
  {
    /* 根据PWM占空比和LED使能状态控制LED亮度 */
    uint16_t out = led_enabled ? (uint16_t)(pwm_arr - pwm_duty) : pwm_arr;
    __HAL_TIM_SET_COMPARE(&htim10, TIM_CHANNEL_1, out);
    
    osDelay(50);
  }
}

LED 任务通过 TIM10 的 PWM 输出控制 LED 亮度。由于 PB8 是低电平有效，所以需要将 PWM 占空比取反。

4.6 TIM10 定时器初始化

static void MX_TIM10_Init(void)
{
  TIM_OC_InitTypeDef sConfigOC = {0};

  htim10.Instance = TIM10;
  htim10.Init.Prescaler = 0;
  htim10.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim10.Init.Period = 65535;
  htim10.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim10.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim10) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_PWM_Init(&htim10) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.OCMode = TIM_OCMODE_PWM1;
  sConfigOC.Pulse = 0;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  if (HAL_TIM_PWM_ConfigChannel(&htim10, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  HAL_TIM_MspPostInit(&htim10);
}

TIM10 定时器初始化函数配置了定时器的基本参数和 PWM 输出通道。

4.7 GPIO 初始化

static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /* 配置PC13为输入 */
  GPIO_InitStruct.Pin = GPIO_PIN_13;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  /* 配置PD12和PD13为输入 */
  GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
}

GPIO 初始化函数配置了按键和编码器的输入引脚。

5. 技术细节

5.1 编码器工作原理

EC11 编码器是一种旋转式位置传感器，通过两个输出信号（A 相和 B 相）的相位差来检测旋转方向。当编码器顺时针旋转时，A 相领先 B 相；当编码器逆时针旋转时，B 相领先 A 相。

本项目使用查表法检测旋转方向，通过读取 A 相和 B 相的状态，计算出当前状态码，然后根据上一次的状态码和当前状态码查表得到旋转方向。

5.2 PWM 控制原理

PWM（脉冲宽度调制）是一种通过改变脉冲宽度来控制信号的技术。在 LED 控制中，PWM 的占空比（高电平时间与整个周期的比值）决定了 LED 的平均亮度。占空比越高，LED 越亮；占空比越低，LED 越暗。

本项目使用 TIM10 定时器生成 PWM 信号，定时器时钟为 84MHz（APB2 总线时钟），预分频器为 0，自动重装载值为 65535，因此 PWM 频率为：

PWM频率 = 定时器时钟 / (预分频器+1) / (自动重装载值+1) = 84MHz / 1 / 65536 ≈ 1281Hz

5.3 FreeRTOS 任务管理

FreeRTOS 是一个开源的实时操作系统，提供了任务管理、队列、信号量等功能。本项目使用 FreeRTOS 的任务管理功能，创建了三个任务：

Encoder 任务：优先级正常，负责读取编码器状态并计算旋转方向
KEY 任务：优先级低，负责检测按键状态
LED 任务：优先级低，负责控制 LED 亮度

任务调度器根据任务优先级和状态，决定哪个任务获得 CPU 控制权。

5.4 按键防抖处理

按键在按下和释放时会产生机械抖动，导致多次触发。本项目实现了软件防抖，通过检测按键状态的持续时间来判断按键是否真正被按下。当按键状态持续 50ms 以上时，才认为按键被按下。

5.5 任务间通信

当前项目使用全局变量进行任务间通信，Encoder 任务更新pwm_duty变量，KEY 任务更新led_enabled变量，LED 任务读取这些变量并控制 LED 亮度。

6. 工作流程

系统初始化：
- 配置系统时钟
- 初始化 GPIO
- 初始化 TIM10 定时器
- 初始化 FreeRTOS
任务创建：
- 创建 Encoder 任务
- 创建 KEY 任务
- 创建 LED 任务
任务执行：
- Encoder 任务：
  - 读取编码器状态
  - 计算旋转方向
  - 根据方向调整 PWM 占空比
- KEY 任务：
  - 检测按键状态（带防抖）
  - 当按键按下时，切换 LED 使能状态
- LED 任务：
  - 根据 PWM 占空比和 LED 使能状态控制 LED 亮度

7. 代码优化建议

7.1 使用队列替代全局变量

当前代码使用全局变量传递数据，建议使用 FreeRTOS 的队列进行任务间通信，提高代码的可靠性和可维护性。例如：

// 创建队列
osMessageQueueId_t pwmQueue = osMessageQueueNew(1, sizeof(uint16_t), NULL);

// 发送消息
osMessageQueuePut(pwmQueue, &pwm_duty, 0, 0);

// 接收消息
osMessageQueueGet(pwmQueue, &pwm_duty, NULL, 0);

7.2 增加参数配置

可以将 PWM 的步长、按键防抖时间等参数定义为可配置的宏，方便调整：

#define PWM_STEP        1000    // PWM变化步长
#define KEY_DEBOUNCE_MS 50      // 按键防抖时间
#define ENCODER_DELAY   10      // 编码器检测延迟
#define LED_UPDATE_DELAY 50     // LED更新延迟

7.3 增加错误处理

在关键操作处增加错误处理，提高系统的稳定性：

if (HAL_TIM_PWM_Start(&htim10, TIM_CHANNEL_1) != HAL_OK)
{
  Error_Handler();
}

7.4 优化任务优先级

根据实际需求调整任务优先级，确保关键任务能够及时响应：

Encoder 任务：优先级较高，确保及时响应编码器输入
KEY 任务：优先级中等
LED 任务：优先级较低，因为亮度更新不需要实时响应

7.5 增加状态指示

可以增加 LED 状态指示，例如当 LED 开启时，使用另一个 LED 指示状态：

if (led_enabled)
{
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9, GPIO_PIN_SET);
}
else
{
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9, GPIO_PIN_RESET);
}

8. 测试方法

基本功能测试：
- 旋转编码器，观察 LED 亮度变化
- 按下编码器的按键，观察 LED 的开关状态
性能测试：
- 快速旋转编码器，测试系统的响应速度
- 多次按下按键，测试防抖功能
边界测试：
- 旋转编码器到最小亮度，测试是否能正确停止
- 旋转编码器到最大亮度，测试是否能正确停止
稳定性测试：
- 长时间运行，测试系统的稳定性
- 重复操作，测试系统的可靠性

9. 项目结构

FreeRTOS\F02_Encoder_PWM_LED_1\
├── Core\
│   ├── Inc\
│   │   ├── main.h
│   │   └── stm32f4xx_hal_conf.h
│   └── Src\
│       ├── main.c
│       ├── stm32f4xx_hal_msp.c
│       ├── stm32f4xx_it.c
│       └── sysmem.c
├── Drivers\
│   ├── CMSIS\
│   │   ├── Device\
│   │   └── Include\
│   └── STM32F4xx_HAL_Driver\
│       ├── Inc\
│       └── Src\
├── FreeRTOS\
│   ├── CMSIS_RTOS_V2\
│   └── Source\
└── README.md

10. 技术要点

FreeRTOS 任务创建与管理：使用osThreadNew创建任务，设置任务优先级和栈大小。
编码器读取算法：使用查表法实现编码器旋转方向的检测，提高检测速度和准确性。
PWM 控制：使用 TIM10 的 PWM 模式控制 LED 亮度，实现平滑的亮度调节。
按键防抖：实现软件防抖，提高按键检测的可靠性。
任务间通信：当前使用全局变量，建议使用队列进行任务间通信。
STM32 HAL 库使用：使用 HAL 库函数配置 GPIO、定时器等外设。
代码规范：遵循 STM32 HAL 库的代码规范和注释风格。

11. 项目特点

模块化设计：将功能分为三个独立的任务，便于维护和扩展。
实时响应：使用 FreeRTOS 实现实时任务调度，确保编码器输入和按键操作能够及时响应。
平滑控制：通过 PWM 技术实现 LED 亮度的平滑调节，避免亮度突变。
可靠性：实现了按键防抖，提高了系统的可靠性。
可扩展性：代码结构清晰，便于添加新的功能或修改现有功能。

12. 应用场景

本项目实现的 EC11 编码器控制 LED 亮度技术可以应用于多种场景：

照明控制：调节室内灯光亮度
设备参数调节：调节设备的各种参数，如音量、速度等
仪表盘控制：控制仪表盘的显示亮度
智能家居：调节智能灯具的亮度
工业控制：调节设备的输出功率

13. 总结

本项目成功实现了使用 EC11 编码器控制 LED 亮度的功能，通过 FreeRTOS 的任务管理实现了无阻塞的操作。项目结构清晰，代码简洁，功能完整，可以作为学习 FreeRTOS 和 STM32 PWM 控制的参考示例。

通过本项目的学习，可以掌握以下技术：

STM32 微控制器的 GPIO 和定时器配置
FreeRTOS 任务创建和管理
编码器读取和旋转方向检测
PWM 控制技术
按键防抖处理
任务间通信方法

这些技术在嵌入式系统开发中非常实用，可以应用于各种需要用户输入和输出控制的场景。

嘉立创筑基派PWM_LED_demo

Thu, 02 Apr 2026 14:38:52 GMT

PWM LED 控制项目文档

1. 项目概述

本项目是一个基于 STM32F407 微控制器的 LED 亮度控制示例，通过 PWM(脉冲宽度调制)技术实现 LED 亮度的动态调节。项目采用 STM32 HAL 库开发，使用 TIM10 定时器生成 PWM 信号，通过改变占空比来控制 LED 的亮度，并实现 LED 呼吸灯效果。

2. 技术框架

2.1 硬件平台

微控制器: STM32F407
定时器: TIM10
PWM 输出引脚: TIM10_CH1

2.2 软件架构

开发环境: STM32CubeMX + VScode
库函数: STM32 HAL 库
代码结构: 标准 STM32 HAL 项目结构

3. 代码结构分析

3.1 头文件和包含部分

#include "main.h"

包含了主头文件，其中定义了 STM32 HAL 库的基本配置和函数声明。

3.2 变量定义

TIM_HandleTypeDef htim10;

定义了 TIM10 定时器的句柄，用于定时器操作。

3.3 常量定义

static const uint16_t LED_PWM_DUTY_MAX = 60000U;   // PWM最大占空比值
static const uint16_t LED_PWM_DUTY_MIN = 0U;       // PWM最小占空比值
static const uint16_t LED_FADE_STEPS = 70U;        // 呼吸灯渐变步数
static const uint32_t LED_FADE_STEP_MS = 8U;        // 每步延迟时间(毫秒)
static const uint32_t LED_PEAK_HOLD_MS = 160U;     // 最亮保持时间(毫秒)
static const uint32_t LED_VALLEY_HOLD_MS = 120U;   // 最暗保持时间(毫秒)

这些常量定义了 LED 呼吸灯效果的各种参数，包括 PWM 占空比范围、渐变步数和时间参数。

3.4 函数原型

void SystemClock_Config(void);              // 系统时钟配置
static void MX_GPIO_Init(void);             // GPIO初始化
static void MX_TIM10_Init(void);            // TIM10定时器初始化
static void LED_SetBrightness(uint16_t duty);      // 设置LED亮度
static void LED_GentleFade(uint16_t start_duty, uint16_t end_duty);  // LED渐变效果

4. 主要功能实现

4.1 主函数

int main(void)
{
  // 系统初始化
  HAL_Init();
  SystemClock_Config();

  // 外设初始化
  MX_GPIO_Init();
  MX_TIM10_Init();

  // 启动PWM输出
  if (HAL_TIM_PWM_Start(&htim10, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  LED_SetBrightness(LED_PWM_DUTY_MIN);

  // 主循环
  while (1)
  {
    LED_GentleFade(LED_PWM_DUTY_MIN, LED_PWM_DUTY_MAX);
    HAL_Delay(LED_PEAK_HOLD_MS);
    LED_GentleFade(LED_PWM_DUTY_MAX, LED_PWM_DUTY_MIN);
    HAL_Delay(LED_VALLEY_HOLD_MS);
  }
}

主函数首先进行系统初始化，然后配置 GPIO 和 TIM10 定时器，启动 PWM 输出。在主循环中，通过 LED_GentleFade 函数实现 LED 亮度的渐变效果，形成呼吸灯模式。

4.2 系统时钟配置

void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  // 配置主内部稳压器输出电压
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

  // 初始化RCC振荡器
  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 = 4;
  RCC_OscInitStruct.PLL.PLLN = 168;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 4;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  // 初始化CPU、AHB和APB总线时钟
  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_DIV4;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;

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

系统时钟配置函数使用 HSE(外部高速时钟)作为 PLL 时钟源，通过 PLL 倍频生成 168MHz 的系统时钟。配置了 CPU、AHB 和 APB 总线的时钟分频系数，实现了整个系统的时钟分配。

4.3 TIM10 定时器初始化

static void MX_TIM10_Init(void)
{
  TIM_OC_InitTypeDef sConfigOC = {0};

  htim10.Instance = TIM10;
  htim10.Init.Prescaler = 0;
  htim10.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim10.Init.Period = 65535;
  htim10.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim10.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim10) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_PWM_Init(&htim10) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.OCMode = TIM_OCMODE_PWM1;
  sConfigOC.Pulse = LED_PWM_DUTY_MAX;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  if (HAL_TIM_PWM_ConfigChannel(&htim10, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  HAL_TIM_MspPostInit(&htim10);
}

TIM10 定时器初始化函数配置了定时器的基本参数和 PWM 输出通道。关键参数包括：

预分频器(Prescaler): 0
计数模式: 向上计数
自动重装载值(Period): 65535
PWM 模式: PWM1 模式
输出极性: 高电平有效

4.4 GPIO 初始化

static void MX_GPIO_Init(void)
{
  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
}

GPIO 初始化函数使能了 GPIO 端口时钟，为 PWM 输出引脚提供时钟支持。

4.5 LED 亮度设置函数

static void LED_SetBrightness(uint16_t duty)
{
  __HAL_TIM_SET_COMPARE(&htim10, TIM_CHANNEL_1, duty);
}

LED_SetBrightness 函数通过设置 TIM10 通道 1 的比较寄存器(CCR)值来改变 PWM 占空比，从而控制 LED 亮度。占空比越大，LED 越亮；占空比越小，LED 越暗。

4.6 LED 渐变效果函数

static void LED_GentleFade(uint16_t start_duty, uint16_t end_duty)
{
  const int32_t delta = (int32_t)end_duty - start_duty;

  for (uint16_t step = 0; step <= LED_FADE_STEPS; ++step)
  {
    const uint16_t duty = (uint16_t)(start_duty + (delta * step) / LED_FADE_STEPS);
    LED_SetBrightness(duty);
    HAL_Delay(LED_FADE_STEP_MS);
  }
}

LED_GentleFade 函数实现了 LED 亮度的平滑渐变效果。它从起始占空比值开始，逐步改变到目标占空比值，每步之间有短暂的延迟。通过调整 LED_FADE_STEPS 和 LED_FADE_STEP_MS 参数，可以改变渐变的速度和平滑度。

4.7 错误处理函数

void Error_Handler(void)
{
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
}

错误处理函数在发生错误时被调用，它会禁用中断并进入无限循环，防止系统继续运行。

5. 技术细节

5.1 PWM 原理

PWM(Pulse Width Modulation，脉冲宽度调制)是一种通过改变脉冲宽度来控制信号的技术。在 LED 控制中，PWM 的占空比(高电平时间与整个周期的比值)决定了 LED 的平均亮度。占空比越高，LED 越亮；占空比越低，LED 越暗。

5.2 TIM10 定时器配置

TIM10 是 STM32F407 上的一个 16 位定时器，具有以下特点：

16 位自动重装载计数器
多达 4 个独立通道(IC、OC 或 PWM)
可编程预分频器
重复计数器

在本项目中，TIM10 配置为 PWM 模式，使用通道 1 输出 PWM 信号。定时器时钟为 84MHz(APB2 总线时钟)，预分频器为 0，自动重装载值为 65535，因此 PWM 频率为： PWM 频率 = 定时器时钟 / (预分频器+1) / (自动重装载值+1) = 84MHz / 1 / 65536 ≈ 1281Hz

5.3 呼吸灯效果实现

呼吸灯效果是通过 LED_GentleFade 函数实现的，它将 LED 亮度从最小值渐变到最大值，再从最大值渐变回最小值。渐变过程分为多个步骤，每步之间有短暂的延迟，形成平滑的亮度变化效果。

渐变步数和每步延迟时间决定了呼吸灯的速度和平滑度。步数越多，每步延迟时间越长，呼吸灯效果越平滑但速度越慢；反之则效果越明显但速度越快。

5.4 STM32 HAL 库使用

本项目使用 STM32 HAL 库进行开发，HAL 库提供了丰富的函数和结构体，简化了外设的配置和使用。例如：

HAL_Init(): 初始化 HAL 库
HAL_RCC_OscConfig(): 配置系统时钟源
HAL_RCC_ClockConfig(): 配置系统时钟
HAL_TIM_Base_Init(): 初始化定时器基本功能
HAL_TIM_PWM_Init(): 初始化定时器 PWM 功能
HAL_TIM_PWM_Start(): 启动 PWM 输出
__HAL_TIM_SET_COMPARE(): 设置定时器比较值

5.5 代码结构和注释规范

本项目遵循 STM32CubeMX 生成的代码结构，使用特定的注释标记用户代码区域，如：

/* USER CODE BEGIN Header / 和 / USER CODE END Header */
/* USER CODE BEGIN Includes / 和 / USER CODE END Includes */
/* USER CODE BEGIN 2 / 和 / USER CODE END 2 */
/* USER CODE BEGIN 3 / 和 / USER CODE END 3 */
/* USER CODE BEGIN 4 / 和 / USER CODE END 4 */

这种结构使得在重新生成代码时，用户代码不会被覆盖，提高了代码的可维护性。

6. 项目特点

模块化设计: 将 LED 控制功能封装为独立函数，便于维护和扩展。
参数化配置: 使用常量定义呼吸灯效果参数，便于调整。
错误处理: 实现了基本的错误处理机制。
代码规范: 遵循 STM32 HAL 库的代码规范和注释风格。
可扩展性: 代码结构清晰，便于添加新的功能或修改现有功能。

7. 应用场景

本项目实现的 PWM LED 控制技术可以应用于多种场景：

LED 照明控制
指示灯亮度调节
装饰灯效果
背光亮度调节
信号灯控制

8. 总结

本项目展示了如何使用 STM32F407 的定时器 PWM 功能实现 LED 亮度控制和呼吸灯效果。通过合理配置定时器参数和编写控制函数，实现了 LED 亮度的平滑调节。代码结构清晰，遵循 STM32 HAL 库的规范，具有良好的可维护性和可扩展性。该示例可以作为学习 STM32 定时器 PWM 功能和 LED 控制技术的参考。

整形溢出_IntegerOverflow

Thu, 02 Apr 2026 13:02:17 GMT

整数溢出 (Integer Overflow) 技术笔记

核心概念

整数溢出是指算术运算的结果超出了数据类型所能表示的数值范围。

无符号整数溢出：在 C/C++ 标准中是合法的，结果会发生回绕 (Wrap-around)，即从最大值跳变到最小值（或反之），导致逻辑错误。
有符号整数溢出：属于未定义行为 (Undefined Behavior)，可能导致程序崩溃、计算错误或安全漏洞。

示例类型范围：uint16_t (16 位无符号整数) 的取值范围为 0 ~ 65535 (216−12^{16} - 1216−1)。

典型场景分析：PWM 占空比渐变

在嵌入式开发中，计算两个无符号整数的差值（如 PWM 占空比的变化量）是常见场景。若处理不当，极易引发溢出。

❌ 错误做法：直接相减

当 end_duty < start_duty 时，无符号减法会导致向下溢出。

uint16_t start = 1000;
uint16_t end = 500;

// 错误做法
uint16_t delta1 = end - start; 
// 500 - 1000 = -500
// 但 uint16_t 不能存负数，会自动回绕：65536 - 500 = 65036（完全错误）

这就是典型的无符号整数溢出。

// 正确做法
int32_t delta2 = (int32_t)end - start; 
// 先把 end 强转为 32位有符号整数，运算结果也是有符号数
// 可以正常存储负数，结果 = -500（正确）

️ 常见防溢出技巧

1. 类型提升（Type Promotion）

// 加法溢出防护
uint16_t a = 60000, b = 60000;
uint32_t sum = (uint32_t)a + b;  // 提升到32位再相加
if (sum > 65535) {
    // 处理溢出
}

// 乘法溢出防护
uint16_t x = 1000, y = 1000;
uint32_t product = (uint32_t)x * y;  // 1,000,000 不会溢出32位

2. 预检查（Pre-check）

uint16_t add_with_check(uint16_t a, uint16_t b) {
    if (a > UINT16_MAX - b) {
        // 会溢出，返回最大值或报错
        return UINT16_MAX;
    }
    return a + b;
}

// 乘法预检查
uint16_t mul_with_check(uint16_t a, uint16_t b) {
    if (a != 0 && b > UINT16_MAX / a) {
        return UINT16_MAX;  // 溢出
    }
    return a * b;
}

3. 使用更大的中间类型

// 你的代码中的例子
const int32_t delta = (int32_t)end_duty - start_duty;

// 后续计算
uint16_t duty = (uint16_t)(start_duty + (delta * step) / LED_FADE_STEPS);
//                   ^^^^^ 最终转回 uint16_t
//                   delta * step 最大约 60000 * 70 = 4.2M < 2^31，安全

4. 饱和运算（Saturation）

uint16_t saturated_add(uint16_t a, uint16_t b) {
    uint32_t result = (uint32_t)a + b;
    return (result > UINT16_MAX) ? UINT16_MAX : (uint16_t)result;
}

// 用于PWM占空比限制
uint16_t duty = saturated_add(current_duty, increment);

5. 使用编译器内置溢出检查（GCC/Clang）

#include <stdint.h>

int32_t multiply_with_overflow_check(int32_t a, int32_t b) {
    int32_t result;
    if (__builtin_mul_overflow(a, b, &result)) {
        // 溢出发生了
        return INT32_MAX;
    }
    return result;
}

// 检查加法
int32_t add_with_overflow_check(int32_t a, int32_t b) {
    int32_t result;
    if (__builtin_add_overflow(a, b, &result)) {
        return INT32_MAX;
    }
    return result;
}

6. 定时器场景的特殊技巧

// 处理定时器计数器溢出（常见于编码器、输入捕获）
static uint16_t last_count = 0;
static uint16_t overflow_count = 0;

void timer_irq_handler(void) {
    uint16_t current_count = TIM2->CNT;
    
    // 检测向下溢出（递减计数）
    if (current_count > last_count) {
        overflow_count++;  // 处理溢出
    }
    
    // 计算实际32位计数值
    uint32_t real_count = (overflow_count << 16) | current_count;
    
    last_count = current_count;
}

你的代码中的完整防溢出分析

static void LED_GentleFade(uint16_t start_duty, uint16_t end_duty)
{
    const int32_t delta = (int32_t)end_duty - start_duty;  // ✅ 防止减法溢出
    
    for (uint16_t step = 0; step <= LED_FADE_STEPS; ++step)
    {
        // 危险计算：(delta * step) / LED_FADE_STEPS
        // delta 最大 60000, step 最大 70 → 乘积 4.2M
        // int32_t 最大 2.1B，所以安全
        const uint16_t duty = (uint16_t)(start_duty + (delta * step) / LED_FADE_STEPS);
        //            ^^^^^ 最终结果范围 0~60000，转回 uint16_t 安全
        
        LED_SetBrightness(duty);
        HAL_Delay(LED_FADE_STEP_MS);
    }
}

潜在风险（已避免）：

如果 LED_FADE_STEPS 改成 1000，delta * step 最大 60M，仍然安全
如果 LED_PWM_DUTY_MAX 改成 600000（超过 uint16_t），代码会出问题

最佳实践总结

场景	推荐技巧
减法可能导致负数	提升到有符号类型 `(int32_t)a - b`
两个小整数相加	提升到更大类型 `(uint32_t)a + b`
乘法可能溢出	预检查 `if (a > MAX / b)`
循环累加	使用更大类型累加，最后再截断
时间差值计算	使用无符号减法（利用回绕特性）配合溢出标志
PID/滤波计算	使用浮点或定点数并做饱和处理

实用工具宏

// 安全加法宏（饱和）
#define SAFE_ADD_U16(a, b) ((uint16_t)(((uint32_t)(a) + (b)) > UINT16_MAX ? UINT16_MAX : ((a) + (b))))

// 安全减法（带符号提升）
#define SAFE_SUB_U16(a, b) ((int32_t)(a) - (int32_t)(b))

// 检查加法是否溢出
#define ADD_OVERFLOW_U16(a, b) (((uint32_t)(a) + (b)) > UINT16_MAX)

// 使用示例
uint16_t pwm = 60000;
uint16_t inc = 10000;

if (ADD_OVERFLOW_U16(pwm, inc)) {
    pwm = UINT16_MAX;  // 饱和到最大值
} else {
    pwm += inc;
}

嘉立创筑基派点灯DEMO

Thu, 02 Apr 2026 02:56:51 GMT

嘉立创筑基派点灯 DEMO_1

FreeRTOS 基础概念与 API 入门（STM32 新手向）

Tue, 31 Mar 2026 04:00:00 GMT

FreeRTOS 基础概念与 API 入门（STM32 新手向）

目标：看完这份笔记，你可以独立搭出一个“2 任务 + 1 队列 + 1 信号量”的最小 FreeRTOS 工程。

1. 先建立整体认知

FreeRTOS 本质是一个内核，它帮你做三件事：

管理多个任务（Task）。
按优先级和时机调度任务运行。
提供任务间通信手段（队列、信号量、事件组等）。

你可以把它理解为“单片机上的微型操作系统内核”：

main() 里做硬件初始化。
创建任务。
启动调度器。
从此由内核接管 CPU 分配。

2. 任务运行状态（核心）

2.2 任务状态流（可视化）

stateDiagram-v2
    [*] --> Ready
    Ready --> Running: 获得CPU
    Running --> Blocked: 等待事件
    Blocked --> Ready: 事件发生
    Running --> Ready: 时间片用尽
    Running --> Suspended: 挂起
    Suspended --> Ready: 恢复

2.3 新手最容易混淆

Blocked 是“被动等待条件”，条件满足会自动回到 Ready。
Suspended 是“人为冻结”，不会自动恢复。

3. 关键概念：调度、Tick、临界区、堆与栈

3.1 优先级与抢占

FreeRTOS 通常是“高优先级优先运行”。
抢占开启时（configUSE_PREEMPTION=1），更高优先级就绪会打断低优先级任务。
同优先级是否时间片轮转取决于 configUSE_TIME_SLICING。

建议：

先把任务优先级分成 2~3 档，不要一开始全拉开。
高优先级只放“短、急、关键”任务。

3.2 Tick 与延时

Tick 是内核时基中断（例如 1ms 一次，取决于 configTICK_RATE_HZ）。
vTaskDelay() 的参数单位是 Tick，不是 ms。
推荐用 pdMS_TO_TICKS(ms) 做转换。

示例：

vTaskDelay(pdMS_TO_TICKS(500));

vTaskDelay() vs vTaskDelayUntil()：

vTaskDelay()：相对延时，循环中会累积漂移。
vTaskDelayUntil()：绝对周期，更适合周期任务。

3.3 临界区

用于保护共享资源，防止并发访问破坏数据。

任务上下文常用：

taskENTER_CRITICAL();
/* critical section */
taskEXIT_CRITICAL();

原则：

临界区要短。
临界区内不要做阻塞操作（如队列阻塞等待）。

3.4 空闲任务与 Tick Hook

空闲任务（Idle Task）在“无任务可运行”时执行。
可用 Idle Hook/Tick Hook 做轻量背景工作（必须非常短）。
不建议在 Hook 里写复杂逻辑。

3.5 堆与栈（必须分清）

栈（Stack）：每个任务独立，存函数局部变量/调用现场。
堆（Heap）：系统动态分配区，任务控制块、队列等常从堆申请。

常见问题：

任务栈太小 -> 栈溢出。
heap_x.c 选型不当或堆太小 -> 创建对象失败。

4. 核心 API 速查（原生 FreeRTOS）

说明：以下以原生 API 为主，CMSIS 对照见第 8 节。

4.1 任务管理

xTaskCreate()：创建任务。
vTaskDelete()：删除任务。
vTaskDelay()：相对延时。
vTaskDelayUntil()：固定周期延时。
vTaskSuspend() / vTaskResume()：挂起/恢复任务。

最小示例：

xTaskCreate(TaskA, "A", 256, NULL, 2, NULL);
xTaskCreate(TaskB, "B", 256, NULL, 1, NULL);
vTaskStartScheduler();

4.2 队列（Queue）

用途：任务间传数据（最常用）。

xQueueCreate(len, item_size)
xQueueSend() / xQueueReceive()

示例：

QueueHandle_t q = xQueueCreate(8, sizeof(uint32_t));
uint32_t v = 123;
xQueueSend(q, &v, pdMS_TO_TICKS(10));
xQueueReceive(q, &v, portMAX_DELAY);

注意：

item_size 要和收发数据类型一致。
发送接收的超时参数单位是 Tick。

4.3 信号量与互斥量

二值信号量：事件同步。
计数信号量：资源计数。
互斥量：共享资源互斥，带优先级继承。

常用 API：

xSemaphoreCreateBinary()
xSemaphoreCreateCounting()
xSemaphoreCreateMutex()
xSemaphoreTake() / xSemaphoreGive()

建议：

保护共享外设（如串口）优先用互斥量。
ISR 到任务同步常用二值信号量或任务通知。

4.4 事件组（Event Group）

用途：多个事件位组合判断（如“网络就绪 + 传感器就绪”）。

xEventGroupCreate()
xEventGroupSetBits()
xEventGroupWaitBits()

4.5 软件定时器（Software Timer）

用途：定时执行轻量回调。

xTimerCreate()
xTimerStart()
回调函数中避免耗时和阻塞。

4.6 中断协作（ISR 与任务）

规则：

ISR 里必须用 FromISR 版本 API。
可能触发任务切换时，调用 portYIELD_FROM_ISR()。

示例：

BaseType_t hpw = pdFALSE;
xQueueSendFromISR(q, &data, &hpw);
portYIELD_FROM_ISR(hpw);

中断优先级注意：

Cortex-M 下要确保可调用 FreeRTOS API 的中断优先级配置正确。
重点关注 configMAX_SYSCALL_INTERRUPT_PRIORITY。

5. 从 0 到 1 最小工程心智模型

5.1 `main()` 推荐顺序

时钟/中断分组初始化。
外设初始化（GPIO/UART 等）。
创建通信对象（Queue/Semaphore）。
创建任务。
vTaskStartScheduler() 启动调度器。

5.2 任务划分建议（新手版）

采集任务：读传感器，发队列。
处理任务：收队列，计算。
输出任务：串口/屏幕输出。

避免：

一个任务里什么都干。
多个任务同时直接操作同一外设且无互斥。

5.3 典型双任务流程（LED + 串口）

任务 A（LED）：500ms 翻转一次，证明调度在跑。
任务 B（UART）：每 1s 打印计数。
两任务优先级先设相同，确认稳定后再调优。

达标标准：

LED 按周期闪烁。
串口稳定打印，系统不死机、不乱序。

6. 新手高频坑与排查

6.1 栈溢出

现象：莫名 HardFault、随机死机。

排查：

开启栈溢出检测（configCHECK_FOR_STACK_OVERFLOW）。
增大可疑任务栈。
避免大数组放栈上，改静态或堆。

6.2 阻塞时间单位写错

把 Tick 当 ms 会导致节奏错乱。
统一使用 pdMS_TO_TICKS()。

6.3 ISR 调错 API

ISR 中误用 xQueueSend() 而不是 xQueueSendFromISR()。
结果可能是断言失败或异常行为。

6.4 队列长度或元素大小不匹配

队列元素定义和实际收发类型不一致会导致“看似能跑但数据错乱”。

6.5 死锁

任务 A 等 B 的锁，B 又等 A 的锁。
保持锁顺序一致，减少嵌套锁。

6.6 优先级反转

低优先级占互斥资源导致高优先级被间接阻塞。
共享资源优先用互斥量（有优先级继承）。

6.7 `printf` 风险

栈占用大、耗时长、重入性风险。
建议：
- 降低打印频率。
- 避免在 ISR 内打印。
- 关键路径用轻量日志。

7. 5 天入门练习清单

Day 1：跑通最小双任务

目标：LED 任务 + UART 任务并发运行。
验证：LED 稳定闪烁，串口 1s 输出一次。

Day 2：队列通信

目标：TaskA 发送计数到队列，TaskB 接收并打印。
验证：打印值连续且无丢失。

Day 3：信号量同步

目标：按键中断释放信号量，任务被唤醒处理。
验证：无按键时任务阻塞，按下后立即响应。

Day 4：软件定时器

目标：用软件定时器周期触发状态上报。
验证：回调按固定周期执行。

Day 5：ISR 到任务通知

目标：中断使用 FromISR API 唤醒任务。
验证：中断响应后任务快速运行，系统稳定。

8. 原生 API 与 CMSIS-RTOS v2 对照

仅列最常用映射，便于读不同教程时快速切换：

任务创建：xTaskCreate <-> osThreadNew
延时：vTaskDelay <-> osDelay
启动调度：vTaskStartScheduler <-> osKernelStart
队列发送/接收：xQueueSend/xQueueReceive <-> osMessageQueuePut/osMessageQueueGet
信号量获取/释放：xSemaphoreTake/xSemaphoreGive <-> osSemaphoreAcquire/osSemaphoreRelease

结论：

新手建议先掌握原生 FreeRTOS API，再看 CMSIS 封装。
两者思路一致，主要差在命名和包装层。

最后检查清单（写代码前看一遍）

Tick 与 ms 是否都用 pdMS_TO_TICKS() 统一转换？
ISR 是否全部使用 FromISR API？
共享外设是否有互斥保护？
各任务栈大小是否留有余量？
阻塞等待是否都设置了合理超时？

9. 可直接运行的最小工程模板（可复制到 STM32 工程）

下面示例是一个可直接拷贝到用户工程的最小 FreeRTOS 骨架：两个任务（LED、UART），一个队列和一个互斥量。注：外设初始化（UART/GPIO）请按你的 HAL/LL 实现替换。

/* 全局对象 */
QueueHandle_t g_queue;
SemaphoreHandle_t g_uartMutex;

void LedTask(void *pvParameters)
{
    (void) pvParameters;
    for (;;)
    {
        HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
        vTaskDelay(pdMS_TO_TICKS(500)); // Blocked 状态
    }
}

void UartTask(void *pvParameters)
{
    (void) pvParameters;
    uint32_t cnt = 0;
    char buf[64];

    for (;;)
    {
        if (xSemaphoreTake(g_uartMutex, pdMS_TO_TICKS(50)) == pdPASS)
        {
            int n = snprintf(buf, sizeof(buf), "cnt=%lu\r\n", (unsigned long)cnt++);
            HAL_UART_Transmit(&huart1, (uint8_t*)buf, n, HAL_MAX_DELAY);
            xSemaphoreGive(g_uartMutex);
        }
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

int main(void)
{
    HAL_Init();
    SystemClock_Config();
    MX_GPIO_Init();
    MX_USART1_UART_Init();

    g_queue = xQueueCreate(8, sizeof(uint32_t));
    g_uartMutex = xSemaphoreCreateMutex();

    if (g_queue == NULL || g_uartMutex == NULL)
    {
        Error_Handler();
    }

    xTaskCreate(LedTask, "LED", 128, NULL, 1, NULL);
    xTaskCreate(UartTask, "UART", 256, NULL, 1, NULL);

    vTaskStartScheduler(); // 不会返回，FreeRTOS 接管

    for (;;);
}

10. 常用 FreeRTOSConfig 宏与行为映射（快速参考）

configUSE_PREEMPTION = 1 : 启用抢占，优先级高的任务就绪会立即切换上 CPU。
configUSE_TIME_SLICING = 1 : 同优先级任务之间启用时间片轮转（若为 0 则同优先级可能不轮转）。
configTICK_RATE_HZ : tick 频率（例如 1000 -> 1 tick = 1 ms），影响 vTaskDelay 等。
configMINIMAL_STACK_SIZE : 默认任务最小栈大小，创建任务时要基于此合理估算。
configMAX_PRIORITIES : 允许的最大优先级数量。
configCHECK_FOR_STACK_OVERFLOW : 启用栈溢出检测（建议设 1 或 2 并实现 vApplicationStackOverflowHook）。
configUSE_MUTEXES : 使能互斥量（优先级继承），建议用于共享外设保护。
configMAX_SYSCALL_INTERRUPT_PRIORITY / Cortex-M 中断优先级配置：确保使用 FreeRTOS API 的中断优先级不高于此阈值。

在文档中应说明这些宏通常在 FreeRTOSConfig.h 中修改，并给出常见工程的推荐值或范围。

11. 常见错误写法与正确写法对照（训练式示例）

错误：在 ISR 中调用 xQueueSend()（会导致不可预测行为或断言）正确：在 ISR 中调用 xQueueSendFromISR() 并在需要时调用 portYIELD_FROM_ISR()。
错误：多个任务直接调用 HAL_UART_Transmit()（非线程安全，可能数据交错）正确：为串口创建一个互斥量，所有任务在发送前 xSemaphoreTake()，发送后 xSemaphoreGive()。
错误：队列创建时 item_size 与传入类型不匹配（例如 sizeof(uint32_t) 但传入结构体指针）正确：队列元素大小应与实际传入的数据类型完全一致，或发送指针并确保生命周期。
错误：在临界区中做阻塞调用（例如在 taskENTER_CRITICAL() 后调用 xQueueReceive(portMAX_DELAY)）正确：临界区内仅做短、小且非阻塞的操作，阻塞操作应在临界区外执行。

12. 调试与观测：如何判断栈/队列/调度问题

查看任务栈水位：uxTaskGetStackHighWaterMark() 可以返回任务已使用栈的最小剩余值（单位平台相关），用于评估是否需要增大栈。
实现钩子：实现 vApplicationStackOverflowHook() 与 vApplicationMallocFailedHook()，在发生问题时记录信息并安全重启或进入安全状态。
使用断言：启用 configASSERT()，并在断言回调中输出关键信息（例如当前任务名、寄存器快照）以便排查。
统计与事件：使用 vTaskList() / vTaskGetRunTimeStats()（如果配置启用 run-time stats）来观察任务运行情况与 CPU 占用。
故障注入：作为练习，有意识地缩小队列长度或把某任务栈设置偏小，观察系统表现并用以上工具定位问题。

参考快速清单（新增后）

可复制的最小工程模板见本节第 9 节。
常见错误与正确写法见第 11 节，调试方法见第 12 节。

STM32 GPIO 笔记

Wed, 25 Mar 2026 07:00:00 GMT

STM32 GPIO 笔记

CubeMX 中的 GPIO 配置选项

在 STM32CubeMX 中配置 GPIO 时，主要选项包括：

Pin Mode (引脚模式): 选择引脚的功能，如 Input (输入), Output (输出), Analog (模拟), Alternate Function (复用功能)。
GPIO output level (GPIO 输出电平): 设置初始输出电平，High (高) 或 Low (低)。
GPIO mode (GPIO 模式): 选择输出类型，Push-Pull (推挽) 或 Open-Drain (开漏)。
GPIO Pull-up/Pull-down (GPIO 上拉/下拉): No pull-up and no pull-down (无上拉下拉), Pull-up (上拉), Pull-down (下拉)。
Maximum output speed (最大输出速度): Low (低), Medium (中), High (高), Very High (很高)。
User Label (用户标签): 为引脚添加自定义名称，便于代码中引用。

GPIO 模式 (Modes)

GPIO 有多种模式，以下是中英文对照：

Input Floating (输入浮空): 引脚浮空输入，无内部上拉或下拉。
Input Pull-up (输入上拉): 引脚输入，上拉到 VCC。
Input Pull-down (输入下拉): 引脚输入，下拉到 GND。
Output Push-Pull (输出推挽): 输出模式，能驱动高低电平。
Output Open-Drain (输出开漏): 输出模式，只能拉低电平，需要外部上拉。
Alternate Function Push-Pull (复用推挽): 复用功能，如 UART、SPI 等，推挽输出。
Alternate Function Open-Drain (复用开漏): 复用功能，开漏输出。
Analog (模拟): 用于 ADC/DAC，无数字功能。

HAL 库函数用法

STM32 HAL 库提供了简化的 GPIO 操作函数：

HAL_GPIO_ReadPin(GPIOx, GPIO_PIN_x): 读取指定 GPIO 引脚的状态，返回 GPIO_PIN_SET 或 GPIO_PIN_RESET。
- 示例: if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_SET)
HAL_GPIO_WritePin(GPIOx, GPIO_PIN_x, GPIO_PIN_SET/RESET): 设置 GPIO 引脚的输出电平。
- 示例: HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, GPIO_PIN_SET);
HAL_GPIO_TogglePin(GPIOx, GPIO_PIN_x): 翻转 GPIO 引脚的输出电平。
- 示例: HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_2);

对照标准库 (Standard Peripheral Library)

HAL 库是对标准库的封装，提供了更易用的接口。以下是对照：

HAL_GPIO_ReadPin 对应标准库的 GPIO_ReadInputDataBit 或 GPIO_ReadOutputDataBit。
- 标准库: uint8_t GPIO_ReadInputDataBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);
HAL_GPIO_WritePin 对应标准库的 GPIO_SetBits 和 GPIO_ResetBits。
- 标准库: void GPIO_SetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);
- void GPIO_ResetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);
HAL_GPIO_TogglePin 在标准库中需要手动实现，或使用位操作。
- 标准库无直接对应，通常用: GPIOx->ODR ^= GPIO_Pin;

HAL 库更抽象，兼容性更好，而标准库更底层，效率更高但复杂。

GPIO 模式详细作用

Analog (模拟) 模式: 用于连接模拟外设，如 ADC (模数转换器) 或 DAC (数模转换器)。在该模式下，引脚不进行数字输入/输出，而是直接传递模拟信号到内部 ADC/DAC 模块，用于测量电压或输出模拟电压。常用于传感器输入或音频输出。
Alternate Function (复用功能) 模式: 允许 GPIO 引脚被其他外设复用，如 UART、SPI、I2C、PWM 等通信或定时器功能。此时，引脚不再作为通用 GPIO 使用，而是由相应外设控制，用于数据传输、时钟信号等。选择 Push-Pull 或 Open-Drain 取决于外设需求，例如 I2C 常使用 Open-Drain。

GPIO 省电

如果 IO 不使用,可以配置为模拟模式(analog mode),这样引脚就不会产生电流消耗,从而降低功耗。

JTAG/SWD 引脚注意事项

上电/复位早期 SWJ（SWD+JTAG）接口默认启用，相关管脚可能出现短暂跳变；不应在系统初始化前让这些引脚直接驱动敏感负载。

仅使用 SWD 时：可在初始化早期禁用 JTAG，释放额外管脚（如 JTDI/TDI、JTDO/TDO、JTMS/TMS、NJTRST）。释放后，这些引脚可以像普通 GPIO 一样配置为输入、输出或复用。
实务建议：在禁用/重映射前，先将这些引脚配置为输入并配合合适的上拉/下拉；完成释放后再统一设置目标模式和初始输出电平，避免上电瞬间的误动作。
Trace/ITM：若未使用串行调试输出（SWO/JTDO），建议保持禁用或配置为输入，避免外部误触发。

示例（F1 系）：

HAL：保留 SWD、禁用 JTAG：__HAL_AFIO_REMAP_SWJ_NOJTAG();；完全禁用 SWJ：__HAL_AFIO_REMAP_SWJ_DISABLE();
标准库：保留 SWD、禁用 JTAG：GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);；完全禁用 SWJ：GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable, ENABLE);

不同系列芯片的具体禁用/重映射方法可能不同，请参考该系列的参考手册与 HAL/LL 宏说明。

各系列差异简表

F1（STM32F1）
- 配置位置：AFIO 重映射。
- 保留 SWD、禁用 JTAG：__HAL_AFIO_REMAP_SWJ_NOJTAG();
  - 标准库：GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);
- 完全禁用 SWJ：__HAL_AFIO_REMAP_SWJ_DISABLE();
  - 标准库：GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable, ENABLE);
- 释放后：将 PA15/PB3/PB4 等按需配置为 GPIO 输入/输出/复用。
F4（STM32F4）
- 配置位置：CubeMX 中 System Core -> SYS -> Debug 选择；代码层无 AFIO 宏。
- 推荐：选择 Serial Wire（保留 SWD，释放 JTAG 仅用的管脚）；No Debug 会释放包括 PA13/PA14 在内的所有调试引脚，慎用。
- 常见管脚：SWDIO PA13、SWCLK PA14；JTAG 仅用：PA15 (JTDI)、PB3 (JTDO/SWO)、PB4 (NJTRST)。
- 释放后示例（适用于 F4/L4/H7，仅示意）：

// 在早期初始化阶段，将 JTAG 仅用的管脚设为安全模式（输入）或目标模式
GPIO_InitTypeDef GPIO_InitStruct = {0};
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();

GPIO_InitStruct.Mode = GPIO_MODE_INPUT;   // 或 GPIO_MODE_OUTPUT_PP 等
GPIO_InitStruct.Pull = GPIO_NOPULL;       // 视外部电路选择 PULLUP/PULLDOWN

GPIO_InitStruct.Pin = GPIO_PIN_15;        // PA15: JTDI（SWD 模式下可用作普通 GPIO）
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

GPIO_InitStruct.Pin = GPIO_PIN_3 | GPIO_PIN_4; // PB3: JTDO/SWO, PB4: NJTRST
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

L4（STM32L4）
- 配置位置与 F4 类似：通过 CubeMX SYS -> Debug 选择 SWD/JTAG/禁用。
- 管脚分配基本与 F4 一致（具体型号可能略有差异），SWD：PA13/PA14；JTAG 仅用：PA15/PB3/PB4。
- 若启用 Trace/ITM，PB3 (SWO) 会被占用；未使用时建议设为输入或禁用。
H7（STM32H7）
- 配置位置与 F4/L4 类似：CubeMX SYS -> Debug；部分双核器件（M7+M4）有独立调试端口，需按器件手册确认。
- 管脚：SWD 保留 PA13/PA14；JTAG 仅用常见 PA15/PB3/PB4；Trace/SWO 使用 PB3。
- 禁用或释放策略与 F4/L4 相同：未用 Trace 时保持 PB3 禁用或输入，避免误触发。

备注：以上管脚为常见映射，具体以器件数据手册/CubeMX 引脚视图为准；释放调试引脚会影响在线调试能力，请在量产或对引脚有严格需求时谨慎处理。

STM32 SPI 笔记

Wed, 25 Mar 2026 07:00:00 GMT

STM32 SPI 笔记

SPI 简介

SPI（Serial Peripheral Interface）是一种同步串行通信接口，由摩托罗拉公司提出。

特点

全双工通信
主从模式（Master/Slave）
同步时钟（SCK）
高速传输（可达数十 Mbps）

信号线

信号	全称	说明
SCK	Serial Clock	时钟信号，由主机产生
MOSI	Master Out Slave In	主机输出/从机输入
MISO	Master In Slave Out	主机输入/从机输出
NSS/CS	Chip Select	片选信号，低电平有效

2. STM32 SPI 工作模式

SPI 工作模式

模式	CPOL	CPHA	采样边沿
0	0	0	第一个上升沿
1	0	1	第一个下降沿
2	1	0	第二个上升沿
3	1	1	第二个下降沿

CPOL：时钟极性（空闲时电平）
CPHA：时钟相位（采样时刻）

HAL 库配置示例

初始化代码

// SPI 句柄定义
SPI_HandleTypeDef hspi1;

// SPI 初始化配置
void MX_SPI1_Init(void)
{
    hspi1.Instance = SPI1;
    hspi1.Init.Mode = SPI_MODE_MASTER;
    hspi1.Init.Direction = SPI_DIRECTION_2LINES;
    hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
    hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
    hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
    hspi1.Init.NSS = SPI_NSS_SOFT;
    hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
    hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
    hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
    hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    hspi1.Init.CRCPolynomial = 10;
    
    if (HAL_SPI_Init(&hspi1) != HAL_OK)
    {
        // 初始化错误处理
        Error_Handler();
    }
}

数据收发函数

// 单字节发送
HAL_SPI_Transmit(&hspi1, &txData, 1, HAL_MAX_DELAY);

// 单字节接收
HAL_SPI_Receive(&hspi1, &rxData, 1, HAL_MAX_DELAY);

// 全双工收发
HAL_SPI_TransmitReceive(&hspi1, txBuffer, rxBuffer, size, HAL_MAX_DELAY);

// 中断方式发送
HAL_SPI_Transmit_IT(&hspi1, txBuffer, size);

// DMA 方式发送
HAL_SPI_Transmit_DMA(&hspi1, txBuffer, size);

常见问题

问题	可能原因	解决方案
通信无数据	片选未拉低	检查 `NSS` 引脚配置
数据错位	时钟模式不匹配	确认主从 `CPOL/CPHA` 一致
速率过低	分频系数过大	调整 `BaudRatePrescaler`
接收数据固定	未先发送时钟	SPI 需先发数据产生时钟

// TODO :

补充示波器波形图
添加实际项目应用场景
记录调试过程中遇到的问题及解决方案

RUST in an hour

Wed, 25 Mar 2026 06:47:59 GMT

RUST in an hour

Delete element

The underscore is a special name - or rather, a “lack of name”. It basically means to throw away something:_

// this does *nothing* because 42 is a constant
let _ = 42;

// this calls `get_thing` but throws away its result
let _ = get_thing();

Tuples

the format of tuples is “(a,b,c…)” , the most usage are similar to tuples in Python:

let pair = ('a', 17);
pair.0; // this is 'a'
pair.1; // this is 17

//you can define their type

let pairs:(i32, i32,char) = (1,2,'a');

the content of tuples are static

Distructuring tuples

example:

let (x, y, z) = (1, 2, 3);

Statements

let x = vec![1, 2, 3, 4, 5, 6, 7, 8]
    .iter()
    .map(|x| x + 3)
    .fold(0, |x, y| x + y);

Declare function

R语言常用函数

Wed, 25 Mar 2026 06:17:26 GMT

Functionsk

runif

runif(n,min,max) n is the number.

sample

sample(x,n,replace) x is the range n is the number when n is bigger than the length of x, you should set replace = T.

x <- sample(2:10,100,replace = T)
# the length is bigger,use repalce = T

rnorm

dnorm(x, mean = 0, sd = 1, log = FALSE)
pnorm(q, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE)
qnorm(p, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE)
rnorm(n, mean = 0, sd = 1)

rnorm: normal distribution n: number mean: the center of the distribution sd: the range near the center

for example: rnorm(10,100,20) it means we select ten numbers between 80 and 120, the min is 100-20, max is 100+20.

set seed()

设定随机数种子，便于复现

hist() 频率直方图

hist receive a vector it will draw a histogram to show the frequency of the data

hist(x,freq = NULL, probability = !freq,
    right = TRUE,density = NULL, angle = 45, col = "lightgray",
    main = "Histogram of",
    xlim = range(breaks), ylim = NULL,
    xlab = xname,axes = TRUE, plot = TRUE, labels = FALSE,)

freq: if T, display every values frequency, default is T,show the frequency instead of the density.
probability: an alias for !freq, for S compatibility.
right: if the data equal to the right side of range, it will beongs to this rnage.
density: draw shading lines
angle: the angle of the density
col: the color of the histogram
main: the title of the histogram
xlim: the range of the x axis, when value = range(breaks),it will draw all the range of data, but if not, it will default to chose the range.
ylim: the range of the y axis
xlab: the label of the x axis
ylab: the label of the y axis
axes: if T, draw the x and y axis,default is T
labels: default is F, show the value of the data on the histogram

plot 散点图

plot function need two parameters as x,y , this function defualt draw points on the graph

plot(x, y = NULL, type = "p", xlim = NULL, ylim = NULL, log = "",
    main = NULL, sub = NULL, xlab = NULL, ylab = NULL,
    ann = par("ann"), axes = TRUE, frame.plot = axes, panel.first = NULL,
    panel.last = NULL, bty = "o", ...)

type: “p” for points, “l” for lines, “b” for both(lines and points), “c” for the lines part alone of “b”, “o” for both ‘overplotted’, “h” for ‘histogram’ like (or ‘high-density’) vertical lines, “s” for stair steps, “S” for other steps, see ‘Details’ below,
cex: size of the points
col: color
pch: the shape of the points,19 is full
xlim/ylim: xlim = c(min_x, max_x), decide the range of x/y
log: log”x”/“xy”: use log on x,y
main: tittle
sub: subtitle, down the pic
bty: the type of the frame, “o” is the default line, “l” is no frame, “c” means double line

text

用于给点或者决策树等添加文字

text(x, y, label, pos = 3, offset = 0.5， cex = 1.5, srt = 45)

label: the label vector
cex: size of the label, default is 1
pos: the position of the label
offset: the distance between the label and the point
srt: the angle of the label

qq 图（Quantile-Quantile Plot）

geom_qq qqplot qqnrom 这三个方式做出来类似

qqnorm(All$mark)
qqline(All$mark, col = 2)  # 添加一条理论正态分布的参考线，颜色设为红色

abline

abline(a = NULL, b = NULL, h = NULL, v = NULL, reg = NULL, coef = NULL,
    untf = FALSE, lty = 1, lwd = 1, col = "black", ...)

a,b: a*x+b
h,v: horizontal and vertical lines
reg: regression line
lty: line type
lwd: line width
col: colour

拟合示例：

   data <- data.frame(x = 1:10, y = 2 * (1:10) + rnorm(10))
   plot(data$x, data$y)  # 绘制数据点
   model <- lm(y ~ x, data)  # 对数据进行线性拟合
   abline(model, col = "blue")  # 添加拟合线

as.factor

usage: xxx <- as.factor(xxx) use: change vector to factor what is factor?

# 创建一个简单的因子
fruit <- c("apple", "banana", "apple", "orange", "banana", "apple")
fruit_factor <- factor(fruit)

# 显示因子结构
fruit_factor

# 指定水平和标签
fruit_factor_labeled <- factor(fruit, levels = c("apple", "banana", "orange"), 
                               labels = c("Apple", "Banana", "Orange"))
fruit_factor_labeled

summary

得到拟合模型的参数

colMeans

average_marks <- colMeans(df2, na.rm = TRUE)

colSums

sum_marks <- colSums(df2, na.rm = TRUE)

apply()

median_marks <- apply(df2, 2, median, na.rm = TRUE)
#计算中位数
row_sums <- apply(mat, 1, sum)
#计算矩阵每一行的和
max_marks <- apply(df2, 2, max, na.rm = TRUE)
min_marks <- apply(df2, 2, min, na.rm = TRUE)
#计算最大最小

tapply

a <- c(2, 4, 1, 7, 6, 8, 3, 4)
c <- c("A", "A", "B", "B", "A", "A", "B", "B")
result <- tapply(a, c, mean)

d <- c("X", "Y", "X", "Y", "X", "Y", "X", "Y")
result <- tapply(a, list(c, d), mean)

tapply(vector, index, FUN, ..., default = NA, simplify = TRUE)

in the first example, variable in c vector defines which group the variable in a vector belongs to. it will calculate the mean of each group such as A,B

rep

rep(x, times = NULL, each = NULL, length.out = NULL, along = NULL)
rep(1, times = 5) 
# 重复数字1，共5次

lm

线性模型（lm()）、广义线性模型（glm()）、混合效应模型（lme()）线性拟合 lm(y~x)

lme

glm

服从指数组分布

gam

cooks.distance

boxplot 箱线图

x 和 y：这是箱线图的基本数据，可以是向量、矩阵、数据框或列表。如果 x 是一个向量，那么 y 可以省略，此时 x 表示类别，y 表示对应的数值。
names.arg：如果 x 是一个向量，可以使用 names.arg 来提供类别名称。
main：设置图形的主标题。
xlab 和 ylab：分别设置 X 轴和 Y 轴的标签。
las：控制轴标签的方向，0 表示水平，1 表示垂直，2 表示旋转 45 度。
col 和 fill：设置箱线的颜色和填充色。
border：设置箱线边框的颜色。
outlier.col 和 outlier.pch：设置异常值的点颜色和形状。
horizontal：如果设为 TRUE，则绘制水平箱线图。
varwidth：如果设为 TRUE，箱线的宽度将根据数据的样本量变化，否则所有箱线宽度相同。
notch：如果设为 TRUE，箱线会有一个切口，表示 95%的置信区间，可用于比较中位数的显著性。
range：控制须的长度，通常默认为 1.5 倍的四分位距（IQR）。
par：可以传递图形参数，如 mar（边距）、 oma（外边距）等。怎么看箱线图，箱线图主要用于描述数据的分布情况，其关键元素包括：
箱子（Box）：表示数据的下四分位数（Q1）和上四分位数（Q3），也就是数据的中间 50%。
中位数线（Median Line）：位于箱子内部的线，表示数据的中位数。
须（Whiskers）：从箱子两端延伸出去的线，通常表示数据的最小值（不包括异常值）和最大值，但不超过 Q1 减去 1.5 倍 IQR 和 Q3 加上 1.5 倍 IQR。
异常值（Outliers）：落在须之外的数据点，表示远离主要数据集的值。

bwplot

AIC

fligner.test

检验方差齐性，得到 p-value，如果小于 0.05，拒绝原假设

shapiro.test

检验数据是否遵循正态分布，得到值大于 0.05，则认为遵循正态分布

cor.test

durbinWatsonTest

Durbin-Watson 统计量是一个在 0 到 4 之间的数，用于评估模型的残差序列是否具有自相关性。数值接近 2 通常表示残差之间没有明显的自相关，而远离 2 则可能表明存在自相关

dwtest()

dwtest(object, alternative = c("two.sided", "less", "greater"), lag.max = NULL)

输出将包括 Durbin-Watson 统计量、对应的 p 值和检验结论。如果 p 值大于显著性水平（通常为 0.05），则不能拒绝原假设，即残差没有自相关性。反之，如果 p 值小于显著性水平，则可能需要对模型进行调整，以消除残差的自相关性。

kruskal.test

aov

anova

par(mfrow=c(x,y),cor = (1,1,2,2))

mfrow 定义图的阵列 cor 定义上下左右边框

dotchart()

pairs()

panel.cor()

tree()

library(tree)
my_tree <- tree(response ~ ., data = dataset, control = tree.control(nnode = n))
plot(my_tree)
text(my_tree)

response: 分类或回归问题的响应变量，对于分类问题，它应该是一个因子；对于回归问题，它应该是一个数值向量。
.: 代表所有其他变量，即用所有的自变量来预测响应变量。
data: 包含响应变量和自变量的数据框。
control: 一个 tree.control 对象，用于设置构建决策树时的参数，如最大树深度 nnode 等。

参数检验

T 检验：

单样本 T 检验：检验一个样本的均值是否与已知总体均值有显著差异。独立样本 T 检验（两样本 T 检验）：比较两个独立样本的均值差异是否显著。配对样本 T 检验：比较配对数据（如同一对象处理前后的测量）的均值差异是否显著。 ANOVA（方差分析）：

一元方差分析：用于比较三个或以上独立样本的均值是否存在显著差异。多元方差分析（MANOVA）：当因变量不止一个时，用于同时分析多个因变量的均值差异。卡方检验（χ²检验）：

拟合优度检验：检验观察频数与期望频数之间是否存在显著差异。独立性检验：分析两个分类变量是否独立。同质性检验：检验多个样本的频率分布是否相同。 F 检验：

方差齐性检验：在进行 ANOVA 之前，检验各组方差是否相等。方差分析中的 F 检验：ANOVA 中用于确定组间差异是否显著。

interaction.plot

interaction.plot(x.factor = mydata$Age.Group, 
                 trace.factor = mydata$Gender, 
                 response = mydata$Salary, 
                 type = "b", 
                 col = c("red", "blue"), 
                 leg.legend = c("Female", "Male"))

x.factor：X 轴的因子变量，可以是一个因子变量或一个数值向量。
trace.factor：Y 轴的因子变量，可以是一个因子变量或一个数值向量。
response：响应变量，可以是一个数值向量。
data: 数据框
type: 类型

“l” 线型图
“b” 线型图和点型图
“p” 点型图
“o” 超越线图的点图。
“c” 直方图风格的线图
legend: 图例

groupedData()

处理重复测量数据

radarplot() 雷达图

radarchart/radarchartcirc(df, axistype, seg, pty, pcol, plty, plwd, pdensity, pangle, pfcol,cglty, cglwd, cglcol, axislabcol, title, maxmin, na.itp, centerzero, vlabels, vlcex, caxislabels, calcex, paxislabels, palcex, ...)

axislabcol: 轴标签的颜色。轴标签和数字的颜色，默认是”blue
axistype
，可以是 0 到 5 之间的数值。0 表示无轴标签，1 表示中心轴标签，2 表示围绕图表的轴标签，3 表示同时有中心和周边轴标签，4 是 1 的星号格式，5 是 3 的星号格式。默认是 0
seg: 分段数，决定轴上的分割数量。
pty: 多边形的类型（线型）,指定点符号的向量，默认是 16（闭合的圆圈）。如果不绘制数据点，应设置为 32。
pcol: 多边形边缘的颜色,绘制数据的颜色代码向量，默认是 1
，会重复使用
plty: 多边形边缘的线型。绘制数据的线型向量，默认是 1
，会重复使用
plwd: 多边形边缘的线宽。
pdensity: 可能用于控制点的密度，如果 pcol 用于点而不是线条。
pangle: 可能用于控制点的角度分布，如果 pcol 用于点。
pfcol: 多边形内部的填充颜色。pfcol = scales::alpha(“#00AFBB”, 0.5)；alpha() 函数的第二个参数是一个介于 0 和 1 之间的数值，表示颜色的透明度。0 表示完全透明，1 表示完全不透明。在这个例子中，0.5 表示半透明，所以最终的 pfcol 颜色是 50%透明的蓝色
cglty: 网格线的线型。雷达网格的线型，默认是 3（虚线）。对于 radarchartcirc()，默认是 1（实线）
cglwd: 网格线的线宽。雷达网格的线宽，默认是 1，表示最细的线宽
cglcol: 网格线的颜色。雷达网格的颜色，默认是”navy”
title: 图表的标题。maxmin: 可能用于控制最大最小值的显示。
na.itp: 如何处理 NA 值。
centerzero: 是否将图表中心设为 0。
vlabels: 变量的标签，通常对应数据框的列名。
vlcex: 变量标签的字体大小。
caxislabels: 轴刻度标签。
calcex: 刻度标签的字体大小。
paxislabels: 多边形轴的标签。
palcex: 多边形轴标签的字体大小。

legend 图例

legend(x, y, legend, fill = NULL, col = "black", bg = "white",
       lty = 1, lwd = 1, pch = 1, angle = 45, density = NULL, bty = "o",
       box.lwd = 1, box.col = "black", text.col = "black", 
       title = NULL, cex = 1, pt.bg = NA, pt.cex = 1, 
       xjust = 0, yjust = 1, xpd = NA, 
       ncol = 1, horiz = FALSE, title.adj = c(0.5, 0.5), ...)

STM32 定时器笔记

Tue, 30 Dec 2025 16:00:00 GMT

定时器

定时器基础知识

基础构成

时钟来源: 内部 APB 时钟/ETR 外部时钟/内部触发 ITR；定时器时钟频率 = 定时器输入时钟 ÷ (PSC+1)。
计数器 CNT: 16/32 位向上、向下或中心对齐计数模式；溢出或到达 ARR 触发更新事件。
预分频 PSC: 将输入时钟再分频，减少计数速度；更新事件才会装载新 PSC。
自动重装载 ARR: 计数上限或下限，决定周期；开启预装载时（ARPE）在更新事件同步装载。

关键模式

单脉冲模式(One Pulse): 响应一次触发产生有限脉冲，常用于测距等。
输出比较/定时输出: CCRx 与 CNT 比较，匹配时产生事件，可配置翻转/置位/清零。
PWM: 由 ARR 设周期，CCR 设占空比；上升沿/下降沿对齐或中心对齐可减小谐波。
输入捕获: 捕获外部边沿时间戳到 CCR，结合 PSC/ARR 可测频率或脉宽。
编码器模式: 两路正交输入解码位移/速度；选择 TI1/TI2 极性、滤波。
基础定时: 部分定时器（如 TIM6/7）仅生成更新事件驱动 DAC 或触发。

事件与中断/DMA

更新事件 UEV: CNT 到 ARR 或方向翻转时触发；可触发中断或 DMA，常用来做“心跳”。
触发输出 TRGO: 可配置为 UEV/OCxREF/OCxREF 清零，用于驱动 ADC、DAC、另一个定时器。
中断: 更新 UIE、捕获比较 CCxIE、触发 TIE、突破 BDTR 故障；注意在 NVIC 和寄存器同时开启。
DMA: 可把更新或捕获比较事件搬运 ARR/CCR 数据，适合连续波形更新。

输出相关细节

CCR 预装载: PWM 时建议开 OCxPE，避免更新窗口撕裂；在更新事件同步写入。
极性: 可配置 CHx 极性高/低，PWM 互补输出(CHxN)需高级定时器并设置死区时间 BDTR.DTG。
刹车/死区: 高级定时器支持刹车输入 BKIN、死区插入、输出使能 MOE，保障功率驱动安全。

输入滤波与时序

数字滤波: ICF 位可设采样次数与分频，滤除毛刺；过强滤波会增加响应延迟。
边沿选择: CCxP/CCxNP 选择上升/下降/双边沿；双边沿测频时需注意计数翻倍。

常用公式

fcnt=ftimPSC+1f_{cnt} = \frac{f_{tim}}{PSC+1}fcnt=PSC+1ftim fupdate=fcntARR+1f_{update} = \frac{f_{cnt}}{ARR+1}fupdate=ARR+1fcnt fpwm=ftim(PSC+1)(ARR+1)f_{pwm} = \frac{f_{tim}}{(PSC+1)(ARR+1)}fpwm=(PSC+1)(ARR+1)ftim

实用小贴士

修改 PSC/ARR/CCR 后若开预装载，需等待一次更新事件才生效，可手动 UG 产生。
中心对齐模式下计数往返一次算一个周期，实际频率为对齐模式的 2 倍计数范围。
多定时器级联时，用 TRGO/ITR 做主从同步，避免相位漂移。

CubeMX 配置

CubeMX 配置 STM32F103C8 定时器界面:

选项卡:

Slave mode:
- Disable
- External Clock Mode 1
- Reset Mode
- Gate Mode
- Trigger Mode
Tigger Source:
- Disable
- ITR0
- ITR1
- ITR2
- ITR3
- ETR1
- Tl1_ED
- Tl1FP1
Clock Source:
- Disable
- Internal Clock
- ETR2
Channel1/2/3/4:
- Disable
- Input Capture direct mode
- Input Capture indirect mode
- Input Capture tiggered by TRC
- Output Compare No Output
- Output Compare CH1/2/3/4
- PWM Generation No Output
- PWM Generation CH1/2/3/4
Combine Channels:
- Disable
- Encoder Mode
- PWM Input on CH1
- PWM Input on CH2
- XOR ON/HALL Sensor Mode
Use ETR as Clearing Source
XOR activation
One Pulse Mode

CubeMX 配置选项解读

Slave Mode (从模式选择)

用于设定当前定时器如何响应来自其他定时器或外部引脚的触发信号。

Disable: 禁用从模式。定时器独立运行，仅受自身控制寄存器支配。
External Clock Mode 1: 外部时钟模式 1。计数器 CNT 不再由内部时钟驱动，而是由选定的触发源（如 TIx 或 ETR）的边沿驱动。常用于“外部脉冲计数”。
Reset Mode: 复位模式。当选定的触发信号出现上升沿时，CNT 计数器立即清零并重新开始计数。常用于“清除计数器”或“同步相位”。
Gate Mode: 门控模式。触发信号为高电平时，CNT 正常计数；信号为低电平时，CNT 停止计数。常用于“测量高电平持续时间”。
Trigger Mode: 触发模式。在触发信号的上升沿启动计数器运行。注意：启动后，计数器会一直运行，直到手动停止。常用于“延迟启动”。

Trigger Source (触发源选择)

决定谁来触发上述的“从模式”动作。

ITR0/1/2/3: 内部触发输入。来源于其他定时器的 TRGO 输出。具体对应关系需查阅芯片手册的 TIMx internal trigger connection 表。常用于“定时器级联（主从模式）”。
ETR1: 外部触发输入。信号通过外部引脚 ETR 进入，经过极性、预分频和滤波后作为触发源。
TI1_ED: 通道 1 边沿检测（Edge Detector）。TI1 的上升沿和下降沿都会产生触发。
TI1FP1 / TI2FP2: 滤波后的通道信号。即来自输入引脚 CH1/CH2 且经过滤波和极性选择后的信号。

Clock Source (时钟源)

决定计数器 CNT 计数的脉冲来源。

Internal Clock: 内部时钟。默认选项，使用来自 APB 预分频器处理后的内部时钟信号。
ETR2: 外部时钟模式 2。使用 ETR 引脚作为时钟源。与 External Clock Mode 1 的区别在于 ETR2 使用专用路径，不占用从模式控制器。

Channel 1/2/3/4 (通道模式)

Input Capture direct mode: 直接输入捕获。物理引脚 CHx 的信号连接到对应的 CCRx 寄存器。用于“测频”或“测脉宽”。
Input Capture indirect mode: 间接输入捕获。物理引脚 CHx 的信号连接到相邻的 CCRy 寄存器（如 CH1 连接到 CCR2）。常用于“PWM 输入模式”，即一个引脚信号同时测量周期和占空比。
Output Compare No Output: 输出比较（无输出）。CNT 与 CCR 匹配时产生中断或事件，但不翻转物理引脚电平。常用于“软件定时执行任务”。
Output Compare CHx: 输出比较。匹配时翻转物理引脚电平。
PWM Generation CHx: PWM 输出。根据 ARR 和 CCR 的值在引脚上生成脉冲宽度调制信号。

Combine Channels (组合通道)

Encoder Mode: 编码器模式。利用 TI1 和 TI2 两个通道的正交信号自动增减 CNT。用于“电机测速”或“旋钮位置检测”。
PWM Input on CH1/2: PWM 输入模式。自动占用两个捕获寄存器，一个测周期，一个测占空比。
XOR ON/HALL Sensor Mode: 异或/霍尔传感器模式。将 CH1/2/3 的输入进行异或运算后再接入触发控制器。常用于“直流无刷电机（BLDC）的换向控制”。

其他勾选项

Use ETR as Clearing Source: 使用 ETR 作为清除源。当 ETR 信号为高时，强制清零输出参考信号（OCxREF）。常用于“过流保护”。
XOR activation: 异或激活。开启通道间的异或逻辑。
One Pulse Mode: 单脉冲模式。计数器在发生一次溢出（Update 事件）后自动停止（设置 CR1 寄存器的 OPM 位）。

PWM Generation 选项解读

一、时钟与计数基准（决定 PWM 频率）

配置项	作用	关键公式/逻辑	典型设置
TIMx_CLK	定时器内核时钟源	`TIMx_CLK = APBx_CLK × (APB预分频≠1 ? 2 : 1)`	查时钟树，F103 通常 72MHz
Prescaler (PSC)	分频计数器时钟	`计数频率 = TIMx_CLK / (PSC+1)`	设 PSC 使计数频率≈1MHz（精度与范围平衡）
Counter Period (ARR)	决定 PWM 周期（频率）	`PWM频率 = 计数频率 / (ARR+1)`	根据目标频率计算：`ARR = (计数频率/目标频率) - 1`
Counter Mode	计数方向	`Up`（0→ARR）、`Down`（ARR→0）、`Center`	电机控制常用`Up`，三相驱动用`Center`
auto-reload preload	ARR 更新方式	`Enable`：修改 ARR 后需更新事件才生效；`Disable`：立即生效	建议 Enable，避免调频时波形突变

二、PWM 输出控制（决定波形形状）

配置项	作用	关键逻辑	典型设置
Pulse (CCR)	决定 PWM 占空比	`占空比 = CCR / (ARR+1)`	动态调占空比时直接改此值
Mode	PWM 工作模式	`PWM mode 1`：CNT<CCR 有效；`PWM mode 2`：CNT≥CCR 有效	根据硬件“有效电平”选，常用模式 1
CH Polarity	通道极性	`High`：有效电平为高；`Low`：有效电平为低	匹配驱动电路（如高电平驱动电机选`High`）
Output compare preload	CCR 更新方式	`Enable`：修改 CCR 后需更新事件才生效；`Disable`：立即生效	建议 Enable，避免调占空比时跳变
Fast Mode	快速响应模式	绕过影子寄存器，强制立即更新输出	默认`Disable`，仅需极快响应时启用

三、高级定时器特有（驱动 H 桥电机必须）

配置项	作用	关键逻辑	典型设置
Break Input	刹车信号输入	外部刹车信号有效时，强制关闭 PWM 输出	接硬件保护电路（如过流检测）
Dead Time	死区时间	防止 H 桥上下管同时导通，设置互补输出的延迟	根据 MOS 管开关时间计算，通常 1~10μs
Complementary Output	互补输出通道	与主通道反相，用于驱动 H 桥的另一个管子	必须与主通道配合使用

四、动态调频关键操作流程

当需要实时改变 PWM 频率（如步进电机加减速）时，必须按此顺序操作：

1. HAL_TIM_PWM_Stop(&htim, TIM_CHANNEL_1);  // ① 先停止PWM输出
2. htim.Instance->ARR = new_arr;            // ② 更新ARR（新频率）
3. // ③ 按比例更新CCR，保持占空比不变：
   new_ccr = (new_arr + 1) * old_ccr / (old_arr + 1);
   __HAL_TIM_SET_COMPARE(&htim, TIM_CHANNEL_1, new_ccr);
4. HAL_TIM_PWM_Start(&htim, TIM_CHANNEL_1); // ④ 重新启动PWM

核心原则：改频率时必须同步调整 CCR，否则占空比会突变，导致电机扭矩波动甚至失步。

五、速查：不同定时器选型

类型	代表	适合场景	注意
基本定时器	TIM6, TIM7	纯时基（如 DAC 触发、简单延时）	无输出引脚，不能直接输出 PWM
通用定时器	TIM2~TIM5	普通 PWM 输出、输入捕获、编码器	步进电机驱动常用，但无死区功能
高级定时器	TIM1, TIM8	三相电机驱动、H 桥控制	必须配置死区时间，防止烧管

一句话总结

PSC + ARR = 频率（PSC 定内部时钟，ARR 定周期）
CCR = 占空比（占空比 = CCR/(ARR+1)）
Polarity + Mode = 有效电平逻辑
动态调频时：停 PWM → 改 ARR → 按比例改 CCR → 启 PWM
驱动 H 桥必选高级定时器 + 配置死区

提示：在 STM32CubeMX 中配置时，先设 PSC 和 ARR 得到目标频率，再设 CCR 得到占空比，最后根据硬件电路选择极性和模式。高级定时器务必在“Break and Dead Time”选项卡中设置死区时间。