氵工的博客

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

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.com

GitHub - 729DHS/linkage-2dof: 2-DOF wheel-legged robot linkage mechanism simulation with interactive visualization

2-DOF wheel-legged robot linkage mechanism simulation with interactive visualization - 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”选项卡中设置死区时间。

STM32 库设计笔记

Mon, 29 Dec 2025 16:00:00 GMT

库设计

一般而言,库的易用性和复杂度负相关,在设计高度抽象的易用性库时,需要考虑设计模式和三层架构封装

句柄化与对象封装

在面对对象编程中,我们用类或结构体来完成定义我们所操作的对象以下是 STM32 HAL 库的一段 SPI 代码

typedef struct __SPI_HandleTypeDef
{
  SPI_TypeDef                *Instance;      /*!< SPI registers base address               */
  SPI_InitTypeDef            Init;           /*!< SPI communication parameters             */
  const uint8_t              *pTxBuffPtr;    /*!< Pointer to SPI Tx transfer Buffer        */
  uint16_t                   TxXferSize;     /*!< SPI Tx Transfer size                     */
  __IO uint16_t              TxXferCount;    /*!< SPI Tx Transfer Counter                  */
  uint8_t                    *pRxBuffPtr;    /*!< Pointer to SPI Rx transfer Buffer        */
  uint16_t                   RxXferSize;     /*!< SPI Rx Transfer size                     */
  __IO uint16_t              RxXferCount;    /*!< SPI Rx Transfer Counter                  */
  void (*RxISR)(struct __SPI_HandleTypeDef *hspi);   /*!< function pointer on Rx ISR       */
  void (*TxISR)(struct __SPI_HandleTypeDef *hspi);   /*!< function pointer on Tx ISR       */
  DMA_HandleTypeDef          *hdmatx;        /*!< SPI Tx DMA Handle parameters             */
  DMA_HandleTypeDef          *hdmarx;        /*!< SPI Rx DMA Handle parameters             */
  HAL_LockTypeDef            Lock;           /*!< Locking object                           */
  __IO HAL_SPI_StateTypeDef  State;          /*!< SPI communication state                  */
  __IO uint32_t              ErrorCode;      /*!< SPI Error code                           */
#if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)
  void (* TxCpltCallback)(struct __SPI_HandleTypeDef *hspi);             /*!< SPI Tx Completed callback          */
  void (* RxCpltCallback)(struct __SPI_HandleTypeDef *hspi);             /*!< SPI Rx Completed callback          */
  void (* TxRxCpltCallback)(struct __SPI_HandleTypeDef *hspi);           /*!< SPI TxRx Completed callback        */
  void (* TxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);         /*!< SPI Tx Half Completed callback     */
  void (* RxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);         /*!< SPI Rx Half Completed callback     */
  void (* TxRxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);       /*!< SPI TxRx Half Completed callback   */
  void (* ErrorCallback)(struct __SPI_HandleTypeDef *hspi);              /*!< SPI Error callback                 */
  void (* AbortCpltCallback)(struct __SPI_HandleTypeDef *hspi);          /*!< SPI Abort callback                 */
  void (* MspInitCallback)(struct __SPI_HandleTypeDef *hspi);            /*!< SPI Msp Init callback              */
  void (* MspDeInitCallback)(struct __SPI_HandleTypeDef *hspi);          /*!< SPI Msp DeInit callback            */
#endif  /* USE_HAL_SPI_REGISTER_CALLBACKS */
} SPI_HandleTypeDef;

从上代码中可见,HAL 库为了封装 SPI,用这个 SPI__HandleType 结构体把所需全部参数封装

再比如标准库的 GPIO 初始化结构体

typedef struct
{
  uint16_t GPIO_Pin;             
  GPIOSpeed_TypeDef GPIO_Speed;  
  GPIOMode_TypeDef GPIO_Mode;    
}GPIO_InitTypeDef;

typedef enum
{ 
  GPIO_Speed_10MHz = 1,
  GPIO_Speed_2MHz, 
  GPIO_Speed_50MHz
}GPIOSpeed_TypeDef;
#define IS_GPIO_SPEED(SPEED) (((SPEED) == GPIO_Speed_10MHz) || ((SPEED) == GPIO_Speed_2MHz) || \
                              ((SPEED) == GPIO_Speed_50MHz))

typedef enum
{ GPIO_Mode_AIN = 0x0,
  GPIO_Mode_IN_FLOATING = 0x04,
  GPIO_Mode_IPD = 0x28,
  GPIO_Mode_IPU = 0x48,
  GPIO_Mode_Out_OD = 0x14,
  GPIO_Mode_Out_PP = 0x10,
  GPIO_Mode_AF_OD = 0x1C,
  GPIO_Mode_AF_PP = 0x18
}GPIOMode_TypeDef;

以上是对对象的封装,常见还是用到结构体跟 enum 枚举,但是对于非嵌入式尤其是现代 C++而言,不使用 typedef 结构体,一般使用类和类枚举

HAL 设计与条件编译

来看一段标准库代码

#ifdef CMSIS_NVIC_VIRTUAL
  #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE
    #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h"
  #endif
  #include CMSIS_NVIC_VIRTUAL_HEADER_FILE
#else
  #define NVIC_SetPriorityGrouping    __NVIC_SetPriorityGrouping
  #define NVIC_GetPriorityGrouping    __NVIC_GetPriorityGrouping
  #define NVIC_EnableIRQ              __NVIC_EnableIRQ
  #define NVIC_GetEnableIRQ           __NVIC_GetEnableIRQ
  #define NVIC_DisableIRQ             __NVIC_DisableIRQ
  #define NVIC_GetPendingIRQ          __NVIC_GetPendingIRQ
  #define NVIC_SetPendingIRQ          __NVIC_SetPendingIRQ
  #define NVIC_ClearPendingIRQ        __NVIC_ClearPendingIRQ
  #define NVIC_GetActive              __NVIC_GetActive
  #define NVIC_SetPriority            __NVIC_SetPriority
  #define NVIC_GetPriority            __NVIC_GetPriority
  #define NVIC_SystemReset            __NVIC_SystemReset
#endif /* CMSIS_NVIC_VIRTUAL */

再比如

#ifdef SYSCLK_FREQ_HSE
  static void SetSysClockToHSE(void);
#elif defined SYSCLK_FREQ_24MHz
  static void SetSysClockTo24(void);
#elif defined SYSCLK_FREQ_36MHz
  static void SetSysClockTo36(void);
#elif defined SYSCLK_FREQ_48MHz
  static void SetSysClockTo48(void);
#elif defined SYSCLK_FREQ_56MHz
  static void SetSysClockTo56(void);  
#elif defined SYSCLK_FREQ_72MHz
  static void SetSysClockTo72(void);
#endif

这种条件编译和检测宏定义然后看人下菜的模式,经常用于 HAL 设计,好处就是,可以灵活配置,已经对接好了各种可以快速移植的平台,你只需要选择你需要的宏定义甚至可以自动识别宏定义,然后条件编译

当然,我们这种模式是为了实现后续的黑盒化,统一我们的库函数什么的,虽然前期写的痛苦代码较多,但是后期使用方便.

高度抽象带来的额外代码和防御性编程

当我们代码高度封装,就会出现我们为了实现这些本需要我们自己操作的内容,需要额外写自动化配置的多余代码,甚至还需要为了预留更高级的操作,我们还需要保留自己的一份原始底层操作函数代码假设我们用自己的库实现了高度封装高度智能自动化的 GPIO 配置,但是这样的代价就是有些操作我们不能做,比如让 IO 口频率很高,或者因为外设原因,原本库中配置好的一套初始化就不能用了,我们只能自己配置,但是这个时候我们用的是自己的库,所以还是需要预留底层操作

防御性编程

仍然是标准库的案例:

void GPIO_SetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
{
  /* Check the parameters */
  assert_param(IS_GPIO_ALL_PERIPH(GPIOx));
  assert_param(IS_GPIO_PIN(GPIO_Pin));
  
  GPIOx->BSRR = GPIO_Pin;
}

这个 assert_param 宏就是防御性编程,这是一个检验的函数用于检验传入参数是否合法,否则直接进入 hardfault,在这里即使是最简单的 Set 操作,也检验了 IO 端口号的合法性再比如说互斥锁和原子操作,就是典型的防御性编程,保证程序运行时至少是完全在运行的,保证运行环境安全性.

回调函数与解耦

为什么抽象库函数需要回调? 首先我们理解这个问题是什么意思简单说,抽象库需要在不同层间传递“当事件发生时要做什么”的可变逻辑,但库本身又不想也不应关心具体业务,于是提供一个“挂钩点”(回调)让上层注入行为。

解耦职责: 底层库只负责检测事件、调度流程,上层注入的回调负责业务决策,两者互不依赖,降低耦合。
消除主动轮询: 没有回调时,上层只能轮询查询外设状态;有了回调,库在中断/任务切换点被动触发,既省 CPU 又降低延迟。
复用与可测试性: 同一套库代码可以被不同项目/模块复用,只需更换回调实现即可;测试时也能用假回调注入,隔离硬件依赖。
状态机闭环: HAL 里常见的“配置->启动->事件回调->收尾”模式,回调为状态机提供了出口,让框架能够正确结束或继续下一步。
扩展性: 当需要额外处理(统计、日志、安全检查)时,增加或替换回调就能完成,无需修改库本体。

回调的使用注意点:

回调应尽量短小可重入,避免在中断上下文里做耗时或阻塞操作。
明确回调的调用时机与线程/中断上下文,否则容易出现竞态。
对回调错误要有兜底策略(返回码或错误钩子),避免隐藏故障。

STM32 Keil RTE 与 RTOS 笔记

Sat, 27 Dec 2025 16:00:00 GMT

Keil+RTE 环境创建

打开 Keil,New uVision Project,选择芯片 STM32f103C8T6,默认弹出 RTE 窗口

如图,进行 Std 标准库创建时,选择以下基础内容: CMSIS —> CORE 这是链接 ARM 芯片的核心 Device —> Startup 这是芯片启动必须链接的其他可以不需要但是使用标准库操作 STM32 时,还需要 Device —> StdPeriph Drivers 下的内容如 RCC,GPIO,I2C 等,选择后出现黄色报错,点击界面最左下角的 Resolve 即可,会自动寻找依赖项选择,如 Framework

这样最基础的 Std 库项目创建完成,其他跟普通的创建项目没有区别创建主函数,写个简单 demo,点击 Options for Target,也就是常说的魔术棒点击 C/C++(AC6)进行宏定义设置对于 103C8 需要写 STM32F10X_MD 对于标准库需要写 USD_STDPERIPH_DRIVER 以及对于 AC6+CMSIS 6.X 版本,需要加入 IP=IPR 对 CMSIS 5.X 则不需要

想知道自己库的版本,或者对版本和库进行管理,点击 RTE 图标旁边的 Pack Installer 即可

对于 FreeRTOS 的一些知识

FreeRTOS 的 API 分为两个版本,一个是原生,一个是 CMSIS 版 API,CMSIS 对原生函数名等进行改写

原生 API

遵循一套独特的命名约定，函数名通常包含返回类型。

以下是原生例程

#include "stm32f10x.h"
#include "stm32f10x_conf.h"
#include <stdio.h>
#include "FreeRTOS.h"
#include "task.h"

volatile uint32_t g_counter = 0;  // 简单计数器，LED和UART共享

void LED_Init(void) {
    GPIO_InitTypeDef gpio;
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
    gpio.GPIO_Pin = GPIO_Pin_13;
    gpio.GPIO_Mode = GPIO_Mode_Out_PP;
    gpio.GPIO_Speed = GPIO_Speed_2MHz;
    GPIO_Init(GPIOC, &gpio);
}

void USART1_Init(void) {
    GPIO_InitTypeDef gpio; USART_InitTypeDef usart;
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_USART1, ENABLE);
    gpio.GPIO_Pin = GPIO_Pin_9;  gpio.GPIO_Mode = GPIO_Mode_AF_PP;      gpio.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &gpio);
    gpio.GPIO_Pin = GPIO_Pin_10; gpio.GPIO_Mode = GPIO_Mode_IN_FLOATING;                               GPIO_Init(GPIOA, &gpio);
    usart.USART_BaudRate = 115200; usart.USART_WordLength = USART_WordLength_8b; usart.USART_StopBits = USART_StopBits_1;
    usart.USART_Parity = USART_Parity_No; usart.USART_HardwareFlowControl = USART_HardwareFlowControl_None; usart.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
    USART_Init(USART1, &usart); USART_Cmd(USART1, ENABLE);
}

int fputc(int ch, FILE *f) {
    USART_SendData(USART1, (uint8_t)ch);
    while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
    return ch;
}

static void USART1_SendChar(char c) {
    USART_SendData(USART1, c);
    while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
}

static void USART1_SendString(const char *s) {
    while (*s) USART1_SendChar(*s++);  // 简单同步发送，不做缓冲
}

void LedTask(void *param) {
    while (1) {
        GPIO_ResetBits(GPIOC, GPIO_Pin_13);  // LED on
        vTaskDelay(pdMS_TO_TICKS(500));
        GPIO_SetBits(GPIOC, GPIO_Pin_13);    // LED off
        vTaskDelay(pdMS_TO_TICKS(500));
    }
}

void UartTask(void *param) {
    char buf[16]; uint32_t val; int i;
    while (1) {
        g_counter++; val = g_counter; i = 0;
        if (val == 0) { buf[i++] = '0'; }
        else {
            char tmp[10]; int j = 0;
            while (val) { tmp[j++] = (val % 10) + '0'; val /= 10; } // 反转收集数字
            while (j--) buf[i++] = tmp[j];                         // 再反转得到正序
        }
        buf[i] = '\0';
        USART1_SendString(buf); USART1_SendString("\r\n");      // 发送计数值
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

int main(void) {
    SystemInit();                 // HAL/CMSIS 启动
    LED_Init(); USART1_Init();    // 硬件初始化
    xTaskCreate(LedTask, "LED", 128, NULL, 1, NULL);   // 低栈闪灯
    xTaskCreate(UartTask, "UART", 512, NULL, 1, NULL); // 串口打印任务
    vTaskStartScheduler();        // 启动调度
    while (1) { /* should never reach */ }
}

以下是 CMSIS V2 例程

#include "stm32f10x.h"
#include "cmsis_os2.h"
#include <stdio.h>

volatile uint32_t g_counter = 0;    // LED 线程自增计数，UART读取
osThreadId_t ledTaskHandle;         // LED 线程句柄
osThreadId_t uartTaskHandle;        // UART 线程句柄

static void LED_Task(void *argument);   // 闪灯任务
static void UART_Task(void *argument);  // 串口打印任务
static void USART1_Init(void);
static void USART1_SendChar(char c);
static void USART1_SendString(const char *s);

static void LED_Task(void *argument) {
    GPIO_InitTypeDef gpio;
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
    gpio.GPIO_Pin = GPIO_Pin_13; gpio.GPIO_Mode = GPIO_Mode_Out_PP; gpio.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOC, &gpio);
    GPIO_SetBits(GPIOC, GPIO_Pin_13);  // 默认灭
    for (;;) {
        GPIO_ResetBits(GPIOC, GPIO_Pin_13); g_counter++; osDelay(500);
        GPIO_SetBits(GPIOC, GPIO_Pin_13);    osDelay(500);
    }
}

static void UART_Task(void *argument) {
    char buf[64];
    USART1_Init();  // 独立初始化串口
    for (;;) {
        snprintf(buf, sizeof(buf), "Hello RTOS, g_counter = %lu\r\n", g_counter);
        USART1_SendString(buf);  // 直接同步发送
        osDelay(1000);
    }
}

static void USART1_Init(void) {
    GPIO_InitTypeDef gpio; USART_InitTypeDef usart;
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_USART1, ENABLE);
    gpio.GPIO_Pin = GPIO_Pin_9;  gpio.GPIO_Mode = GPIO_Mode_AF_PP;      gpio.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &gpio);
    gpio.GPIO_Pin = GPIO_Pin_10; gpio.GPIO_Mode = GPIO_Mode_IN_FLOATING;                               GPIO_Init(GPIOA, &gpio);
    usart.USART_BaudRate = 115200; usart.USART_WordLength = USART_WordLength_8b; usart.USART_StopBits = USART_StopBits_1;
    usart.USART_Parity = USART_Parity_No; usart.USART_Mode = USART_Mode_Tx; usart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_Init(USART1, &usart); USART_Cmd(USART1, ENABLE);
}

static void USART1_SendChar(char c) {
    USART_SendData(USART1, c);
    while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
}

static void USART1_SendString(const char *s) {
    while (*s) USART1_SendChar(*s++);  // 简单轮询方式
}

int main(void) {
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
    osKernelInitialize();
    ledTaskHandle = osThreadNew(LED_Task, NULL, NULL);   // 创建闪灯线程
    uartTaskHandle = osThreadNew(UART_Task, NULL, NULL); // 创建串口线程
    osKernelStart();                                    // 启动调度器
    while (1) {}                                        // 不应返回
}

杂谈

需要注意的是在 RTOS 里要避免 newLib,比如 Stdio.h,printf,这些函数库对于 RTOS 并不友好

为什么 Newlib 对 RTOS “不友好”？

A. 重入性 (Reentrancy) 风险这是最致命的问题。printf、malloc、strtok 等函数通常使用全局变量或静态缓冲区。冲突：如果任务 A 正在调用 printf 打印一半，此时更高优先级的任务 B 抢占了 CPU 也调用 printf，全局缓冲区的数据就会被污染，甚至导致硬件异常。 Newlib 的补救： Newlib 提供了一个 struct _reent 结构体，但 RTOS 必须为每个任务都分配一个这样的结构体并在任务切换时进行切换，这会极大增加内存开销。

B. 栈空间的“大胃王” printf 是一个非常复杂的函数，它需要处理各种格式化、浮动溢出和内部缓存。内存占用：调用一次标准 printf 可能会瞬间消耗几百甚至上千字节的栈空间。后果：在 RTOS 中，每个任务的栈大小是有限的（通常设为 128 或 256 字），直接调用 printf 极易引发 Stack Overflow。

C. 线程安全与 Lock Newlib 的某些函数内部会尝试调用 __malloc_lock 和 __malloc_unlock。如果这些底层的锁函数没有被正确映射到 RTOS 的信号量或互斥量上，系统就会死锁或产生竞态。

总结：RTOS 的“避坑手册”

禁止在中断 (ISR) 中调用 printf：这几乎 100% 会导致系统挂死。
谨慎对待浮点数： %f 格式化极其消耗性能和栈空间。
检查栈大小：如果必须用标准库，请务必调大任务栈（Stack Size）。
配置 Newlib-nano：在 STM32CubeIDE 等编译器中，勾选 —specs=nano.specs，它可以大幅缩减标准库体积，但依然不能完全解决线程安全问题。

Cortex-M 上的原子操作小结

8/16/32 位对齐的读写在 Cortex-M3/M4 上天然原子（单总线周期），但非对齐或跨字宽访问就不原子。
禁中断法：短临界区可用 __disable_irq() / __enable_irq() 包裹，或 FreeRTOS 的 taskENTER_CRITICAL/taskEXIT_CRITICAL；注意临界区越短越好。
自旋原子指令：Cortex-M3+ 支持 LDREX/STREX 形成原子操作，CMSIS 提供封装：
- __LDREXW / __STREXW：32 位独占读写，用于自定义无锁结构。
- __CLREX：清除独占标记，避免意外占用。
内存屏障：
- __DMB() 数据内存屏障，保证访存顺序（典型用在共享变量标志位前后）。
- __DSB() 数据同步屏障，确保之前的访存完成后才继续；常见于外设寄存器配置完成后。
- __ISB() 指令同步屏障，刷新流水线，常用于切换栈/向量表后。
原子加减建议：
- C11 stdatomic 若编译器/库支持，可用 atomic_fetch_add 等，底层会用 LDREX/STREX。
- 否则用禁中断或基于 __LDREXW/__STREXW 的循环实现 atomic_inc/atomic_dec。
FreeRTOS 场景：
- 任务间优先用队列/信号量/互斥量；ISR 到任务用中断安全 API（以 FromISR 结尾）。
- 若仅是简单计数且在任务上下文，可用 taskENTER_CRITICAL 包裹；在 ISR 中则禁用更低优先级中断或用 ulPortSetInterruptMask/vPortClearInterruptMask（端口相关）。

氵工的博客

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

1. 问题背景

2. 正运动学推导

2.1 点坐标逐步求解

2.2 核心简化：直杆约束

2.3 最终解析式

3. 逆运动学推导

3.1 余弦定理

3.2 两个解

3.3 工作空间与奇异位形

4. 代码实现

4.1 两圆相交

4.2 正运动学求解器

4.3 逆运动学

5. 四种装配模式

5.1 轨迹跟踪中的分支保持

5.2 装配模式的选择依据

6. 验证

7. 总结

GitHub - 729DHS/linkage-2dof: 2-DOF wheel-legged robot linkage mechanism simulation with interactive visualization

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

这世界既残酷也温柔笔记

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

做从未来看正确的事

ALL IN 一个波澜壮阔的事业

嘉立创筑基派FreeRTOS 点灯demo

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

0. 实验概述

1. 预备知识

1.1 什么是 FreeRTOS 任务？

1.2 硬件基础

2. 原理解析

2.1 任务优先级与调度

2.2 时间延迟 (osDelay)

3. 代码深度解析

3.1 任务属性定义

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

EC11 编码器控制 LED 亮度项目

1. 项目概述

2. 技术框架

2.1 硬件平台

2.2 软件架构

3. 代码结构分析

3.1 头文件和包含部分

3.2 全局变量定义

3.3 任务句柄定义

3.4 任务函数原型

3.5 编码器状态表

4. 主要功能实现

4.1 主函数

4.2 任务初始化

4.3 Encoder 任务

4.4 KEY 任务

4.5 LED 任务

4.6 TIM10 定时器初始化

4.7 GPIO 初始化

5. 技术细节

5.1 编码器工作原理

5.2 PWM 控制原理

5.3 FreeRTOS 任务管理

5.4 按键防抖处理

5.5 任务间通信

6. 工作流程

7. 代码优化建议

7.1 使用队列替代全局变量

7.2 增加参数配置

7.3 增加错误处理

7.4 优化任务优先级

7.5 增加状态指示

8. 测试方法

9. 项目结构

10. 技术要点

11. 项目特点

12. 应用场景

13. 总结

嘉立创筑基派PWM_LED_demo

PWM LED 控制项目文档

1. 项目概述

2. 技术框架

2.2 时间延迟 (`osDelay`)

5.1 `main()` 推荐顺序