zouyang/phonerail
1
0
派生 0
代码 工单 合并请求 工作流 软件包 项目 发布 百科 活动

固件：R2 迁移 R-0 ~ R-6（底板 + 5 片同构刀片）

浏览代码 
2026-09-16 完成、当时未提交，这里补提交（原样，不含 09-27 上板的修改）。

- 器件层 / 拓扑层整体从 R1 换到 R2：TCA9548A 分通道、五路同址 INA226 0x40 + 输入侧 0x43、
  刀片 PCA9555（VBUS_EN 挪到 P0.4）、CH224A 只读驱动、风扇闭环 t_thermal
- 新增 i2cbus（mux 原子事务）、slot（刀片 I/O 门面）、host/qtest.sh
- 74HC595 链退役（代码与测试保留）
- 判据阈值与时间常量未动；19 个 ctest 全绿，idf.py build 通过

Co-Authored-By: Claude Opus 5.5 <[email protected]>
这个提交包含在：
zhou yang
2026-09-27 10:26:24 +08:00
共同撰写人 Claude Opus 5.5
父节点 5a80d8a872
当前提交 b8ad69681f
共修改 51 个文件，包含 10882 行新增和 4068 行删除
下载 Patch 文件 下载 Diff 文件 展开所有文件 折叠所有文件
firmware/main/t_safety.c
+423 -279
查看文件
@@ -1,279 +1,423 @@
#include "t_safety.h"
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include "hal_i2c_acct.h"
#include "hal_lock.h"
#include "hal_time.h"
#include "rail.h"
#include "rail_cfg.h"
#include "t_actuator.h"
#include "tasks.h"
/* ---- A10：两条判据 --------------------------------------------------------
§10.3 原话：「越界**直接**操作 `EFUSE_EN` / `VBUS_EN`（GPIO 直连，不经任何
队列或抽象层）」。所以下面这几个函数直接调 `rail_*_enable()`，不发消息给
t_actuator —— 发消息就等于把「关电」排在了一个中优先级任务的队列后面。
四条不能改的规矩：
1. **判据只在放锁之后跑。** 两根 EN 线是 GPIO，和 I²C 没有关系；拿着总线锁
去写引脚只会把别的任务多挡一会儿。而且 `t_actuator_abort()` 会去拿 595
那把锁，拿着 I²C 锁进去就是嵌套（`hal_lock_take()` 会直接判 HAL_ERR_STATE）。
2. **先 `t_actuator_abort()`，再断电。** 反过来有个真实的洞：硬重启的
`HR_OFF` 状态会在 4 s 后自己把 `EFUSE_EN` 抬回去，于是「关掉的路」几秒钟
之后又带电了。abort 之后那一路只会走收尾（只碰 595），再也够不到 EN 线。
代价是 abort 最坏会等 595 那把锁 20 ms（`ACT_LOCK_TIMEOUT_MS`），也就是
巡检可能丢一拍 —— 认了：SR-5 原文写着它「仅承担记录与告警，不承担实时保护」，
真正的过压保护是 eFuse 里的硬件 OVP，不靠这条路径的延迟。
3. **判据只在「这一路该有电」而且「这一圈的值是新鲜的」时武装。**
关着的路电压本来就是 0，不设这一条的话每一圈都会得出「偏低 3900 mV」；
而器件失联那一路的值是上一圈的，§10.10 明写着「保持供电，禁用该路的
SR-5 / SW-8 判据并持续告警」。
4. **一条判据也不许发 I²C 事务。** 判据要的三个量（设定值、两根 EN 的状态、
正在跑的序列）全部有影子可查。多读一次就把 §10.3 那 7.8 % 的预算顶穿，
`test_one_cycle_is_exactly_thirteen_transactions()` 会当场变红。 */
static safety_ev_fn s_sink;
static void *s_sink_ctx;
void t_safety_set_event_sink(safety_ev_fn fn, void *ctx)
{
s_sink = fn;
s_sink_ctx = ctx;
}
const char *t_safety_ev_str(safety_ev_t ev)
{
switch (ev) {
case SAFETY_EV_NONE:
return "无";
case SAFETY_EV_OVER_VOLT:
return "过压关路(SR-5)";
case SAFETY_EV_UNDER_VOLT:
return "欠压关路(SR-5)";
case SAFETY_EV_REVERSE:
return "反灌断VBUS(SW-8)";
case SAFETY_EV_PUSHED_UP:
return "被顶高断VBUS(SW-8)";
default:
return "?";
}
}
/* 记一条。**永远在动作之后调** —— 记录慢一步没关系，断电慢一步不行。 */
static void emit(safety_snap_t *s, int rail, safety_ev_t ev, uint32_t now)
{
const ina226_vi_t *vi = &s->rail[rail - 1];
s->last.t_ms = now;
s->last.rail = (uint8_t)rail;
s->last.type = (uint8_t)ev;
s->last.bus_mv = vi->bus_mv;
s->last.current_ua = vi->current_ua;
s->events++;
if (s_sink != NULL) {
s_sink(s_sink_ctx, &s->last); /* TODO(A11)：这里接环形缓冲 */
}
}
/* SR-5：关这一路。**先断 VBUS 再关 eFuse** —— 只关 eFuse 的话，插着 USB 的那几路
会停在「手机只靠 VBUS 供着电」，那既不是开也不是关（`rail_all_off()` 里同一条
理由）。两个都要试，不因为第一个失败就不关第二个。 */
static void trip_rail(safety_snap_t *s, int rail, safety_ev_t ev, uint32_t now)
{
t_actuator_abort(rail); /* 规矩 2：必须在断电之前 */
(void)rail_vbus_enable(rail, false);
(void)rail_efuse_enable(rail, false);
emit(s, rail, ev, now);
}
/* SW-8：只断这一路的 VBUS，**不碰 eFuse** —— 反灌的能量是从 USB 那一侧来的，
把直供也一起关掉等于「因为充电器有问题就把手机关机」，而 §10.2 的整节都在讲
「范围可控的时候只动出事的那一处」。 */
static void cut_vbus(safety_snap_t *s, int rail, safety_ev_t ev, uint32_t now)
{
/* 三个序列里只有 EDL 会去写 `VBUS_EN`（`EDL_EN=1 → VBUS_EN=1 → 等枚举`）。
它正跑着的话必须打断，否则下一拍它就把 VBUS 又抬回来了。
硬重启 / 按键不碰 VBUS，没有理由为一次反灌把它们打断。 */
if (t_actuator_seq(rail) == ACT_SEQ_EDL) {
t_actuator_abort(rail);
}
(void)rail_vbus_enable(rail, false);
emit(s, rail, ev, now);
}
static void check_rail(safety_snap_t *s, int rail, uint32_t now)
{
safety_rail_t *st = &s->st[rail - 1];
const bool en = rail_efuse_is_on(rail);
/* `EFUSE_EN` 的上升沿：缓启动窗口从这一刻算起。 */
if (en && !st->en_on) {
st->en_ms = now;
}
st->en_on = en;
/* 规矩 3 的三道闸。任何一道不过就把圈数清零 —— 「关着的那几秒」
不能算进「持续 20 ms」里，不然一开机就跳闸。
（缓启动窗口是真按毫秒算的：它对应的是 tON + 斜坡那段物理时间，
不像「持续 20 ms」那样是在数样本。） */
if (!en || !s->rail_ok[rail - 1] || (now - st->en_ms) < T_SAFETY_SETTLE_MS) {
st->dev_n = 0;
return;
}
const int32_t mv = s->rail[rail - 1].bus_mv;
const int32_t ua = s->rail[rail - 1].current_ua;
const int32_t dev = mv - (int32_t)rail_setpoint_mv(rail);
/* ---- SW-8（先跑）：只在 VBUS 通着的时候武装 -------------------------
反灌的能量只可能从 VBUS 那一侧来，断开之后判据自然就解除武装了 ——
这也是「关掉之后不会每 20 ms 再刷一条事件」的机制。
先跑它是因为过压这一种情况两条判据都成立：该先撤掉能量来源（VBUS），
20 ms 后 SR-5 再决定要不要连这一路一起关掉。 */
if (rail_vbus_is_on(rail)) {
if (ua < T_SAFETY_REV_UA) {
cut_vbus(s, rail, SAFETY_EV_REVERSE, now);
} else if (dev > T_SAFETY_DEV_MV) {
cut_vbus(s, rail, SAFETY_EV_PUSHED_UP, now);
}
}
/* ---- SR-5：±100 mV 连着 T_SAFETY_DEV_HOLD_CYCLES 圈（= 持续 20 ms）---- */
if (dev > T_SAFETY_DEV_MV || dev < -T_SAFETY_DEV_MV) {
if (st->dev_n < 0xFF) {
st->dev_n++;
}
if (st->dev_n >= T_SAFETY_DEV_HOLD_CYCLES) {
trip_rail(s, rail, dev > 0 ? SAFETY_EV_OVER_VOLT : SAFETY_EV_UNDER_VOLT, now);
/* ⚠️ 这里**故意不**把 `dev_n` 清零。关掉之后下一圈 `en` 就是 false，
上面那道闸自己会清；而万一那次写引脚失败了（影子留在 on），
下一圈 `dev_n` 已经够数，会**立刻再关一次** —— 清零的话得再等两圈。
关电路径上「重试快一点」永远是对的那一边。 */
}
} else {
st->dev_n = 0; /* 「持续」的意思是连续，中间回到范围内就从头数 */
}
}
void t_safety_init(safety_snap_t *s)
{
assert(s != NULL);
memset(s, 0, sizeof(*s));
/* 游标对齐到「现在」，否则第一圈会把启动期间（器件初始化）的事务算进来。 */
s->bus_cursor = hal_i2c_acct_bits();
}
hal_err_t t_safety_step(safety_snap_t *s)
{
assert(s != NULL);
s->cycles++;
hal_err_t err = hal_lock_take(HAL_LOCK_I2C, T_SAFETY_LOCK_TIMEOUT_MS);
if (err != HAL_OK) {
/* 规矩 1：不死等。这一圈作废，20 ms 后重来。 */
s->skipped++;
s->bus_us = hal_i2c_acct_window_us(&s->bus_cursor);
return err;
}
hal_err_t first = HAL_OK;
/* 五路 —— 地址查表，**不许算**（rail_cfg.h 那条禁令）。 */
for (int rail = 1; rail <= PHONERAIL_RAIL_COUNT; rail++) {
ina226_vi_t vi;
const hal_err_t e = ina226_read_vi(rail_cfg(rail)->ina_addr, &vi);
s->rail_ok[rail - 1] = (e == HAL_OK);
if (e == HAL_OK) {
s->rail[rail - 1] = vi; /* 规矩 2：失败就留着上一圈的值，别清零 */
} else {
s->i2c_errors++;
if (first == HAL_OK) {
first = e;
}
}
}
/* 第六片：输入侧。 */
{
ina226_vi_t vi;
const hal_err_t e = ina226_read_vi(INA226_ADDR_INPUT, &vi);
s->input_ok = (e == HAL_OK);
if (e == HAL_OK) {
s->input = vi;
} else {
s->i2c_errors++;
if (first == HAL_OK) {
first = e;
}
}
}
/* PCA9555 的两个输入端口一次事务读完（自增指针）。 */
{
pca9555_in_t in;
const hal_err_t e = pca9555_read_inputs(&in);
s->io_ok = (e == HAL_OK);
if (e == HAL_OK) {
s->io = in;
} else {
s->i2c_errors++;
if (first == HAL_OK) {
first = e;
}
}
}
hal_lock_give(HAL_LOCK_I2C);
/* 判据：放锁之后跑，直接写 EFUSE_EN / VBUS_EN（上面那四条规矩）。
`now` 只取一次 —— 五路要拿同一个时刻去算「持续了多久」。 */
{
const uint32_t now = hal_time_now_ms();
for (int rail = 1; rail <= PHONERAIL_RAIL_COUNT; rail++) {
check_rail(s, rail, now);
}
}
s->bus_us = hal_i2c_acct_window_us(&s->bus_cursor);
return first;
}
uint32_t t_safety_budget_us(void)
{
/* 上面那一圈真正发出去的事务，逐条数：
6 片 INA226 × 2 次寄存器读（母线电压 + 电流）
1 次 PCA9555 读（一次事务读回两个输入端口）
每次都是「写 1 字节寄存器号 + 读 2 字节」的形状。 */
const uint32_t txns = INA226_COUNT * 2u + 1u;
return (uint32_t)hal_i2c_bits_to_us((uint64_t)txns * hal_i2c_txn_bits(1, 2));
}
uint32_t t_safety_load_permille(uint32_t bus_us, uint32_t period_ms)
{
if (period_ms == 0) {
return 0;
}
return (uint32_t)(((uint64_t)bus_us * 1000ull) / ((uint64_t)period_ms * 1000ull));
}
int t_safety_format(const safety_snap_t *s, char *buf, size_t len)
{
assert(s != NULL && buf != NULL && len > 0);
const uint32_t period = task_desc(TASK_SAFETY)->period_ms;
const uint32_t pm = t_safety_load_permille(s->bus_us, period);
return snprintf(buf, len,
"t_safety: cycles=%u skipped=%u i2c_err=%u bus=%u us/%u ms load=%u.%u%% "
"events=%u",
(unsigned)s->cycles, (unsigned)s->skipped, (unsigned)s->i2c_errors,
(unsigned)s->bus_us, (unsigned)period, (unsigned)(pm / 10u),
(unsigned)(pm % 10u), (unsigned)s->events);
}
#include "t_safety.h"
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include "hal_i2c_acct.h"
#include "hal_time.h"
#include "i2cbus.h"
#include "rail.h"
#include "rail_cfg.h"
#include "slot.h"
#include "t_actuator.h"
#include "tasks.h"
/* 判据与四条规矩见 t_safety.h。这里只补一句 R2 最容易写错的：
**断 VBUS 在锁内（它是 I²C 上的 PCA9555），关 eFuse 在锁外（它是 GPIO）。**
两者以前是一对 GPIO，现在不是了。 */
static safety_ev_fn s_sink;
static void *s_sink_ctx;
void t_safety_set_event_sink(safety_ev_fn fn, void *ctx)
{
s_sink = fn;
s_sink_ctx = ctx;
}
const char *t_safety_ev_str(safety_ev_t ev)
{
switch (ev) {
case SAFETY_EV_NONE:
return "无";
case SAFETY_EV_OVER_VOLT:
return "过压关路(SR-5)";
case SAFETY_EV_UNDER_VOLT:
return "欠压关路(SR-5)";
case SAFETY_EV_REVERSE:
return "反灌断VBUS(SW-8)";
case SAFETY_EV_PUSHED_UP:
return "被顶高断VBUS(SW-8)";
case SAFETY_EV_MUX_LOST:
return "mux失联全断";
case SAFETY_EV_SLOT_EMPTY:
return "刀片不在位";
default:
return "?";
}
}
/* 记一条。**永远在动作之后调** —— 记录慢一步没关系，断电慢一步不行。
`rail` 传 0 表示整板级事件（mux 失联），那时 V/I 记的是输入侧的。 */
static void emit(safety_snap_t *s, int rail, safety_ev_t ev, uint32_t now)
{
const ina226_vi_t *vi = (rail >= 1) ? &s->rail[rail - 1] : &s->input;
s->last.t_ms = now;
s->last.rail = (uint8_t)rail;
s->last.type = (uint8_t)ev;
s->last.bus_mv = vi->bus_mv;
s->last.current_ua = vi->current_ua;
s->events++;
if (s_sink != NULL) {
s_sink(s_sink_ctx, &s->last);
}
}
/* ---- 锁内：一路的读 + 判据 ----------------------------------------------- */
typedef struct {
safety_snap_t *s;
int rail;
uint32_t now; /* 本圈统一的时刻：五路要拿同一个时刻去算「持续了多久」 */
} cycle_arg_t;
/* SW-8：只断这一路的 VBUS，**不碰 eFuse** —— 反灌的能量是从 USB 那一侧来的，
把直供也一起关掉等于「因为充电器有问题就把手机关机」。
⚠️ 就在锁内、通道已选好的此刻断（规矩 3）。 */
static void cut_vbus_locked(safety_snap_t *s, int rail, safety_ev_t ev)
{
safety_rail_t *st = &s->st[rail - 1];
(void)slot_vbus_enable_locked(rail, false);
/* 三个序列里只有 EDL 会去写 `VBUS_EN`，它正跑着的话必须打断，否则下一拍
它就把 VBUS 又抬回来了。abort 会走 I²C（收尾要写 Port0），所以**留到锁外**。 */
if (t_actuator_seq(rail) == ACT_SEQ_EDL) {
st->pend_abort = true;
}
st->pend_ev = (uint8_t)ev;
}
/* SR-5：关这一路。**先断 VBUS（这里、锁内）再关 eFuse（锁外）** ——
只关 eFuse 的话，插着 USB 的那几路会停在「手机只靠 VBUS 供着电」，
那既不是开也不是关。 */
static void trip_rail_locked(safety_snap_t *s, int rail, safety_ev_t ev)
{
safety_rail_t *st = &s->st[rail - 1];
(void)slot_vbus_enable_locked(rail, false);
st->pend_abort = true;
st->pend_efuse = true;
st->pend_ev = (uint8_t)ev;
}
static void judge_locked(safety_snap_t *s, int rail, uint32_t now)
{
safety_rail_t *st = &s->st[rail - 1];
const bool en = rail_efuse_is_on(rail);
/* `EFUSE_EN` 的上升沿：缓启动窗口从这一刻算起。 */
if (en && !st->en_on) {
st->en_ms = now;
}
st->en_on = en;
/* 三道闸。任何一道不过就把圈数清零 —— 「关着的那几秒」不能算进
「持续 20 ms」里，不然一开机就跳闸。 */
if (!en || !s->rail_ok[rail - 1] || (now - st->en_ms) < T_SAFETY_SETTLE_MS) {
st->dev_n = 0;
return;
}
const int32_t mv = s->rail[rail - 1].bus_mv;
const int32_t ua = s->rail[rail - 1].current_ua;
const int32_t dev = mv - (int32_t)rail_setpoint_mv(rail);
/* ---- SW-8（先跑）：只在 VBUS 通着的时候武装 -------------------------
反灌的能量只可能从 VBUS 那一侧来，断开之后判据自然就解除武装了。
先跑它是因为过压那种情况两条判据都成立：该先撤掉能量来源（VBUS），
20 ms 后 SR-5 再决定要不要连这一路一起关掉。 */
if (slot_vbus_is_on(rail)) {
if (ua < T_SAFETY_REV_UA) {
cut_vbus_locked(s, rail, SAFETY_EV_REVERSE);
} else if (dev > T_SAFETY_DEV_MV) {
cut_vbus_locked(s, rail, SAFETY_EV_PUSHED_UP);
}
}
/* ---- SR-5：±100 mV 连着 T_SAFETY_DEV_HOLD_CYCLES 圈（= 持续 20 ms）---- */
if (dev > T_SAFETY_DEV_MV || dev < -T_SAFETY_DEV_MV) {
if (st->dev_n < 0xFF) {
st->dev_n++;
}
if (st->dev_n >= T_SAFETY_DEV_HOLD_CYCLES) {
trip_rail_locked(s, rail, dev > 0 ? SAFETY_EV_OVER_VOLT : SAFETY_EV_UNDER_VOLT);
/* ⚠️ 这里**故意不**把 `dev_n` 清零。关掉之后下一圈 `en` 就是 false，
上面那道闸自己会清；而万一那次写引脚失败了（影子留在 on），
下一圈 `dev_n` 已经够数，会**立刻再关一次**。 */
}
} else {
st->dev_n = 0; /* 「持续」的意思是连续，中间回到范围内就从头数 */
}
}
/* 一路的锁内正文：读 V/I → 读两个输入端口 → 跑判据。
⚠️ 器件读失败**不提前返回**：PCA9555 读不到不代表 INA226 也读不到，
而判据只要有新鲜的电压就能出（规矩 2）。 */
static hal_err_t cycle_rail(void *arg)
{
cycle_arg_t *a = (cycle_arg_t *)arg;
safety_snap_t *s = a->s;
const int rail = a->rail;
hal_err_t first = HAL_OK;
ina226_vi_t vi;
hal_err_t e = ina226_read_vi(rail_cfg(rail)->ina_addr, &vi);
s->rail_ok[rail - 1] = (e == HAL_OK);
if (e == HAL_OK) {
s->rail[rail - 1] = vi; /* 失败就留着上一圈的值，别清零 */
} else {
s->i2c_errors++;
first = e;
}
pca9555_in_t in;
e = slot_read_inputs_locked(rail, &in);
s->io_ok[rail - 1] = (e == HAL_OK);
if (e == HAL_OK) {
s->io[rail - 1] = in;
} else {
s->i2c_errors++;
if (first == HAL_OK) {
first = e;
}
}
/* 判据就在这里跑：断 VBUS 要在本路通道选好、锁还持着的此刻（规矩 3）。 */
judge_locked(s, rail, a->now);
return first;
}
static hal_err_t cycle_input(void *arg)
{
safety_snap_t *s = (safety_snap_t *)arg;
ina226_vi_t vi;
const hal_err_t e = ina226_read_vi(INA226_ADDR_INPUT, &vi);
s->input_ok = (e == HAL_OK);
if (e == HAL_OK) {
s->input = vi;
} else {
s->i2c_errors++;
}
return e;
}
void t_safety_init(safety_snap_t *s)
{
assert(s != NULL);
memset(s, 0, sizeof(*s));
for (int i = 0; i < PHONERAIL_RAIL_COUNT; i++) {
s->present[i] = true; /* 与 slot.c 的初值一致：读到之前当它在位 */
}
/* 游标对齐到「现在」，否则第一圈会把启动期间（器件初始化）的事务算进来。 */
s->bus_cursor = hal_i2c_acct_bits();
s->txn_cursor = hal_i2c_acct_txns();
}
/* ---- 锁外：把锁内攒下的动作做掉 ------------------------------------------ */
static void apply_pending(safety_snap_t *s, uint32_t now)
{
for (int rail = 1; rail <= PHONERAIL_RAIL_COUNT; rail++) {
safety_rail_t *st = &s->st[rail - 1];
if (st->pend_ev == (uint8_t)SAFETY_EV_NONE) {
continue;
}
/* 顺序：先 abort 再关 eFuse。反过来有个真实的洞 —— 硬重启的 `HR_OFF`
状态会在 4 s 后自己把 `EFUSE_EN` 抬回去，于是「关掉的路」几秒钟之后
又带电了。abort 之后那一路只会走收尾（只写 Port0），再也够不到 EN 线。 */
if (st->pend_abort) {
t_actuator_abort(rail);
}
if (st->pend_efuse) {
(void)rail_efuse_enable(rail, false);
}
emit(s, rail, (safety_ev_t)st->pend_ev, now);
st->pend_ev = (uint8_t)SAFETY_EV_NONE;
st->pend_efuse = false;
st->pend_abort = false;
}
}
/* ⭐ R2：刀片不在位就不许带电（计划 §5.8）。空槽上电 = 金手指裸露带 12V。
只在「本来是开着的」时候动作，否则每圈都会对着五个空槽刷事件。 */
static void check_present(safety_snap_t *s, uint32_t now)
{
/* ⚠️ 先把五根脚重读一遍再判。`slot_present()` 读的是缓存（读失败时要能
保留上一次的值），不 poll 的话缓存停在 `slot_prsnt_init()` 那一刻，
现象是**拔掉刀片永远判不出来**，而且一个错误码都不会有。
这一步是纯 GPIO，不占总线，所以每圈都做。 */
slot_prsnt_poll();
for (int rail = 1; rail <= PHONERAIL_RAIL_COUNT; rail++) {
s->present[rail - 1] = slot_present(rail);
if (s->present[rail - 1] || !rail_efuse_is_on(rail)) {
continue;
}
t_actuator_abort(rail);
(void)rail_efuse_enable(rail, false);
/* VBUS 也尽力断一次。⚠️ 刀片**真的**被拔了的话这一步必然 NAK
（PCA9555 跟着刀片一起走了），那没关系；它挡的是另一种情形：
`PRSNT#` 接触不良 / 金手指 B31 虚接 —— 刀片还在、PCA9555 还应答，
这时只关 eFuse 会留下「直供断了但 USB 还灌着」的半开状态。
放在关 eFuse **之后**：断电优先，而这一步要走 I²C、可能等锁。 */
(void)slot_vbus_enable(rail, false);
emit(s, rail, SAFETY_EV_SLOT_EMPTY, now);
}
}
/* ⭐ R2：mux 是单点（计划 §5.8）。它一挂，五路的电压电流**全部看不见**，
SR-5 的整条监控链断了 —— 这时「继续供电但看不见」比「停机」危险。
⚠️ 先脉冲一次 `MUX_RST#` 再判：一次总线毛刺就停五台机器，代价太大。 */
static void check_mux(safety_snap_t *s, uint32_t now)
{
if (i2cbus_select_fail_streak() < T_SAFETY_MUX_FAIL_N) {
s->mux_step = 0; /* 选中过一次 ⇒ 这一轮结束（判据数的是「连续」，不是「累计」） */
return;
}
if (s->mux_step == 0) {
/* 这一轮还没试过复位 —— 先脉冲一次 `MUX_RST#`，下一圈再看。
⚠️ 这一步走到哪了要记在 `mux_step` 里，**不能拿 `i2cbus_recoveries()` 和
`s->mux_recovers` 比**：复位之后把后者同步成前者，两个数就永远相等，
于是每一圈都走这条分支 —— `MUX_RST#` 每 20 ms 脉冲一次、五路永远断不掉。 */
(void)i2cbus_recover();
s->mux_recovers++;
s->mux_step = 1;
return;
}
if (s->mux_step >= 2) {
/* 这一轮已经全断过了。再断一次没有任何用处，而每 20 ms 刷一条 MUX_LOST
会把事件日志那块 flash 写穿 —— 判据「一直在响」和判据「不灵」一样糟。
等某一次选通成功（streak 归零）之后才重新武装。 */
return;
}
/* 复位过了还是连续失败：认定失联。 */
s->mux_step = 2;
s->mux_trips++;
for (int rail = 1; rail <= PHONERAIL_RAIL_COUNT; rail++) {
t_actuator_abort(rail);
}
(void)rail_all_off(); /* 前半段（断 VBUS）多半也会失败，那没关系 —— eFuse 是 GPIO */
emit(s, 0, SAFETY_EV_MUX_LOST, now);
}
/* 本圈还允许在等锁上花多久：单次上限与「整圈预算的余额」取小的那个。
⚠️ 这里量的是**墙钟**，所以事务本身花掉的时间也算在内 —— 那是对的：
预算要挡住的是「这一圈把整个周期占满」，而不只是「等锁等太久」。 */
static uint32_t lock_budget_left(uint32_t t0)
{
const uint32_t spent = hal_time_now_ms() - t0;
if (spent >= T_SAFETY_LOCK_BUDGET_MS) {
return 0;
}
const uint32_t left = T_SAFETY_LOCK_BUDGET_MS - spent;
return left < T_SAFETY_LOCK_TIMEOUT_MS ? left : T_SAFETY_LOCK_TIMEOUT_MS;
}
hal_err_t t_safety_step(safety_snap_t *s)
{
assert(s != NULL);
s->cycles++;
const uint32_t now = hal_time_now_ms();
hal_err_t first = HAL_OK;
bool skipped = false;
/* 本圈还能在等锁上花多久（`T_SAFETY_LOCK_BUDGET_MS` 那一段的理由）。
返回 0 表示预算用完了 —— 剩下的路这一圈不读了。 */
const uint32_t t0 = now;
/* 五路，一路一次 `xact`（通道查表，**不许算** —— rail_cfg.h 那条禁令）。 */
for (int rail = 1; rail <= PHONERAIL_RAIL_COUNT; rail++) {
const uint32_t budget = lock_budget_left(t0);
if (budget == 0) {
skipped = true; /* 整圈预算用完：剩下的路本圈作废，下一拍重来 */
break;
}
cycle_arg_t a = { s, rail, now };
const hal_err_t e = i2cbus_xact(slot_mux_ch(rail), budget, cycle_rail, &a);
if (e == HAL_ERR_TIMEOUT) {
skipped = true; /* 规矩 1：不死等。这一路这一圈作废 */
}
if (e != HAL_OK && first == HAL_OK) {
first = e;
}
}
/* 第六片：输入侧，挂在主干上（不在任何通道后面）。 */
{
const uint32_t budget = lock_budget_left(t0);
if (budget == 0) {
skipped = true;
} else {
const hal_err_t e = i2cbus_xact(I2CBUS_CH_TRUNK, budget, cycle_input, s);
if (e == HAL_ERR_TIMEOUT) {
skipped = true;
}
if (e != HAL_OK && first == HAL_OK) {
first = e;
}
}
}
if (skipped) {
s->skipped++;
}
/* 放锁之后：关 eFuse（GPIO）、打断序列、记事件，再跑两条整板级判据。 */
apply_pending(s, now);
check_present(s, now);
check_mux(s, now);
s->bus_us = hal_i2c_acct_window_us(&s->bus_cursor);
{
const uint32_t t = hal_i2c_acct_txns();
s->txns = t - s->txn_cursor;
s->txn_cursor = t;
}
return first;
}
uint32_t t_safety_cycle_txns(void)
{
/* 每路：选通道(1) + INA226 读 V(1) + 读 I(1) + PCA9555 读两个输入端口(1) = 4
主干：选通道(1) + INA226 读 V(1) + 读 I(1) = 3 */
return (uint32_t)PHONERAIL_RAIL_COUNT * 4u + 3u;
}
uint32_t t_safety_budget_us(void)
{
/* 逐条数，按事务形状分两类：
mux 选通 —— 纯写 1 字节（**没有寄存器指针**，见 tca9548a.h）
寄存器读 —— 写 1 字节寄存器号 + 读 2 字节 */
const uint32_t selects = (uint32_t)PHONERAIL_RAIL_COUNT + 1u; /* 五路 + 回主干 */
const uint32_t reads = t_safety_cycle_txns() - selects;
const uint64_t bits = (uint64_t)selects * hal_i2c_txn_bits(1, 0) +
(uint64_t)reads * hal_i2c_txn_bits(1, 2);
return (uint32_t)hal_i2c_bits_to_us(bits);
}
uint32_t t_safety_load_permille(uint32_t bus_us, uint32_t period_ms)
{
if (period_ms == 0) {
return 0;
}
return (uint32_t)(((uint64_t)bus_us * 1000ull) / ((uint64_t)period_ms * 1000ull));
}
int t_safety_format(const safety_snap_t *s, char *buf, size_t len)
{
assert(s != NULL && buf != NULL && len > 0);
const uint32_t period = task_desc(TASK_SAFETY)->period_ms;
const uint32_t pm = t_safety_load_permille(s->bus_us, period);
return snprintf(buf, len,
"t_safety: cycles=%u skipped=%u i2c_err=%u txns=%u bus=%u us/%u ms "
"load=%u.%u%% events=%u mux(rst=%u trip=%u)",
(unsigned)s->cycles, (unsigned)s->skipped, (unsigned)s->i2c_errors,
(unsigned)s->txns, (unsigned)s->bus_us, (unsigned)period,
(unsigned)(pm / 10u), (unsigned)(pm % 10u), (unsigned)s->events,
(unsigned)s->mux_recovers, (unsigned)s->mux_trips);
}