/* A10-R2 之一：`t_safety` **一圈的形状与账**（需求 §10.3、计划 §5.5）。 判据本身在 `test_t_safety_rules.c` 里，这里只管「这一圈发了什么、发给了谁」。 ---- R1 → R2，这个文件测的东西换了重心 ------------------------------------ R1：一条总线、六片不同地址的 INA226，一圈 13 次事务。那时唯一会出事的形态是 「地址算错」，而地址算错**会 NAK**，一眼就能看见。 R2：五片刀片完全同构（INA226 全是 0x40、PCA9555 全是 0x20），区分它们的 唯一手段是底板 TCA9548A 的通道。于是出现了一种 R1 根本没有的错误形态： **通道选错 ⇒ 读到另一台手机的电压电流**，而量纲、范围、变化趋势全都正常， 没有任何一层会报错、会 NAK、会计数。⭐ 本文件里带星的那两条就是它的拦网。 ⚠️ 两条能成立的前提： · 假总线里有一颗**真的 mux**（`sim_i2c_add_mux`）—— 没有它，五片刀片会 塌成一片，「选错通道」在宿主机上一次也复现不出来； · 假 I²C **真的把虚拟时钟花掉**（`sim_i2c_set_bus_time`，默认开）—— 没有它，「20 ms 周期」就退化成「测 delay 参数传对了没」，而真正会出事的是 「巡检自己占掉了 2.34 ms，节拍还准不准」。 */ #include #include #include "board_pins.h" #include "hal_gpio.h" #include "hal_i2c.h" #include "hal_i2c_acct.h" #include "hal_lock.h" #include "hal_time.h" #include "i2cbus.h" #include "ina226.h" #include "pca9555.h" #include "rail.h" #include "rail_cfg.h" #include "sched.h" #include "sim_hal.h" #include "slot.h" #include "t_actuator.h" #include "t_safety.h" #include "tasks.h" #include "tca9548a.h" #include "unity.h" #define N PHONERAIL_RAIL_COUNT /* 主干上那两片 DAC（`rail.h` 的 U6 / U7）。巡检一次也不该碰它们 —— 设定值是影子里的（`rail_setpoint_mv()`），去读 DAC 就是每圈多五次事务。 */ #define DAC_ADDR_A 0x4A #define DAC_ADDR_B 0x4B /* ⭐ 五路预置成**互不相同**的电压：CH1 3600 → CH5 4000 mV。 只有值各不相同，「读到了另一台手机的数据」才留得下痕迹。 */ #define RAIL_MV(rail) (3600 + 100 * ((rail) - 1)) /* 电流也各不相同：CH1 1 A → CH5 5 A。 */ #define RAIL_UA(rail) ((rail) * 1000000) /* 五片刀片的 Port1（四个故障/PG 信号，开漏上拉 ⇒ 静息 0x0F）各驱动成不同的图案， 每一片**恰好有一个信号在响**，而且响的不是同一个。 全驱成一样的话，「五路读的都是同一片」这条错就看不出来。 */ static const uint8_t k_port1[N] = { (uint8_t)(0x0Fu & ~(1u << PCA9555_BIT_EFUSE_FLT)), /* CH1：eFuse 报故障 */ (uint8_t)(0x0Fu & ~(1u << PCA9555_BIT_BUCK_PG)), /* CH2：Buck PG 掉了 */ (uint8_t)(0x0Fu & ~(1u << PCA9555_BIT_INA_ALERT)), /* CH3：INA226 在告警 */ (uint8_t)(0x0Fu & ~(1u << PCA9555_BIT_EFUSE_PG)), /* CH4：eFuse PG 掉了 */ 0x0Fu, /* CH5：什么事都没有 */ }; static safety_snap_t g_snap; /* `board_up()` 跑完那一刻的基准值。启动本身会在总线和引脚上留下痕迹， 拿绝对值去断言等于把启动的账算进第一圈（那正是 `t_safety_init()` 对齐游标要防的事）。 */ static uint32_t g_resets0; /* `MUX_RST#` 复位次数 —— `i2cbus_init()` 必定留下一次，见下 */ static int ch_of(int rail) { return (int)rail_cfg(rail)->mux_ch; } static sim_i2c_dev_t *ina_of(int rail) { return sim_i2c_dev_ch(ch_of(rail), rail_cfg(rail)->ina_addr); } static sim_i2c_dev_t *pca_of(int rail) { return sim_i2c_dev_ch(ch_of(rail), PCA9555_ADDR); } static sim_i2c_dev_t *mux_dev(void) { return sim_i2c_dev(TCA9548A_ADDR); } /* 从**假器件的寄存器**注入，不去改快照 —— 改快照等于跳过驱动和 mux， 那样连「读的是哪一片」都证明不了。 */ static void put_vi(int rail, int mv, int ua) { const int ch = ch_of(rail); const uint8_t addr = rail_cfg(rail)->ina_addr; TEST_ASSERT_EQUAL_INT(0, mv % 5); /* 母线 LSB 1.25 mV：不是 5 的倍数就注不准 */ sim_i2c_set_reg_ch(ch, addr, INA226_REG_BUS_V, (uint16_t)(mv * 4 / 5)); sim_i2c_set_reg_ch(ch, addr, INA226_REG_CURRENT, (uint16_t)(int16_t)(ua / INA226_CURRENT_LSB_UA)); } /* 假板子：主干（mux + 输入侧 INA226 + 两片 DAC）+ 五片刀片（各 INA226 + PCA9555）。 */ static void board_up(void) { const hal_i2c_cfg_t cfg = { .sda_gpio = BOARD_PIN_I2C_SDA, .scl_gpio = BOARD_PIN_I2C_SCL, .freq_hz = 400000 }; TEST_ASSERT_EQUAL_INT(HAL_OK, hal_i2c_init(&cfg)); TEST_ASSERT_EQUAL_INT(HAL_OK, hal_lock_init()); sim_i2c_add_mux(TCA9548A_ADDR, BOARD_PIN_MUX_RST_N); for (int rail = 1; rail <= N; rail++) { const int ch = ch_of(rail); sim_i2c_add_ch(ch, rail_cfg(rail)->ina_addr, 2); put_vi(rail, RAIL_MV(rail), RAIL_UA(rail)); sim_pca9555_attach_ch(rail - 1, ch, PCA9555_ADDR); sim_pca9555_drive(rail - 1, 1, k_port1[rail - 1]); } sim_i2c_add(INA226_ADDR_INPUT, 2); sim_i2c_set_reg(INA226_ADDR_INPUT, INA226_REG_BUS_V, (uint16_t)(12000 * 4 / 5)); sim_i2c_set_reg(INA226_ADDR_INPUT, INA226_REG_CURRENT, (uint16_t)(2000000 / 500)); sim_i2c_add(DAC_ADDR_A, 2); sim_i2c_add(DAC_ADDR_B, 2); TEST_ASSERT_EQUAL_INT(HAL_OK, i2cbus_init()); TEST_ASSERT_EQUAL_INT(HAL_OK, rail_en_init()); TEST_ASSERT_EQUAL_INT(HAL_OK, slot_prsnt_init()); /* ⚠️ `PRSNT#` 配的是**上拉输入**，没人驱动就是高 = 刀片不在位。 不驱低的话每一圈都会触发「刀片不在位」判据，而现象是「所有用例都多出几条 事件、五路自己关掉」—— 看上去像判据写错了，其实是假板子插反了。 */ for (int rail = 1; rail <= N; rail++) { sim_gpio_drive(rail_cfg(rail)->prsnt_n, 0); } slot_prsnt_poll(); for (int rail = 1; rail <= N; rail++) { TEST_ASSERT_EQUAL_INT(HAL_OK, slot_init(rail)); } t_actuator_init(NULL, NULL); rail_setpoint_reset(); t_safety_init(&g_snap); /* ⚠️ 这里一定是 1，不是 0：`i2cbus_init()` 先把 `MUX_RST#` 配成输出（两个 HAL 都保证「配完是 0」）再写 1，中间那一瞬间对真器件就是一次复位脉冲，假 mux 如实照做。这个窗口是已知且可接受的（那时还没人用总线），但**不能当它不存在** —— 所以后面的用例一律和这个基准比差值。 */ g_resets0 = sim_i2c_mux_resets(); TEST_ASSERT_EQUAL_UINT32(1, g_resets0); } void setUp(void) { sim_hal_reset(); board_up(); } /* 每个用例收尾都查一次「有没有同时开两路通道」。真板上那是两片同地址的 INA226 一起应答、读回来是线与 —— 数值正常、还很稳，没有任何一层会报错。 所以这个数**必须恒为 0**，放在 tearDown 里等于给每一条用例都加上这条断言。 */ void tearDown(void) { TEST_ASSERT_EQUAL_UINT32(0, sim_i2c_ambiguous()); } /* ---- 一圈的事务账（计划 §5.5） ------------------------------------------- */ /* 一圈正好 `t_safety_cycle_txns()` 次事务，而且**每一片器件被读的次数是钉死的**。 顺手多读一个寄存器（比如 check 一下 Calibration）会当场变红， 然后写的人才会想起来去把预算那一行也改了。 */ static void test_one_cycle_is_exactly_the_budgeted_transaction_count(void) { uint32_t ina_rd[N], pca_rd[N], pca_wr[N]; for (int rail = 1; rail <= N; rail++) { ina_rd[rail - 1] = ina_of(rail)->n_read; pca_rd[rail - 1] = pca_of(rail)->n_read; pca_wr[rail - 1] = pca_of(rail)->n_write; } const uint32_t in_rd = sim_i2c_dev(INA226_ADDR_INPUT)->n_read; const uint32_t mux_wr = mux_dev()->n_write; const uint32_t mux_rd = mux_dev()->n_read; const uint32_t dac_rd = sim_i2c_dev(DAC_ADDR_A)->n_read + sim_i2c_dev(DAC_ADDR_B)->n_read; const uint32_t before = hal_i2c_acct_txns(); TEST_ASSERT_EQUAL_INT(HAL_OK, t_safety_step(&g_snap)); TEST_ASSERT_EQUAL_UINT32(t_safety_cycle_txns(), hal_i2c_acct_txns() - before); TEST_ASSERT_EQUAL_UINT32(t_safety_cycle_txns(), g_snap.txns); /* 逐片对账：五路各 2 次 INA226 寄存器读 + 1 次 PCA9555 输入读； 主干那片 INA226 2 次；mux 被写 6 次（五路各一次 + 回主干一次）。 ⚠️ 比的是**这一圈的增量**：`slot_init()` 自己就读了 PCA9555 六次（写一个回读一个）， 拿绝对值比等于把启动的账算进巡检。 */ for (int rail = 1; rail <= N; rail++) { TEST_ASSERT_EQUAL_UINT32(2, ina_of(rail)->n_read - ina_rd[rail - 1]); TEST_ASSERT_EQUAL_UINT32(1, pca_of(rail)->n_read - pca_rd[rail - 1]); /* 「读输入」在线上是「写一个寄存器号 + 读两字节」，所以写计数也会 +1。 真正要拦的是**写输出锁存器**：平安无事的一圈里，最后落到这一片上的写 只能是那一个字节的寄存器指针（0x00），不能是 OUTPUT0（0x02）。 */ TEST_ASSERT_EQUAL_UINT32(1, pca_of(rail)->n_write - pca_wr[rail - 1]); TEST_ASSERT_EQUAL_UINT8(PCA9555_REG_INPUT0, pca_of(rail)->last_write[0]); TEST_ASSERT_EQUAL_UINT8(1, pca_of(rail)->last_write_len); TEST_ASSERT_EQUAL_UINT8(0, sim_pca9555_output(rail - 1, 0)); /* 键与 VBUS 全是 0 */ } TEST_ASSERT_EQUAL_UINT32(2, sim_i2c_dev(INA226_ADDR_INPUT)->n_read - in_rd); TEST_ASSERT_EQUAL_UINT32((uint32_t)N + 1u, mux_dev()->n_write - mux_wr); TEST_ASSERT_EQUAL_UINT32(0, mux_dev()->n_read - mux_rd); /* 选完不回读，那是 probe 的事 */ /* 设定值从影子里取（`rail_setpoint_mv()`），判据一次也不该去读 DAC。 读一次就是每圈多五次事务，把 §10.3 的预算直接顶穿。 */ TEST_ASSERT_EQUAL_UINT32( 0, sim_i2c_dev(DAC_ADDR_A)->n_read + sim_i2c_dev(DAC_ADDR_B)->n_read - dac_rd); } /* 静态预算与实测必须**一模一样**。不一样只有两种可能：巡检里多读/少读了东西， 或者有别的任务在同一圈里插了事务进来 —— 两种都该被这条拦住。 （这也是为什么预算函数不是一个写死的常数：它按同一个算式从事务形状来。） */ static void test_measured_bus_time_equals_the_static_budget(void) { for (int i = 0; i < 10; i++) { TEST_ASSERT_EQUAL_INT(HAL_OK, t_safety_step(&g_snap)); TEST_ASSERT_EQUAL_UINT32(t_safety_budget_us(), g_snap.bus_us); TEST_ASSERT_EQUAL_UINT32(t_safety_cycle_txns(), g_snap.txns); } } /* 计划 §5.5 那张表的可执行版本：23 次事务 ≈ 2.5 ms / 12.5 %。 这里按线上真实发生的位数算，得 6×20 + 17×48 = 936 位 = 2340 µs = 11.7 %。 §5.5 手算的 2.48 ms 用的是每次事务的近似值，差的那 140 µs 是近似的账。 ⚠️ 这一条同时钉住「R1 的 13 次 / 1.56 ms 已经不是这块板子的数了」—— 把预算函数改回 R1 那版，这里第一行就红。 */ static void test_the_bus_account_matches_plan_5_5(void) { TEST_ASSERT_EQUAL_UINT32(23, t_safety_cycle_txns()); TEST_ASSERT_EQUAL_UINT32(20, hal_i2c_txn_bits(1, 0)); /* mux 选通：裸写一个字节 */ TEST_ASSERT_EQUAL_UINT32(48, hal_i2c_txn_bits(1, 2)); /* 寄存器读 */ TEST_ASSERT_EQUAL_UINT32(2340, t_safety_budget_us()); TEST_ASSERT_EQUAL_INT(HAL_OK, t_safety_step(&g_snap)); const uint32_t period = task_desc(TASK_SAFETY)->period_ms; const uint32_t pm = t_safety_load_permille(g_snap.bus_us, period); TEST_ASSERT_EQUAL_UINT32(117, pm); /* 计划 §5.5 的「≈12.4 %」：11 %~13 % 都算对得上。超出就是巡检里多读/少读了东西。 */ TEST_ASSERT_TRUE(pm >= 110 && pm <= 130); /* 一圈占的总线时间必须远小于周期，否则巡检自己就把节拍吃掉了。 */ TEST_ASSERT_TRUE(g_snap.bus_us < period * 1000u / 4u); char line[160]; const int n = t_safety_format(&g_snap, line, sizeof(line)); TEST_ASSERT_TRUE(n > 0 && n < (int)sizeof(line)); TEST_ASSERT_NOT_NULL(strstr(line, "txns=23")); TEST_ASSERT_NOT_NULL(strstr(line, "bus=2340 us/20 ms")); TEST_ASSERT_NOT_NULL(strstr(line, "load=11.7%")); printf(" %s（计划 §5.5：≈2.5 ms / 12.4 %%）\n", line); } /* ---- ⭐ R2 最危险的错误形态：读到了另一台手机 ---------------------------- */ /* 五个通道上的假 INA226 预置成**互不相同**的电压与电流，跑一圈，逐路对上。 通道选错的后果是「读到另一台手机的数据」—— 量纲、范围、变化趋势全都正常， 遥测曲线好看得很，五台机器的过压判据却全部盯错了对象。 R1 里这条错误不存在（六片六个地址，错了就 NAK）；R2 里它不报错、不 NAK、 不计数，**只有值本身能拆穿它**。 */ static void test_each_rail_is_read_on_its_own_mux_channel(void) { TEST_ASSERT_EQUAL_INT(HAL_OK, t_safety_step(&g_snap)); for (int rail = 1; rail <= N; rail++) { TEST_ASSERT_TRUE(g_snap.rail_ok[rail - 1]); TEST_ASSERT_EQUAL_INT32(RAIL_MV(rail), g_snap.rail[rail - 1].bus_mv); TEST_ASSERT_EQUAL_INT32(RAIL_UA(rail), g_snap.rail[rail - 1].current_ua); } /* 主干那片（0x43）不在任何通道后面，它的值不许混进五路里。 */ TEST_ASSERT_TRUE(g_snap.input_ok); TEST_ASSERT_EQUAL_INT32(12000, g_snap.input.bus_mv); /* 换一组值再跑一圈：万一上面那组恰好被「按顺序发牌」蒙对，换一组就露馅。 */ for (int rail = 1; rail <= N; rail++) { put_vi(rail, 4000 - 100 * (rail - 1), -(rail * 100000)); /* 顺序反过来、电流转负 */ } TEST_ASSERT_EQUAL_INT(HAL_OK, t_safety_step(&g_snap)); for (int rail = 1; rail <= N; rail++) { TEST_ASSERT_EQUAL_INT32(4000 - 100 * (rail - 1), g_snap.rail[rail - 1].bus_mv); TEST_ASSERT_EQUAL_INT32(-(rail * 100000), g_snap.rail[rail - 1].current_ua); } } /* 同一件事，换 PCA9555 那一路：五片的四个故障信号各响一个，逐片对上。 INA226 那条对上了、这条没对上，说明「选通道」和「读哪一片」在两条路径上 各自算了一遍 —— 而 `slot.c` 存在的全部理由就是让这两件事只算一次。 */ static void test_each_blade_reports_its_own_pca9555_inputs(void) { TEST_ASSERT_EQUAL_INT(HAL_OK, t_safety_step(&g_snap)); for (int rail = 1; rail <= N; rail++) { TEST_ASSERT_TRUE(g_snap.io_ok[rail - 1]); TEST_ASSERT_EQUAL_UINT8(k_port1[rail - 1], g_snap.io[rail - 1].port1); } /* 换成语义判读再验一遍（极性写反在原始字节上是看不出来的）。 */ TEST_ASSERT_TRUE(pca9555_efuse_fault(&g_snap.io[0])); /* CH1 FLT# 低 = 有故障 */ TEST_ASSERT_FALSE(pca9555_efuse_fault(&g_snap.io[1])); TEST_ASSERT_FALSE(pca9555_buck_pg(&g_snap.io[1])); /* CH2 Buck PG 低 = 不良 */ TEST_ASSERT_TRUE(pca9555_buck_pg(&g_snap.io[0])); TEST_ASSERT_TRUE(pca9555_ina_alert(&g_snap.io[2])); /* CH3 ALERT 低 = 在告警 */ TEST_ASSERT_FALSE(pca9555_ina_alert(&g_snap.io[3])); TEST_ASSERT_FALSE(pca9555_efuse_pg(&g_snap.io[3])); /* CH4 eFuse PG 低 */ TEST_ASSERT_TRUE(pca9555_efuse_pg(&g_snap.io[4])); /* CH5 全好 */ } /* 任何时刻都只许开一路通道，而且一圈走完停在**主干**上。 同时开两路在真板上是两片一起应答、读回线与（数值正常、还很稳）—— `sim_i2c_ambiguous()` 是这件事在宿主机上唯一的痕迹。 */ static void test_the_mux_never_has_two_channels_open(void) { for (int i = 0; i < 50; i++) { TEST_ASSERT_EQUAL_INT(HAL_OK, t_safety_step(&g_snap)); TEST_ASSERT_EQUAL_UINT32(0, sim_i2c_ambiguous()); /* 一圈的最后一次选通是回主干（读输入侧那片），所以收尾时通道是全关的。 */ TEST_ASSERT_EQUAL_INT(-1, sim_i2c_mux_ch()); TEST_ASSERT_EQUAL_UINT8(0, sim_i2c_mux_mask()); } TEST_ASSERT_EQUAL_UINT32(0, i2cbus_select_fails()); TEST_ASSERT_EQUAL_UINT32(0, sim_i2c_mux_resets() - g_resets0); /* 一切正常时不该再复位 */ } /* 通道 5 上是 CH224A（PD 受电芯片），通道 6 / 7 悬空。巡检一次也不许选到它们。 选到通道 5 再去读 0x40 会一个字节也读不到，而现象是「这一路电压电流突然全是 0」 —— 看上去像刀片拔了。这里在那三路上各挂一片 0x40，它们必须一次也没被碰过。 */ static void test_the_unused_channels_are_never_selected(void) { sim_i2c_dev_t *pd = sim_i2c_add_ch(TCA9548A_CH_PD, INA226_ADDR_RAIL, 2); sim_i2c_dev_t *sp6 = sim_i2c_add_ch(6, INA226_ADDR_RAIL, 2); sim_i2c_dev_t *sp7 = sim_i2c_add_ch(7, INA226_ADDR_RAIL, 2); for (int i = 0; i < 5; i++) { TEST_ASSERT_EQUAL_INT(HAL_OK, t_safety_step(&g_snap)); } TEST_ASSERT_EQUAL_UINT32(0, pd->n_read); TEST_ASSERT_EQUAL_UINT32(0, sp6->n_read); TEST_ASSERT_EQUAL_UINT32(0, sp7->n_read); TEST_ASSERT_EQUAL_UINT32(0, sim_i2c_ambiguous()); /* 它们也没和刀片撞上过 */ } /* ---- 节拍 ---------------------------------------------------------------- */ /* 500 圈。每一圈都要**正好**落在 20 ms 的格子上，而且真实唤醒时刻（µs 级） 对理想时刻的偏差始终 < 1 ms —— 这就是 §10.3 的「20 ms ±1 ms」。 会漂的实现（干完睡 20）在这里第一圈就出局：R2 一圈自己要占 2.34 ms， 那样周期是 22.34 ms，500 圈之后差出 1.17 s。 */ static void test_safety_holds_a_20ms_beat_for_500_cycles(void) { sched_periodic_t tick; sched_periodic_init(&tick, task_desc(TASK_SAFETY)->period_ms); /* 先确认「干活」在 sim 里真的花掉了时间。不然下面 500 圈测的只是 「delay 参数传对了没」—— 巡检耗时为零的话，什么实现都能踩准 20 ms。 */ const uint64_t t0 = hal_time_now_us(); TEST_ASSERT_EQUAL_INT(HAL_OK, t_safety_step(&g_snap)); TEST_ASSERT_EQUAL_UINT64(t_safety_budget_us(), hal_time_now_us() - t0); sched_periodic_wait(&tick); /* ⚠️ 相位起点是**第一次醒来那一刻**，不是 0：R2 的启动自己就要跑 mux 认件 + 五片 PCA9555 初始化，上百次事务在虚拟时钟上是真花掉了的。拿绝对 0 当起点， 测出来的是「启动花了多久」，和节拍没关系。 */ const uint64_t base_us = hal_time_now_us(); uint32_t prev_ms = hal_time_now_ms(); for (int i = 1; i < 500; i++) { TEST_ASSERT_EQUAL_INT(HAL_OK, t_safety_step(&g_snap)); sched_periodic_wait(&tick); const uint32_t now_ms = hal_time_now_ms(); TEST_ASSERT_EQUAL_UINT32(20, now_ms - prev_ms); prev_ms = now_ms; const int64_t ideal_us = (int64_t)base_us + (int64_t)i * 20000; const int64_t err_us = (int64_t)hal_time_now_us() - ideal_us; TEST_ASSERT_TRUE(err_us > -1000 && err_us < 1000); } TEST_ASSERT_EQUAL_UINT32(0, tick.overruns); TEST_ASSERT_EQUAL_UINT32(500, g_snap.cycles); TEST_ASSERT_EQUAL_UINT32(0, g_snap.skipped); TEST_ASSERT_EQUAL_UINT32(0, g_snap.events); } /* 20 ms 的周期必须**长于** INA226 的一帧转换时间（AVG=4 × 2×1.1 ms = 8.8 ms）。 短了的话同一帧会被读两次，而现象是「电流特别稳」—— 不是任何一种错误， 不会 NAK、不会报警、遥测曲线还更好看。R2 一圈占 2.34 ms，离 8.8 ms 还很远， 所以每一圈拿到的都是新的一帧。 */ static void test_the_period_outlives_one_ina226_conversion(void) { const uint32_t period_us = task_desc(TASK_SAFETY)->period_ms * 1000u; TEST_ASSERT_EQUAL_UINT32(8800, (uint32_t)INA226_CONV_US); TEST_ASSERT_TRUE(period_us > (uint32_t)INA226_CONV_US); /* 两倍余量：巡检自己占的总线时间加进去也不能逼近一帧。 */ TEST_ASSERT_TRUE(period_us >= 2u * (uint32_t)INA226_CONV_US); TEST_ASSERT_TRUE(t_safety_budget_us() < (uint32_t)INA226_CONV_US); TEST_ASSERT_TRUE(task_table_ok()); /* 任务表自检里钉着同一条 */ } /* ---- 加锁纪律 ------------------------------------------------------------ */ /* 一整圈里的每一次事务都持着 I²C 锁；出了这个函数锁必须已经放掉。 R2 里这一圈要拿六次锁（五路 + 主干），每一次都得规规矩矩。 */ static void test_every_transaction_happens_under_the_i2c_lock(void) { sim_lock_require(HAL_LOCK_I2C, true); const uint32_t takes0 = sim_lock_takes(HAL_LOCK_I2C); for (int i = 0; i < 5; i++) { TEST_ASSERT_EQUAL_INT(HAL_OK, t_safety_step(&g_snap)); } TEST_ASSERT_EQUAL_UINT32(0, sim_lock_violations(HAL_LOCK_I2C)); TEST_ASSERT_FALSE(hal_lock_held(HAL_LOCK_I2C)); /* 出门放锁 */ TEST_ASSERT_EQUAL_INT(-1, sim_lock_owner(HAL_LOCK_I2C)); /* 一圈六次 `xact` = 六次拿锁（R1 是一把大锁包住整圈，只拿一次）。 这个数正是「给 t_actuator 留的缝」有几条 —— 变少了缝就没了。 */ TEST_ASSERT_EQUAL_UINT32(5u * ((uint32_t)N + 1u), sim_lock_takes(HAL_LOCK_I2C) - takes0); } /* 上一条不是句空话：不拿锁直接读一片 INA226，违规计数必须 +1。 检查本身失灵的话，上一条会永远绿。 */ static void test_the_lock_check_itself_can_fail(void) { sim_lock_require(HAL_LOCK_I2C, true); ina226_vi_t vi; (void)ina226_read_vi(rail_cfg(1)->ina_addr, &vi); TEST_ASSERT_EQUAL_UINT32(2, sim_lock_violations(HAL_LOCK_I2C)); /* 两次事务 */ } /* 拿不到锁：**跳过，不死等**（t_safety.h 规矩 1）。死等的现象是巡检整个停摆， 而它是优先级最高的那个任务 —— 停摆了没有任何人会发现。 ⚠️ R2 的一笔新账：一圈要等**六次**锁，最坏 6 × 5 = 30 ms，**比 20 ms 的周期还长** （R1 只等一次，5 ms）。这条断言把这个数钉在这里：谁改了超时常量或者 `xact` 的次数，都得先来正面回答「一圈最坏等多久」这个问题。 */ static void test_a_busy_bus_skips_the_cycle_instead_of_waiting_forever(void) { TEST_ASSERT_EQUAL_INT(HAL_OK, t_safety_step(&g_snap)); /* 先跑一圈好的，留下基准 */ const int32_t mv0 = g_snap.rail[0].bus_mv; const uint32_t txns0 = hal_i2c_acct_txns(); const uint32_t en_writes0 = sim_gpio_writes(rail_cfg(1)->efuse_en); sim_lock_set_task(1); /* 假装 t_actuator 正在按键，总线在它手里 */ TEST_ASSERT_EQUAL_INT(HAL_OK, hal_lock_take(HAL_LOCK_I2C, 10)); sim_lock_set_task(0); const uint32_t t0 = hal_time_now_ms(); TEST_ASSERT_EQUAL_INT(HAL_ERR_TIMEOUT, t_safety_step(&g_snap)); /* 这一圈**什么也没做**：一次事务没发、一根引脚没动、快照原封不动。 */ TEST_ASSERT_EQUAL_UINT32(0, hal_i2c_acct_txns() - txns0); TEST_ASSERT_EQUAL_UINT32(0, g_snap.txns); TEST_ASSERT_EQUAL_UINT32(0, g_snap.bus_us); TEST_ASSERT_EQUAL_INT32(mv0, g_snap.rail[0].bus_mv); TEST_ASSERT_EQUAL_UINT32(en_writes0, sim_gpio_writes(rail_cfg(1)->efuse_en)); TEST_ASSERT_EQUAL_UINT32(0, g_snap.events); /* 但这一圈**被记下来了**：不计数的跳过等于悄悄失明。 */ TEST_ASSERT_EQUAL_UINT32(1, g_snap.skipped); TEST_ASSERT_EQUAL_UINT32(2, g_snap.cycles); /* ⭐ **整圈的账，不是单次的账。** R2 一圈要拿六次锁，六次各等满 5 ms 就是 30 ms —— 比 20 ms 的周期还长，现象是巡检成片丢拍而每一次 `xact` 都老老实实 按时返回了。所以 `T_SAFETY_LOCK_BUDGET_MS` 是一条整圈的闸： 花到 10 ms 就不再试剩下的路。 这里断言的正是那条闸：**只试了 2 次**（5 + 5 = 10 ms 用完预算）， 而不是六次全试一遍。把预算那一段删掉的话，下面两条会变成 6 和 30。 */ TEST_ASSERT_EQUAL_UINT32(T_SAFETY_LOCK_BUDGET_MS / T_SAFETY_LOCK_TIMEOUT_MS, i2cbus_lock_timeouts()); TEST_ASSERT_EQUAL_UINT32(T_SAFETY_LOCK_BUDGET_MS, hal_time_elapsed_ms(t0)); /* 而且整圈花掉的时间**必须短于巡检周期**，否则节拍本身就保不住了。 */ TEST_ASSERT_TRUE(hal_time_elapsed_ms(t0) < task_desc(TASK_SAFETY)->period_ms); /* 总线还回来，下一圈照常。 */ sim_lock_set_task(1); hal_lock_give(HAL_LOCK_I2C); sim_lock_set_task(0); TEST_ASSERT_EQUAL_INT(HAL_OK, t_safety_step(&g_snap)); TEST_ASSERT_EQUAL_UINT32(t_safety_cycle_txns(), g_snap.txns); TEST_ASSERT_EQUAL_UINT32(1, g_snap.skipped); } /* ---- 器件出问题的时候（§10.2：失联 ≠ 断电） ------------------------------ */ /* 一片刀片的 INA226 掉线，**剩下四路的读照常**。中断这一圈的现象是 「一片 INA226 掉线，五路判据全瞎」—— 而那四台手机什么毛病都没有。 */ static void test_one_dead_ina226_does_not_stop_the_other_four(void) { sim_i2c_set_present_ch(ch_of(3), rail_cfg(3)->ina_addr, false); TEST_ASSERT_EQUAL_INT(HAL_ERR_NAK, t_safety_step(&g_snap)); TEST_ASSERT_FALSE(g_snap.rail_ok[2]); for (int rail = 1; rail <= N; rail++) { if (rail == 3) { continue; } TEST_ASSERT_TRUE(g_snap.rail_ok[rail - 1]); TEST_ASSERT_EQUAL_INT32(RAIL_MV(rail), g_snap.rail[rail - 1].bus_mv); TEST_ASSERT_TRUE(g_snap.io_ok[rail - 1]); } /* 坏掉那一路的 PCA9555 没跟着遭殃（是两颗器件，不是一颗）。 */ TEST_ASSERT_TRUE(g_snap.io_ok[2]); TEST_ASSERT_EQUAL_UINT8(k_port1[2], g_snap.io[2].port1); TEST_ASSERT_TRUE(g_snap.input_ok); TEST_ASSERT_EQUAL_UINT32(1, g_snap.i2c_errors); /* 读 V 那一次就 NAK 了，读 I 那一次不会再发 ⇒ 这一圈**少一次事务**。 把这个数写下来，是为了让「失联之后还傻读第二次」也会变红。 */ TEST_ASSERT_EQUAL_UINT32(t_safety_cycle_txns() - 1u, g_snap.txns); TEST_ASSERT_EQUAL_UINT32( t_safety_budget_us() - (uint32_t)hal_i2c_bits_to_us(hal_i2c_txn_bits(1, 2)), g_snap.bus_us); } /* 空槽**一个字节也不许发**（2026-09-27 上板实测）。空机时五路无条件各读一次， 真板上每次 NAK 要十几 ms，槽 1 两次就把整圈预算吃光 —— 槽 2~5 和主干的 0x43 一圈都没读到，输入侧监控整个是瞎的。这里把空槽的器件也拔掉：谁碰了它就会 NAK、 `i2c_errors` 立刻非零；全空那一圈还要求主干那片照读不误。 */ static void test_empty_slots_are_never_touched_and_the_input_still_reads(void) { const int empty[] = { 2, 4 }; for (unsigned i = 0; i < sizeof(empty) / sizeof(empty[0]); i++) { const int rail = empty[i]; sim_gpio_drive(rail_cfg(rail)->prsnt_n, 1); /* 高 = 不在位 */ sim_i2c_set_present_ch(ch_of(rail), rail_cfg(rail)->ina_addr, false); sim_i2c_set_present_ch(ch_of(rail), PCA9555_ADDR, false); } TEST_ASSERT_EQUAL_INT(HAL_OK, t_safety_step(&g_snap)); TEST_ASSERT_EQUAL_UINT32(0, g_snap.i2c_errors); TEST_ASSERT_EQUAL_UINT32(0, g_snap.skipped); for (int rail = 1; rail <= N; rail++) { const bool here = (rail != 2 && rail != 4); TEST_ASSERT_EQUAL(here, g_snap.rail_ok[rail - 1]); TEST_ASSERT_EQUAL(here, g_snap.io_ok[rail - 1]); TEST_ASSERT_EQUAL(here, g_snap.present[rail - 1]); } TEST_ASSERT_TRUE(g_snap.input_ok); /* 五槽全空（上板时的真实状态）：总线上只剩主干那一片。 */ for (int rail = 1; rail <= N; rail++) { sim_gpio_drive(rail_cfg(rail)->prsnt_n, 1); sim_i2c_set_present_ch(ch_of(rail), rail_cfg(rail)->ina_addr, false); sim_i2c_set_present_ch(ch_of(rail), PCA9555_ADDR, false); } TEST_ASSERT_EQUAL_INT(HAL_OK, t_safety_step(&g_snap)); TEST_ASSERT_EQUAL_UINT32(0, g_snap.i2c_errors); TEST_ASSERT_TRUE(g_snap.input_ok); TEST_ASSERT_EQUAL_INT32(12000, g_snap.input.bus_mv); } /* 读失败时保留**上一圈的值**并把 ok 标成 false —— 不清零。 清零的话，判据会看到一个 0 V 的「正常数」；而 `ok` 正是让它先看一眼 「这数是不是新的」。拿一个没更新的电压去判过压是最难查的那种错。 */ static void test_a_failed_read_keeps_the_stale_value_and_flags_it(void) { TEST_ASSERT_EQUAL_INT(HAL_OK, t_safety_step(&g_snap)); TEST_ASSERT_EQUAL_INT32(RAIL_MV(1), g_snap.rail[0].bus_mv); sim_i2c_set_present_ch(ch_of(1), rail_cfg(1)->ina_addr, false); /* 器件掉线之后把寄存器也改掉：万一实现偷偷读到了，值就会跟着变。 */ put_vi(1, 3000, 0); for (int i = 0; i < 5; i++) { TEST_ASSERT_EQUAL_INT(HAL_ERR_NAK, t_safety_step(&g_snap)); TEST_ASSERT_FALSE(g_snap.rail_ok[0]); TEST_ASSERT_EQUAL_INT32(RAIL_MV(1), g_snap.rail[0].bus_mv); /* 还是上一圈那个 */ TEST_ASSERT_EQUAL_INT32(RAIL_UA(1), g_snap.rail[0].current_ua); } /* 器件回来了就立刻用新值（`ok` 不是个一去不返的标志）。 */ sim_i2c_set_present_ch(ch_of(1), rail_cfg(1)->ina_addr, true); TEST_ASSERT_EQUAL_INT(HAL_OK, t_safety_step(&g_snap)); TEST_ASSERT_TRUE(g_snap.rail_ok[0]); TEST_ASSERT_EQUAL_INT32(3000, g_snap.rail[0].bus_mv); } /* 同一路上的两颗器件互不牵连：PCA9555 读不到，不影响这一路 INA226 已经读到的值。 `cycle_rail()` 里「器件读失败不提前返回」那一条就是这个意思 —— 提前返回的现象是「一片 I/O 扩展器失联，这一路的过压判据也跟着停了」。 */ static void test_a_dead_pca9555_does_not_spoil_the_same_rails_ina226(void) { sim_i2c_set_present_ch(ch_of(2), PCA9555_ADDR, false); TEST_ASSERT_EQUAL_INT(HAL_ERR_NAK, t_safety_step(&g_snap)); TEST_ASSERT_FALSE(g_snap.io_ok[1]); TEST_ASSERT_TRUE(g_snap.rail_ok[1]); /* INA226 是好的，值是新的 */ TEST_ASSERT_EQUAL_INT32(RAIL_MV(2), g_snap.rail[1].bus_mv); TEST_ASSERT_EQUAL_INT32(RAIL_UA(2), g_snap.rail[1].current_ua); for (int rail = 1; rail <= N; rail++) { if (rail != 2) { TEST_ASSERT_TRUE(g_snap.io_ok[rail - 1]); } } TEST_ASSERT_EQUAL_UINT32(1, g_snap.i2c_errors); } /* 器件掉线之后节拍照样是 20 ms（NAK 的事务也占总线时间，只是占得更少）。 测的是「巡检不会因为总线出错就乱了节奏」。 */ static void test_the_beat_survives_a_dead_blade(void) { sim_i2c_set_present_ch(ch_of(5), rail_cfg(5)->ina_addr, false); sim_i2c_set_present_ch(ch_of(5), PCA9555_ADDR, false); sched_periodic_t tick; sched_periodic_init(&tick, 20); uint32_t prev = hal_time_now_ms(); for (int i = 0; i < 50; i++) { (void)t_safety_step(&g_snap); sched_periodic_wait(&tick); TEST_ASSERT_EQUAL_UINT32(20, hal_time_now_ms() - prev); prev = hal_time_now_ms(); } TEST_ASSERT_EQUAL_UINT32(0, tick.overruns); TEST_ASSERT_EQUAL_UINT32(100, g_snap.i2c_errors); /* 每圈两颗器件各一次 */ /* 别的四路一点没受影响 —— 这才是「失联 ≠ 别的路也不看了」。 */ for (int rail = 1; rail <= 4; rail++) { TEST_ASSERT_TRUE(g_snap.rail_ok[rail - 1]); TEST_ASSERT_EQUAL_INT32(RAIL_MV(rail), g_snap.rail[rail - 1].bus_mv); } } /* 第一圈的占用里不该混进启动期间的事务（游标要在 `t_safety_init()` 时对齐到「现在」）。 混进去的现象是「开机那一下占用率 40 %」，然后再也不复现。 */ static void test_startup_traffic_is_not_charged_to_the_first_cycle(void) { /* 假装启动时又扫了一遍总线。 */ TEST_ASSERT_EQUAL_INT(HAL_OK, hal_lock_take(HAL_LOCK_I2C, 10)); (void)hal_i2c_probe(TCA9548A_ADDR); (void)hal_i2c_probe(INA226_ADDR_INPUT); hal_lock_give(HAL_LOCK_I2C); t_safety_init(&g_snap); TEST_ASSERT_EQUAL_INT(HAL_OK, t_safety_step(&g_snap)); TEST_ASSERT_EQUAL_UINT32(t_safety_budget_us(), g_snap.bus_us); TEST_ASSERT_EQUAL_UINT32(t_safety_cycle_txns(), g_snap.txns); } int main(void) { UNITY_BEGIN(); RUN_TEST(test_one_cycle_is_exactly_the_budgeted_transaction_count); RUN_TEST(test_measured_bus_time_equals_the_static_budget); RUN_TEST(test_the_bus_account_matches_plan_5_5); RUN_TEST(test_each_rail_is_read_on_its_own_mux_channel); RUN_TEST(test_each_blade_reports_its_own_pca9555_inputs); RUN_TEST(test_the_mux_never_has_two_channels_open); RUN_TEST(test_the_unused_channels_are_never_selected); RUN_TEST(test_safety_holds_a_20ms_beat_for_500_cycles); RUN_TEST(test_the_period_outlives_one_ina226_conversion); RUN_TEST(test_every_transaction_happens_under_the_i2c_lock); RUN_TEST(test_the_lock_check_itself_can_fail); RUN_TEST(test_a_busy_bus_skips_the_cycle_instead_of_waiting_forever); RUN_TEST(test_one_dead_ina226_does_not_stop_the_other_four); RUN_TEST(test_empty_slots_are_never_touched_and_the_input_still_reads); RUN_TEST(test_a_failed_read_keeps_the_stale_value_and_flags_it); RUN_TEST(test_a_dead_pca9555_does_not_spoil_the_same_rails_ina226); RUN_TEST(test_the_beat_survives_a_dead_blade); RUN_TEST(test_startup_traffic_is_not_charged_to_the_first_cycle); return UNITY_END(); }