多变量：耦合、RGA、解耦与麦轮底盘

两个输入、两个输出：耦合是什么#

多变量对象的最小例子是 2×2：

前七篇的做法放大一倍就是分散控制：$u_1 = C_1(r_1 - y_1)$，$u_2 = C_2(r_2 - y_2)$，两个 PID 各管各的（出了事互相甩锅）。耦合是 $g_{12}$ 和 $g_{21}$ 不为零：$u_2$ 会推动 $y_1$，反过来也一样。类比一下：一个淋浴器有冷水和热水两个龙头，目标是水温和水量，每个龙头都同时改变这两个量，两个人各管一个龙头、各自盯着自己的那一个量，就是分散控制。

耦合到底会让回路 1 看到什么？看稳态。回路 2 开着的时候，$y_1 = g_{11}u_1$。回路 2 闭上并且带积分，稳态下 $y_2$ 的偏差被拉回 0，$0 = g_{21}u_1 + g_{22}u_2$，即 $u_2 = -g_{21}u_1/g_{22}$，代入 $y_1$：

另一个回路一闭，回路 1 的增益就从 $g_{11}$ 变成了 $g_{11}(1-\kappa)$。你在回路 2 开着的时候整定的 PI，到回路 2 闭上之后用的是另一个对象。

RGA：把这个比值做成一张表#

Bristol 1966 年提出的相对增益，就是上面这个比值，开环增益除以“其余回路闭环时的增益”：

原文只有两页（IEEE TAC 第 11 卷第 1 期，133 到 134 页），我没有找到能读的全文，所以这里的定义和性质是我自己推的，再用 numpy 核对。2×2 的情况每行每列的和都是 1：$\lambda_{12} = \lambda_{21} = 1 - \lambda_{11} = -g_{12}g_{21}/\det G$，$\lambda_{22} = \lambda_{11}$。$n\times n$ 的一般形式是 $\Lambda = G\circ(G^{-1})^T$（逐元素乘），report 用 numpy.linalg.inv 把它算了一遍，和我手写的 2×2 公式一致。

怎么读：$\lambda_{ij}$ 说的是“$u_j$ 配 $y_i$ 这一对，在别的回路都闭上之后，增益变成原来的 $1/\lambda_{ij}$”。

• $\lambda_{ij}\approx1$：别的回路闭不闭，这一对的增益都差不多，可以配。
• $\lambda_{ij}\gg1$：别的回路一闭，这一对的增益大幅缩水，两个回路在互相牵制。
• $\lambda_{ij}<0$：别的回路一闭，这一对的增益变号。据我所知，“别配 RGA 为负的那一对”是这套经验规则里最硬的一条：你按开环符号整定的积分控制器，在另一个回路闭上之后成了正反馈。我不在这里证明它，下面的实验会直接给出结果。

代码就是上面那两个公式。2×2 阵用长度为 4 的行优先列表 [g11, g12, g21, g22]，四种语言布局相同：

1
def rga2(g: list[float]) -> list[float]:
2
    """Relative gain array [l11, l12, l21, l22] of a 2x2 gain matrix.
3

4
    l11 = g11 g22 / det, l12 = -g12 g21 / det; rows and columns sum to 1.
5
    """
6
    d = det2(g)
7
    if abs(d) < 1e-12:
8
        raise ValueError("singular 2x2 matrix")
9
    l11 = g[0] * g[3] / d
10
    l12 = -g[1] * g[2] / d
11
    return [l11, l12, l12, l11]

只算 $\lambda_{11}$ 和 $\lambda_{12}$，另外两项靠“行列和为 1”直接复制。行列式接近 0 的时候没有意义，所以 Python 抛 ValueError，下面的 C、C++、Rust 各用自己的惯用办法报错。

对象：Wood–Berry 精馏塔#

Wood 和 Berry 1973 年在一个中试规模的二元精馏塔上做了塔顶、塔底成分的控制研究。后来的教材和论文常拿这个塔的 2×2 传递函数矩阵做多变量控制的例子，时间单位是分钟：

要交代一件事：这组数是我从常见的转引版本里取的，没有对照 1973 年原文的表格逐项核对。它在这一篇里的角色是“一个 RGA 约等于 2 的耦合对象”，我只要它自洽。

采样周期取 $t_s = 0.1$ 分钟，四个通道的延迟是 10、30、70、30 个采样。实现上把每个通道拆成“一阶滞后加一条 DelayLine”，一共四个状态、四条延迟线：

1
class WoodBerry:
2
    # ...
3
    k: tuple = (12.8, -18.9, 6.6, -19.4)
4
    tau: tuple = (16.7, 21.0, 10.9, 14.4)
5
    delay: tuple = (10, 30, 70, 30)  # samples of 0.1 min
6

7
    def deriv(self, x, u):
8
        return [(self.k[i] * u[i] - x[i]) / self.tau[i] for i in range(4)]
9

10
    def outputs(self, x):
11
        return [x[0] + x[1], x[2] + x[3]]

通道顺序是 $g_{11}, g_{12}, g_{21}, g_{22}$。延迟不在对象里，由仿真循环用 DelayLine 实现，和第 6 篇的 Flywheel 一样。$u_1$ 同时进两个通道（$g_{11}$ 和 $g_{21}$），所以 $u_1$ 要分别推进两条延迟线（延迟 10 和 70），$u_2$ 同理。

直流增益矩阵 $G(0)$ 的行列式是 $12.8\times(-19.4) - (-18.9)(6.6) = -123.58$，所以

手算 $\lambda_{11}=2.0094$，report 里断言 $|\lambda_{11} - 2.0094| < 10^{-3}$，代码给出的是同一个数。读这张表：对角配对 $\lambda_{11} = 2.01$，回路 2 一闭，回路 1 的直流增益从 12.8 掉到 6.37，也就是 $g_{11}/\lambda_{11}$（report 同时用 $g_{11} - g_{12}g_{21}/g_{22}$ 直接算，两个数相同）；非对角配对 $\lambda_{12} = -1.0094$，$y_1$ 从 $u_2$ 的增益在另一个回路闭上之后从 $-18.9$ 变成 $+18.72$，符号反了。

分散 PI：SIMC 逐通道#

对角配对（$u_1\to y_1$，$u_2\to y_2$）用第 6 篇的 SIMC，$\tau_c = \theta$。每个通道本身就是一阶加延迟，$k$、$\tau$、$\theta$ 直接读表，simc_pi 算出来：

两个对角通道我先手算过：$K_p = 12.8$ 的通道是 $\tau/(k(\tau_c+\theta)) = 16.7/(12.8\times2) = 0.652$，$T_i = \min(16.7,\ 4\times2) = 8$；$g_{22}$ 是 $14.4/(-19.4\times6) = -0.124$，$T_i = \min(14.4,\ 24) = 14.4$。代码给出的 0.6523、8.0、−0.1237、14.4 与此一致，而且是代码算的，没有硬编码。注意 $g_{22}$ 的增益是负的，所以它的 $K_p$ 也是负的：控制器的符号必须和对象一致，否则第一拍就是正反馈。Pid 不关心符号，写错了它也照样给你一个发散的回路。

下面两个通道是错配实验用的：wb_wrongpair 里 $y_1$ 由 $u_2$ 管，用的是 $g_{12}$ 那一行的 SIMC 增益，$y_2$ 由 $u_1$ 管，用的是 $g_{21}$ 那一行的。SIMC 在这里的意义很窄：它保证每个通道单独闭环时是好的，对另一个回路的存在一无所知，这是下面几个实验里被检验的地方。

四个 Pid 的构造只有这几行，控制器就是第 5 篇的 Pid，$K_d = 0$：

1
def wb_loops(plant: WoodBerry) -> dict[str, list[Pid]]:
2
    """SIMC PI (tauc = theta) for the two pairings, parallel gains."""
3

4
    def pid(i: int) -> Pid:
5
        theta = plant.delay[i] * WB_TS
6
        g = simc_pi(plant.k[i], plant.tau[i], theta)
7
        return Pid(PidConfig(g.kp, g.ki, 0.0, WB_TS))
8

9
    # channel order: 0 = g11, 1 = g12, 2 = g21, 3 = g22
10
    return {"diag": [pid(0), pid(3)], "off": [pid(1), pid(2)]}

静态解耦和矩阵增益 PI#

既然耦合在稳态下是 $G(0)$ 的非对角项，一个直接的想法是在控制器后面加一个矩阵 $D$，让 $G(0)D$ 变成对角：

Wood–Berry 的 $D = \begin{bmatrix}2.0094&2.9670\\0.6836&2.0094\end{bmatrix}$，report 验证了 $G(0)D$ 的非对角项只有 $4\times10^{-15}$。结构是这样的：

两个 PI 是同一对对角 PI（用 SIMC 在对角通道上整定的那两个），这是对比的前提。把 $D$ 和 PI 合并看，控制律是 $\mathbf u = D\,[K_p\mathbf e + K_i\!\int\mathbf e]$，也就是一个矩阵增益 PI：

所谓“多变量 PID”，在这个层面上不过是把标量增益换成矩阵增益，不多不少。第 9 篇会把这个想法推到底。

静态解耦只管 $s = 0$。$g_{11}$ 到 $g_{22}$ 的延迟和时间常数各不相同，$D$ 想抵消的耦合通道和它本该抵消的通道，在动态上并不对齐。稳态耦合是没了，暂态会变好还是变坏，我没法从公式直接看出来，下面直接看数。

四个算例的循环#

四个算例的循环完全一样，只差“谁管谁”这几行：

1
y1, y2 = plant.outputs(x)
2
if name == "wb_single1":
3
    u1, u2 = loops["diag"][0].update(r1, y1), 0.0
4
elif name == "wb_decentral":
5
    u1 = loops["diag"][0].update(r1, y1)
6
    u2 = loops["diag"][1].update(r2, y2)
7
elif name == "wb_wrongpair":
8
    u2 = loops["off"][0].update(r1, y1)  # y1 is driven by u2
9
    u1 = loops["off"][1].update(r2, y2)  # y2 is driven by u1
10
else:  # wb_decoupled
11
    v1 = loops["diag"][0].update(r1, y1)
12
    v2 = loops["diag"][1].update(r2, y2)
13
    u1, u2 = mat2_vec(d, [v1, v2])
14
# ...
15
u = [lines[0].push(u1), lines[1].push(u2)]
16
u += [lines[2].push(u1), lines[3].push(u2)]
17
x = advance(plant.deriv, x, u, WB_TS, WB_SUBSTEPS)

三件事值得盯一下。配对：wb_wrongpair 里 off[0] 看 $y_1$、输出给 $u_2$，off[1] 看 $y_2$、输出给 $u_1$。四条延迟线：lines[0] 和 lines[2] 都吃 $u_1$，lines[1] 和 lines[3] 都吃 $u_2$，分别对应 $g_{11}, g_{12}, g_{21}, g_{22}$ 的延迟。解耦：wb_decoupled 先让两个 PI 输出 $v$，再用 mat2_vec(d, [v1, v2]) 乘 $D$，记录下来的 u1、u2 是 $D$ 之后、进延迟线之前的量。

从几何推出 H#

车体系 $x$ 向前、$y$ 向左、$z$ 向上，$\nu = (v_x, v_y, \omega_z)$ 是车体系下的速度。轮子 $i$ 的接地点位置是 $(x_i, y_i)$，$|x_i| = l_x$、$|y_i| = l_y$，接地点的速度是

麦轮的滚子轴和轮平面成 45°，轮子沿滚子方向可以自由滑动，所以对轮子的转动只有一个约束：轮缘速度 $r\omega_i$ 等于接地点速度在“轮面前进方向”和“垂直方向”上的两个分量按滚子斜度（±45°）的组合：

$s_i$ 由滚子的装法决定。我取 $s = (-1, +1, +1, -1)$，轮子依次是左前（FL）、右前（FR）、左后（RL）、右后（RR），位置 $(x_i, y_i) = (+l_x, +l_y), (+l_x, -l_y), (-l_x, +l_y), (-l_x, -l_y)$。编号和坐标画出来是这样（俯视，$+y$ 指向左边，仿真里的 i1 到 i4 就是这个顺序）：

1
              front (+x)
2
   (+lx,+ly) 1 FL  ^  2 FR (+lx,-ly)
3
               +---|---+
4
   (+y) <------|   .   |
5
               +-------+
6
   (-lx,+ly) 3 RL     4 RR (-lx,-ly)
7
               rear (-x)

代入：

写成 $\omega = H\nu/r$，$L = l_x + l_y = 0.4$ m：

（$s$ 整个反过来的装法，在 $l_x = l_y$ 时每个轮子对 $\omega_z$ 的系数都是 0，底盘转不起来，所以真车不是那样装的。我没有对照真实的 RoboMaster 底盘去核对滚子朝向，这一组 $s$ 是推导里的假设。）report 用 numpy 验证了 $H^TH=\operatorname{diag}(4,4,4L^2)$：$H$ 的三列互相正交，这一点后面一直在用。代码里 $H$ 就是 12 个数的行优先列表，轮 $i$ 的那一行在 h[3 * i : 3 * i + 3]：

1
def mecanum_h(lx: float, ly: float) -> list[float]:
2
    """Wheel matrix H (4x3): wheel speeds are H nu / r for nu = (vx, vy, wz).
3

4
    Wheel order: front left, front right, rear left, rear right.
5
    """
6
    s = lx + ly
7
    return [
8
        1.0, -1.0, -s,
9
        1.0, 1.0, s,
10
        1.0, 1.0, -s,
11
        1.0, -1.0, s,
12
    ]  # fmt: skip

动力学：为什么力矩是 $\tfrac{K_t}{r}H^Ti$#

底盘质量 $m$、转动惯量 $I_z$，每个轮子折算到轮轴上的转动惯量 $J_w$。动能是

电机功率 $\sum_iK_ti_i\omega_i = \nu^T\bigl(\tfrac{K_t}{r}H^Ti\bigr)$，所以对 $\nu$ 的广义力就是 $\tfrac{K_t}{r}H^Ti$，与 $H$ 行的符号约定无关，只要 $\omega = H\nu/r$。再加粘性阻尼 $-c_v\nu$ 和体系间的向心耦合（车体系下速度分量的导数不是加速度：$m(\dot v_x - \omega_zv_y)=F_x$，$m(\dot v_y + \omega_zv_x)=F_y$），得到

世界系位姿 $(X, Y, \psi)$ 由 $\dot X = v_x\cos\psi - v_y\sin\psi$、$\dot Y = v_x\sin\psi + v_y\cos\psi$、$\dot\psi = \omega_z$ 积分。参数是我取的假设值：$m = 20$ kg，$I_z = 0.6$ kg·m²，$r = 0.076$ m，$l_x = l_y = 0.2$ m，$J_w = 0.001$ kg·m²（每轮），$c_v = 0.5$，$K_t = 0.3$ N·m/A（第 1 篇交代过出处和不确定性）。因为 $H^TH$ 是对角的，左边的质量阵也是对角的：$M_{eff} = \operatorname{diag}(20.6925,\ 20.6925,\ 0.7108)$。

向心项值得多说一句。省掉它，对象在车体系下就是三个独立的一阶系统，$\omega_z = 0$ 时没错，转起来就不对了。这一篇的指令最后是 $\omega_z\approx2.2$ rad/s，$v\approx1.46$ m/s，向心力在 $x$ 方向的分量 $m\omega_zv_y = 20\times2.192\times1.462 = 64.1$ N，是四个轮子同向推车时推力上限（$4K_t\times20/r\approx316$ N）的五分之一。我先省掉它跑过一遍，后面“没有按直觉发生的事”给出了两版的数。

放进代码里，Mecanum.deriv 就是这个方程：先算广义力 $\tfrac{K_t}{r}H^Ti-c_v\nu$，加向心项，再除以对角的 $M_{eff}$，最后接上位姿的运动学：

1
def deriv(self, x, u):
2
    h = mecanum_h(self.lx, self.ly)
3
    meff = self.inertia()
4
    f = []
5
    for k in range(3):
6
        wrench = 0.0
7
        for i in range(4):
8
            wrench += h[3 * i + k] * u[i]
9
        f.append(self.kt / self.r * wrench - self.cv * x[k])
10
    f[0] += self.m_body * x[2] * x[1]
11
    f[1] -= self.m_body * x[2] * x[0]
12
    dv = [f[k] / meff[k] for k in range(3)]
13
    c, s = math.cos(x[5]), math.sin(x[5])
14
    return [
15
        dv[0],
16
        dv[1],
17
        dv[2],
18
        c * x[0] - s * x[1],
19
        s * x[0] + c * x[1],
20
        x[2],
21
    ]

状态是 [vx, vy, wz, X, Y, psi]，输入是四个轮子的电流。inertia() 返回对角质量阵：$m$、$m$、$I_z$ 各加上 $\tfrac{J_w}{r^2}$ 乘 mecanum_gram_diag。

零空间：四个轮子，三个自由度#

$H$ 是 4×3 的，$H^T$ 有一维零空间。向量 $n=[1,1,-1,-1]/2$ 满足 $H^Tn=0$：$H$ 的第一列是 $(1,1,1,1)$，和 $n$ 的内积是 $\tfrac12(1+1-1-1)=0$；第二列 $(-1,1,1,-1)$，$\tfrac12(-1+1-1+1)=0$；第三列 $(-L,L,-L,L)$，$\tfrac12(-L+L+L-L)=0$。report 数值核对了 $H^Tn=[0,0,0]$。

物理含义：$n$ 是“左前、右前一起往前拧，左后、右后一起往后拧”的电流模式，它产生的合力和合力矩都是 0。四个人抬一张桌子，两个人往前拉、两个人往后拉，桌子不动，但每个人都在出力：零空间电流就是这样的力，不产生任何底盘运动，只是白白发热（我没有在这一篇里算电机热和电池功率，只给电流）。对任意电流 $i$，可以分解成

$n^Ti$ 就是仿真里记录的 null_i。给定车体系的合力和合力矩 $w=(F_x,F_y,T_z)$，求满足 $\tfrac{K_t}{r}H^Ti=w$ 的电流，有无穷多解，范数最小的那个是

它没有零空间分量。同理由轮速求车体速度的正运动学 $\hat\nu = rH^+\omega = r(H^TH)^{-1}H^T\omega$。因为 $H^TH$ 是对角的，这两个式子都不需要矩阵求逆，只要除以 $(4,4,4L^2)$：

1
def mecanum_currents(
2
    w: list[float], lx: float, ly: float, r: float, kt: float
3
) -> list[float]:
4
    """Minimum-norm currents for the body wrench w = (Fx, Fy, Tz).
5

6
    The wrench is (kt / r) H^T i; the solution is
7
    i = (r / kt) H (H^T H)^-1 w.
8
    """
9
    h = mecanum_h(lx, ly)
10
    g = mecanum_gram_diag(lx, ly)
11
    a = [w[k] / g[k] for k in range(3)]
12
    return [
13
        r / kt * (h[3 * i] * a[0] + h[3 * i + 1] * a[1] + h[3 * i + 2] * a[2])
14
        for i in range(4)
15
    ]
16

17

18
def null_current(i: list[float]) -> float:
19
    """Component n^T i along the null vector n = [1, 1, -1, -1] / 2."""
20
    return 0.5 * (i[0] + i[1] - i[2] - i[3])

report 把我手写的 $\hat\nu$ 和 numpy.linalg.pinv 的结果比，差 $2.2\times10^{-16}$，把最小范数电流和 pinv 比，差 $5.6\times10^{-17}$。

饱和的时候，方向比大小重要#

轮速有上限，$\omega_{max} = 50$ rad/s（官网列的 M3508 空载转速约 482 rpm，也就是 50.5 rad/s），电流有上限 20 A。指令是 $\nu_{ref}=(2.0,\,2.0,\,3.0)$，对应的四个轮速是

只有轮 2（FR）超限。三种处理：

• 逐轮截断（mec_wheel_clip）：每个轮子的设定值各自截到 $\pm50$，每个轮子的电流各自截到 $\pm20$ A，每个轮子一个 Pid（带 $\pm20$ A 限幅，窗口是 CLAMP）。
• 逐轮等比缩放（mec_wheel_scale）：整个轮速向量乘同一个系数 $s = 50/68.42 = 0.7308$，电流向量也乘同一个系数让 $\max|i|\le20$。
• 车体系 PI（mec_body）：三个 PI 管 $\hat\nu$，指令乘同一个 $s$，输出的合力和合力矩用最小范数映射成电流，最后电流向量等比缩放。

截断为什么麻烦？$\omega_{ref}$ 本来在 $H$ 的值域里（它是 $H\nu_{ref}/r$），只截轮 2 一个，截出来的向量不再属于值域。值域外的那部分就是零空间分量 $n^T\omega_{clip} = -9.21$ rad/s，而轮子的实际速度永远在值域里（$\omega = H\nu/r$），所以这 $-9.21$ rad/s 的误差任何底盘运动都消不掉。四个同样增益的 PI 对它的反应是：比例项单独就是 $k_p\times(-9.21)=-38.4$ A，沿 $n$ 的方向，也就是每个轮子 $\pm19.2$ A，已经是 20 A 限幅的 96%，积分项再把它推到限幅。电流的限幅被零空间电流占满，留给真正推车的“值域”部分的余量没了。

等比缩放的两种写法没有这个问题：缩放后的 $\omega_{ref}$ 仍在值域里，四个 PI 增益相同，值域里的误差只会产生值域里的电流，零空间分量从头到尾是 0（舍入误差除外）。为了让缩放时不积分饱和，缩放这两种的 Pid 不设自己的限幅，驱动把“上一个采样是否缩放了”当作 hold_integral 传给所有积分器，和第 7 篇冻结外环积分是同一个手法。

三个变体共用一个循环，只差 if 的三支：

1
omega = plant.wheel_speeds(x)
2
wref = mecanum_wheel_speeds(nu_ref, lx, ly, r)
3
if name == "mec_wheel_clip":
4
    wref = [max(-OMEGA_MAX, min(OMEGA_MAX, w)) for w in wref]
5
    i_cmd = [pids[i].update(wref[i], omega[i]) for i in range(4)]
6
elif name == "mec_wheel_scale":
7
    wref, _ = scale_to(wref, OMEGA_MAX)
8
    v = [
9
        pids[i].update(wref[i], omega[i], 0.0, scaled)
10
        for i in range(4)
11
    ]
12
    i_cmd, scaled = scale_to(v, plant.i_max)
13
else:
14
    _, hit = scale_to(wref, OMEGA_MAX)
15
    s = OMEGA_MAX / max(abs(w) for w in wref) if hit else 1.0
16
    nu_hat = mecanum_forward(omega, lx, ly, r)
17
    w = [
18
        pids[a].update(s * nu_ref[a], nu_hat[a], 0.0, scaled)
19
        for a in range(3)
20
    ]
21
    i_cmd, scaled = scale_to(
22
        mecanum_currents(w, lx, ly, r, kt), plant.i_max
23
    )

这里有三处要看。测量：控制器看到的是 omega（四个轮速，真值，没有噪声），车体系 PI 用 mecanum_forward 从轮速恢复 $\hat\nu$。缩放标志：scaled 在循环末尾更新、在下一拍的 update 里当 hold_integral 用，读到的是上一拍的值，和第 7 篇一样；逐轮截断这一支不用它，它的 Pid 自己带 $\pm20$ A 限幅，CLAMP 照常工作。记录：null_i 是最终发给对象的那一组电流（限幅或缩放之后）的 $n^Ti$，不是 Pid 内部的某个量。

车体系 PI 的整定在每个轴上一样：$M_{eff}\dot\nu = F - c_v\nu$ 是一阶对象，按第 2 篇的公式放在 $\omega_n = 30$、$\zeta = 0.7$：

1
def body_pid_configs(plant: Mecanum) -> list[PidConfig]:
2
    """PI placed at WN, ZETA on each body axis: meff nu' = F - cv nu."""
3
    cfgs = []
4
    for meff in plant.inertia():
5
        kp = 2.0 * ZETA * WN * meff - plant.cv
6
        cfgs.append(PidConfig(kp, WN * WN * meff, 0.0, MEC_TS))
7
    return cfgs

编译和风格检查#

编译参数和前几篇一样：C 是 gcc -std=c11 -O2 -Wall -Wextra -Wpedantic -Werror（15.3.0），C++ 是 g++ -std=c++20 加同样的警告，Rust 是 rustc 1.95.0、edition 2024，cargo clippy --release -- -D warnings。风格检查：C 用内核的 checkpatch.pl（--no-tree，忽略 SPDX 和 typedef 两项），0 errors、0 warnings；C++ 用 clang-format 的 Google 风格（-Werror）；Python 用 ruff format --check 和 ruff check，行宽 79；Rust 用 cargo fmt --check。四项都在提交前过了。

一个小插曲：checkpatch.pl 对 mimo.h 里第一个用到 pl_real 的声明报了 “need consistent spacing around ’*’”，因为它不认识这个类型名。在 #include 之后放一行 #define PL_MEC_WHEELS 4 就不报了（它显然是靠文件里已有的内容猜类型）。这个宏是真的在表达“4 个轮子”，我就留着了；更干净的写法我没有找到。