wandering1
4ceb5b41e6
用户指令（2026-10-30）：确认录波任务完成度，把除实际操作之外的所有 步骤做完，然后删除规划文件，避免已完成的工作被误读为未做。 审计结论：代码面确已全部收口——wave_read.py --selftest 92/92、 三套主机单测 113/170/110 复跑全 rc=0、bench 自抓与 PC 读段脚本在仓、 数据可信/复刻明细/短板评测/UI 两处回写均已做过。**唯一未跑的是 板级台架那一轮（实际操作）**，判据不得丢，故先迁后删： - 设计说明 §9 承接落盘道失败留痕名全清单（13+1 条，打印点现值 default_task.c:816/:831 实测核对） - 设计说明 §10 承接原卡 2/卡 3 的板级段（触发来路一行、回放页 一行）与本波执行顺序图（mermaid，原规划 §3 逐字迁） - §4/§11 头部定位、§11 尾注、§14 关系行改属主口径 - 全库 32 处引用改挂设计说明 §10/§9（18 文件）：任务规划 README 独立行（顺带订正单测数 100→113 为实测）、登记簿、数据可信 ×2、 复刻明细、产品需求 ×2、ADC 注入 ×3、短板评测 ×2、页面补齐规划、 App/algo README、配图生成器注释、录波三套单测注释 ×6 - git rm docs 该规划文件；人类索引任务规划 6→5 个文件（沿革注照 屏板链路先例走裸句，不留反引号死引用） 验证：残留两形态（任务规划/故障录波、裸文件名）全树扫描 0； mermaid 预检新发 0；doc-links 11 个被改文件逐文件 PASS；生成器 注释改动重跑产物逐字节不变（svg 60a0dd39e4）；三套单测与 wave_read selftest 复跑全绿；18 文件 BOM/CR/U+FFFD 全零。 本笔不含固件编译单元（test/host 仅注释行与文档），构建留待合并 轮统一跑；板级轮启动判据与顺序见设计说明 §10。
539 lines
26 KiB
C
539 lines
26 KiB
C
/*
|
||
* 模块名称：录波环（滚动环 + 触发冻结状态机 + 已封存区读口）主机侧单元测试
|
||
* 被测对象：真实源文件（#include 原样纳入，测生产代码而非副本）：
|
||
* App/algo/wave_store.c + App/algo/wave_ring.c
|
||
* 两源均为纯逻辑（无 HAL / CMSIS / RTOS / FatFs / 日志）→ **无需任何桩目录**。
|
||
*
|
||
* 为什么要主机侧（而不是只等台架）：本层的判据几乎全是**结构与并发**类——
|
||
* 段首基址与点序、SEALED 期间写指针必须真冻结、ACK 前不许重录、滞留超时自弃、
|
||
* 冷却只在 ACK 后计时、读口在未就绪时绝不返回旧数据。这些在台架上要么不可观测
|
||
* （1 ms 一拍的窗口，人工读不到）、要么无法安全注入（真造一次「defaultTask 挂住
|
||
* 两秒」就是把看门狗窗口拿去赌）。主机侧可以拿影子样本序列把它逐点钉死。
|
||
* 需要板子的部分（注入 1 V/50 Hz 后 FTP 拉回对表、实机 FAT 落盘）不在本套件，
|
||
* 见 docs/子系统设计/故障录波设计说明.md §10 板级行（录波数据面最小闭环）。
|
||
*
|
||
* 覆盖点（用例名写「它自己在验证什么」，不发编号；属主登记处 = 本目录）：
|
||
* 用例：形态与预算钉死：int16×320×8 = 5120、两半各 160、
|
||
* sizeof(wave_seg_meta_t) = 136、sizeof(wave_ch_desc_t) = 12
|
||
* 用例：init 复位语义：IDLE / 不可读 / 计数与轮转号归零
|
||
* 用例：参数守卫：push / request / latch / read / get_stat 的非法入参
|
||
* 用例：触发到封段的时序：封段恰在触发后第 160 拍，事件一次性
|
||
* 用例：段内容与点序：8 列 × 320 点逐点等于影子样本，
|
||
* 触发那一拍的样本在点 159、点 160 是其后第一拍（列序 = 语义序）
|
||
* 用例：SEALED 丢样本：push 返 DONE、drop 计点、写指针真冻结、内容不变
|
||
* 用例：封存交棒握手：未 latch 一律不可用；latch 只准一次、不覆盖；
|
||
* latch 内容进段头（eng / flags_seq / clip_mask / wall + 8 路系数）
|
||
* 用例：读窗夹取与跨环回绕；read_cb 的 32 位形态
|
||
* 用例：列号映射：0..7 恒等、TEMP 与越界返 WAVE_ST_E_RANGE
|
||
* 用例：ACK 语义：成功推进 seg_idx 与 seg_total 并起冷却；重复 ACK 拒绝；
|
||
* 未就绪时读口返 E_STATE 而不是旧数据
|
||
* 用例：环未填满就触发：前导点必须是 0（不是上一段的残留），真实样本从
|
||
* 点 129 起（本次上电只有 31 个点可给）
|
||
*
|
||
* 通过：全部 CHECK 通过（main 返回 0）。
|
||
* 创建日期：2026-10-29（故障录波 task-1）
|
||
*/
|
||
|
||
#include <stddef.h>
|
||
#include <stdint.h>
|
||
#include <stdio.h>
|
||
|
||
/* ===================== 断言 ===================== */
|
||
static int s_total = 0, s_passed = 0, s_failed = 0;
|
||
|
||
#define CHECK(cond, name) do { \
|
||
s_total++; \
|
||
if (cond) { s_passed++; printf(" [PASS] %s\n", name); } \
|
||
else { s_failed++; printf(" [FAIL] %s (line %d)\n", name, __LINE__); } \
|
||
} while (0)
|
||
|
||
/* ===================== 被测代码（生产源原样纳入） ===================== */
|
||
#include "wave_store.c"
|
||
#include "wave_ring.c"
|
||
|
||
/* ===================== 影子样本模型 ===================== */
|
||
#define HIST_N 2048u /* 影子样本环（比录波环大，够跑完整个场景） */
|
||
#define TRIG_K 400u /* 第一段：消费请求那一拍的样本号 */
|
||
|
||
static int16_t s_hist[HIST_N][WAVE_RING_CH];
|
||
static uint32_t s_k; /* 下一个要压的样本号 */
|
||
static uint32_t s_evt_sealed; /* 累计看到多少次 EVT_SEALED */
|
||
static uint32_t s_push_bad; /* push 返回了 OK/DONE 之外的值 */
|
||
static int32_t s_push_last; /* 最近一次 push 的返回值 */
|
||
|
||
/* 每路一条可辨认的斜坡：不同样本、不同列都不重复，负值也覆盖（TPAFE 是双极性补码） */
|
||
static int16_t wave_sig(uint32_t a_k, uint8_t a_col) {
|
||
return (int16_t)(((int32_t)a_k * 7) - 1200 + ((int32_t)a_col * 91));
|
||
}
|
||
|
||
/* 压 n 拍（push 之后 tick，与 adcTask 的接线顺序一致：先写样本再算点数） */
|
||
static void wave_step(uint32_t a_n) {
|
||
uint32_t i;
|
||
|
||
for (i = 0u; i < a_n; i++) {
|
||
int16_t codes[WAVE_RING_CH];
|
||
uint8_t c;
|
||
int32_t rc;
|
||
|
||
for (c = 0u; c < (uint8_t)WAVE_RING_CH; c++) {
|
||
codes[c] = wave_sig(s_k, c);
|
||
s_hist[s_k % HIST_N][c] = codes[c];
|
||
}
|
||
rc = wave_ring_push(codes, (uint8_t)WAVE_RING_CH);
|
||
s_push_last = rc;
|
||
if ((rc != WAVE_ST_OK) && (rc != WAVE_ST_DONE)) {
|
||
s_push_bad++;
|
||
}
|
||
rc = wave_ring_tick(s_k, s_k);
|
||
if (rc == (int32_t)WAVE_RING_EVT_SEALED) {
|
||
s_evt_sealed++;
|
||
}
|
||
s_k++;
|
||
}
|
||
}
|
||
|
||
/* 影子样本 -> 段内点：点 i 对应样本 (a_trig - 159 + i)，负数表示当时还没采到 */
|
||
static int32_t wave_pt_sample(uint32_t a_trig, uint32_t a_pt) {
|
||
return ((int32_t)a_trig - (int32_t)(WAVE_RING_PRE - 1u)) + (int32_t)a_pt;
|
||
}
|
||
|
||
/* 整段逐点比对（a_trig = 消费请求那一拍的样本号） */
|
||
static int wave_cmp_all(uint32_t a_trig) {
|
||
int16_t buf[WAVE_RING_PTS];
|
||
uint8_t c;
|
||
|
||
for (c = 0u; c < (uint8_t)WAVE_RING_CH; c++) {
|
||
int32_t n;
|
||
uint32_t i;
|
||
|
||
n = wave_ring_read_ch(c, 0u, (uint16_t)WAVE_RING_PTS, buf);
|
||
if (n != (int32_t)WAVE_RING_PTS) {
|
||
return 0;
|
||
}
|
||
for (i = 0u; i < (uint32_t)WAVE_RING_PTS; i++) {
|
||
int32_t ks = wave_pt_sample(a_trig, i);
|
||
int16_t want = (ks < 0) ? (int16_t)0 : wave_sig((uint32_t)ks, c);
|
||
if (buf[i] != want) {
|
||
return 0;
|
||
}
|
||
}
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
/* 封好段并交棒（返回消费请求那一拍的样本号） */
|
||
static uint32_t s_trig_first;
|
||
|
||
static void wave_seal_once(uint8_t a_src, uint8_t a_elm) {
|
||
wave_ring_request(a_src, a_elm);
|
||
wave_step(1u); /* 本拍样本 = 点 159，同拍 tick 消费请求钉基址 */
|
||
s_trig_first = s_k - 1u;
|
||
wave_step((uint32_t)WAVE_RING_POST); /* 后触发 160 点，最后一拍封段 */
|
||
}
|
||
|
||
/* 造一份封存瞬间事实 */
|
||
static void wave_fill_cal(wave_seal_cal_t *p_cal, uint8_t a_seq_tag) {
|
||
uint8_t i;
|
||
|
||
p_cal->eng = (uint8_t)WAVE_ENG_PIN;
|
||
p_cal->flags_seq = (uint8_t)(0x50u ^ a_seq_tag);
|
||
p_cal->clip_mask = (uint16_t)0x00E6u;
|
||
p_cal->wall = 1764374400u + (uint32_t)a_seq_tag;
|
||
for (i = 0u; i < (uint8_t)WAVE_ST_CH_MAX; i++) {
|
||
p_cal->ch[i].sem = i;
|
||
p_cal->ch[i].conv = (uint8_t)((i == 0u) || (i == 3u) || (i == 4u)) ? 0u : 1u;
|
||
p_cal->ch[i].bits = (uint8_t)(((i == 0u) || (i == 3u) || (i == 4u)) ? 16u : 12u);
|
||
p_cal->ch[i].avail = (uint8_t)(0x01u | (((i == 1u) || (i == 5u)) ? 0x02u : 0x00u));
|
||
p_cal->ch[i].k_q16 = (int32_t)(((i == 0u) || (i == 3u) || (i == 4u)) ? 10000000L : 52800000L);
|
||
p_cal->ch[i].b_codes = (int32_t)(a_seq_tag + i);
|
||
}
|
||
}
|
||
|
||
static wave_seal_cal_t s_cal;
|
||
|
||
/* ===================== 主测 ===================== */
|
||
int main(void) {
|
||
printf("=== Wave Ring Tests:\n");
|
||
|
||
/* ---------- 用例：形态与预算 ---------- */
|
||
printf("-- 用例：形态与预算 --\n");
|
||
CHECK(sizeof(int16_t) == 2u, "int16 是两字节（不许 float）");
|
||
CHECK(WAVE_RING_BYTES == 5120u, "环 = 5120 字节");
|
||
CHECK(((uint32_t)WAVE_RING_PTS * (uint32_t)WAVE_RING_CH * 2u) == WAVE_RING_BYTES, "环长等式");
|
||
CHECK(WAVE_RING_PTS == (WAVE_RING_PRE + WAVE_RING_POST), "段长 = 预触发 + 后触发");
|
||
CHECK(WAVE_RING_PRE == 160u, "预触发 160 点 = 8 周波 @20 点/周波");
|
||
CHECK(sizeof(wave_ch_desc_t) == (size_t)WAVE_ST_CH_BYTES, "通道表一项正好 12 字节");
|
||
CHECK(sizeof(wave_seg_meta_t) == 136u, "段头快照 136 字节（本卡静态增量台账用）");
|
||
|
||
/* ---------- 用例：init 复位 ---------- */
|
||
printf("-- 用例：init 复位语义 --\n");
|
||
wave_ring_init();
|
||
CHECK(wave_ring_state() == (uint8_t)WAVE_RING_ST_IDLE, "init 后 IDLE");
|
||
CHECK(wave_ring_sealed() == 0u, "init 后无可读段");
|
||
{
|
||
wave_ring_stat_t st;
|
||
int16_t buf[8];
|
||
CHECK(wave_ring_read_ch(0u, 0u, 8u, buf) == WAVE_ST_E_STATE, "init 后读已封存区被拒");
|
||
CHECK(wave_ring_get_stat(&st) == WAVE_ST_OK, "get_stat OK");
|
||
CHECK((st.seg_idx == 0u) && (st.seg_total == 0u) && (st.ovf_cnt == 0u) &&
|
||
(st.drop_cnt == 0u) && (st.err_cnt == 0u), "init 后计数与轮转号归零");
|
||
}
|
||
|
||
/* ---------- 用例：参数守卫 ---------- */
|
||
printf("-- 用例：参数守卫 --\n");
|
||
CHECK(wave_ring_push(NULL, (uint8_t)WAVE_RING_CH) == WAVE_ST_E_PARAM, "push 空指针");
|
||
{
|
||
int16_t codes[WAVE_RING_CH];
|
||
CHECK(wave_ring_push(codes, 7u) == WAVE_ST_E_PARAM, "push 长度不等于 8 拒绝");
|
||
CHECK(wave_ring_push(codes, 9u) == WAVE_ST_E_PARAM, "push 长度大于 8 拒绝");
|
||
}
|
||
CHECK(wave_ring_request(0u, 0u) == WAVE_ST_E_PARAM, "request 触发源 0 拒绝");
|
||
CHECK(wave_ring_request(4u, 0u) == WAVE_ST_E_PARAM, "request 触发源 4 拒绝");
|
||
CHECK(wave_ring_latch_meta(NULL) == WAVE_ST_E_PARAM, "latch 空指针");
|
||
CHECK(wave_ring_sealed_meta(NULL) == WAVE_ST_E_PARAM, "sealed_meta 空指针");
|
||
CHECK(wave_ring_get_stat(NULL) == WAVE_ST_E_PARAM, "get_stat 空指针");
|
||
CHECK(wave_ring_write_done(0) == WAVE_ST_E_STATE, "没段可 ACK 时拒绝");
|
||
|
||
/* ---------- 用例：触发到封段时序 ---------- */
|
||
printf("-- 用例：触发到封段时序 --\n");
|
||
wave_ring_init();
|
||
s_k = 0u;
|
||
s_evt_sealed = 0u;
|
||
s_push_bad = 0u;
|
||
wave_step(TRIG_K);
|
||
CHECK(wave_ring_state() == (uint8_t)WAVE_RING_ST_IDLE, "400 拍后仍 IDLE（没请求就不该动）");
|
||
wave_ring_request((uint8_t)WAVE_TRIG_MANUAL, 7u);
|
||
wave_step(1u);
|
||
s_trig_first = s_k - 1u;
|
||
CHECK(s_trig_first == TRIG_K, "请求在下一拍被消费（本层不自己冻结，交给 adcTask 的 tick）");
|
||
CHECK(wave_ring_state() == (uint8_t)WAVE_RING_ST_FREEZE, "消费请求即 FREEZE");
|
||
CHECK(s_evt_sealed == 0u, "还没封段");
|
||
CHECK(wave_ring_sealed() == 0u, "FREEZE 期间不可读");
|
||
wave_step((uint32_t)WAVE_RING_POST - 1u);
|
||
CHECK((wave_ring_state() == (uint8_t)WAVE_RING_ST_FREEZE) && (s_evt_sealed == 0u),
|
||
"后触发 159 点时仍未封段");
|
||
wave_step(1u);
|
||
CHECK(wave_ring_state() == (uint8_t)WAVE_RING_ST_SEALED, "后触发计满 160 点才封段");
|
||
CHECK(s_evt_sealed == 1u, "EVT_SEALED 恰好一次");
|
||
wave_step(1u);
|
||
CHECK(s_evt_sealed == 1u, "事件不重复报（只封段那一拍报）");
|
||
CHECK(s_push_bad == 0u, "全程 push 无非法返回");
|
||
|
||
/* ---------- 用例：a 未 latch 前一律不可用（必须先于内容比对） ---------- */
|
||
printf("-- 用例：封存交棒握手 --\n");
|
||
CHECK(wave_ring_sealed() == 0u, "刚封段还没交棒：不可用");
|
||
{
|
||
wave_ring_stat_t st;
|
||
wave_seg_meta_t meta;
|
||
int16_t buf[8];
|
||
(void)wave_ring_get_stat(&st);
|
||
CHECK(st.meta_ready == 0u, "meta_ready = 0");
|
||
CHECK(wave_ring_read_ch(0u, 0u, 8u, buf) == WAVE_ST_E_STATE, "未 latch 读被拒");
|
||
CHECK(wave_ring_sealed_meta(&meta) == WAVE_ST_E_STATE, "未 latch 段头被拒");
|
||
/* 此刻 latch 是合法时机 */
|
||
wave_fill_cal(&s_cal, 0u);
|
||
s_cal.eng = 9u;
|
||
CHECK(wave_ring_latch_meta(&s_cal) == WAVE_ST_E_PARAM, "折算档位非法拒绝");
|
||
s_cal.eng = (uint8_t)WAVE_ENG_PIN;
|
||
CHECK(wave_ring_latch_meta(&s_cal) == WAVE_ST_OK, "latch 成功");
|
||
CHECK(wave_ring_sealed() == 1u, "latch 后可用（两个标志并成一个）");
|
||
/* 第二次交棒：必须整份拒绝，锁存值一个字节都不许被换掉 */
|
||
{
|
||
uint32_t wall0 = s_cal.wall;
|
||
s_cal.wall = 123u;
|
||
s_cal.clip_mask = 0x0000u;
|
||
CHECK(wave_ring_latch_meta(&s_cal) == WAVE_ST_E_STATE, "重复 latch 拒绝");
|
||
CHECK(wave_ring_sealed_meta(&meta) == WAVE_ST_OK, "latch 后段头可读");
|
||
CHECK((meta.wall == wall0) && (meta.clip_mask == 0x00E6u),
|
||
"重复 latch 没有覆盖已锁存值（半路换系数会让头与数据不同源）");
|
||
s_cal.wall = wall0;
|
||
}
|
||
CHECK((meta.fs_hz == (uint16_t)WAVE_ST_FS_DEF) && (meta.pts_per_cycle == (uint8_t)WAVE_ST_PPC_DEF),
|
||
"段头采样率与每周波点数按 §6.2 落值");
|
||
CHECK((meta.ch_count == (uint8_t)WAVE_RING_CH) && (meta.pts_per_ch == (uint16_t)WAVE_RING_PTS) &&
|
||
(meta.pre_pts == (uint16_t)WAVE_RING_PRE), "段头几何三要素与环一致");
|
||
CHECK((meta.trig_src == (uint8_t)WAVE_TRIG_MANUAL) && (meta.trig_elm == 7u),
|
||
"触发源与元件序号进段头");
|
||
CHECK((meta.t0_ms == s_trig_first) && (meta.frame_seq == s_trig_first),
|
||
"段首毫秒与帧序号取触发那一拍（不是封段那一拍）");
|
||
CHECK((meta.flags_seq == s_cal.flags_seq) && (meta.clip_mask == 0x00E6u),
|
||
"有效性位图与削顶位图进段头");
|
||
{
|
||
uint8_t i;
|
||
int ok = 1;
|
||
for (i = 0u; i < (uint8_t)WAVE_RING_CH; i++) {
|
||
if ((meta.ch[i].sem != i) || (meta.ch[i].conv != s_cal.ch[i].conv) ||
|
||
(meta.ch[i].bits != s_cal.ch[i].bits) || (meta.ch[i].avail != s_cal.ch[i].avail) ||
|
||
(meta.ch[i].k_q16 != s_cal.ch[i].k_q16) || (meta.ch[i].b_codes != s_cal.ch[i].b_codes)) {
|
||
ok = 0;
|
||
}
|
||
}
|
||
CHECK(ok != 0, "通道表 8 项逐项进段头（sem = 下标）");
|
||
}
|
||
}
|
||
|
||
/* ---------- 用例：段内容与点序 ---------- */
|
||
printf("-- 用例：段内容与点序 --\n");
|
||
CHECK(wave_cmp_all(s_trig_first) != 0, "8 列 × 320 点逐点等于影子样本（列序 = 语义序）");
|
||
{
|
||
int16_t buf[WAVE_RING_PTS];
|
||
(void)wave_ring_read_ch(0u, 0u, (uint16_t)WAVE_RING_PTS, buf);
|
||
CHECK(buf[WAVE_RING_PRE - 1u] == wave_sig(s_trig_first, 0u),
|
||
"触发那一拍的样本落在点 159（预触发窗最后一点）");
|
||
CHECK(buf[WAVE_RING_PRE] == wave_sig(s_trig_first + 1u, 0u),
|
||
"点 160 是触发之后第一拍");
|
||
CHECK(buf[0] == wave_sig(s_trig_first - (WAVE_RING_PRE - 1u), 0u),
|
||
"点 0 是最老的预触发点（段首基址钉对了）");
|
||
CHECK(buf[1] > buf[0], "斜坡单调 -> 点序没有倒过来");
|
||
}
|
||
|
||
/* ---------- 用例：SEALED 丢样本 + 写指针真冻结 ---------- */
|
||
printf("-- 用例：SEALED 丢样本与写指针冻结 --\n");
|
||
{
|
||
wave_ring_stat_t st0;
|
||
wave_ring_stat_t st1;
|
||
(void)wave_ring_get_stat(&st0);
|
||
wave_step(10u);
|
||
(void)wave_ring_get_stat(&st1);
|
||
CHECK(s_push_last == WAVE_ST_DONE, "SEALED 期间 push 返 DONE（样本被丢）");
|
||
CHECK(st1.drop_cnt == (st0.drop_cnt + (10u * (uint32_t)WAVE_RING_CH)),
|
||
"drop 计数单位 = 点（一次丢一拍加 8）");
|
||
CHECK(st1.seal_hold == (uint16_t)(st0.seal_hold + 10u), "SEALED 滞留按拍累计");
|
||
CHECK(wave_ring_state() == (uint8_t)WAVE_RING_ST_SEALED, "滞留未超时仍是 SEALED");
|
||
CHECK(wave_cmp_all(s_trig_first) != 0, "已封存区一个点都没被动过（写指针真冻住）");
|
||
}
|
||
|
||
/* ---------- 用例：读窗夹取 / 跨回绕 / read_cb ---------- */
|
||
printf("-- 用例：读窗夹取与跨回绕 --\n");
|
||
{
|
||
int16_t buf[WAVE_RING_PTS];
|
||
int32_t n;
|
||
uint32_t i;
|
||
int ok;
|
||
|
||
n = wave_ring_read_ch(3u, 300u, 40u, buf);
|
||
CHECK(n == 20, "超出段尾自动夹到剩余点数");
|
||
ok = 1;
|
||
for (i = 0u; i < 20u; i++) {
|
||
int32_t ks = wave_pt_sample(s_trig_first, 300u + i);
|
||
if (buf[i] != wave_sig((uint32_t)ks, 3u)) {
|
||
ok = 0;
|
||
}
|
||
}
|
||
CHECK(ok != 0, "夹出来的 20 点仍与影子样本一致（回绕段尾正确）");
|
||
/* base = 241（400 拍场景）-> 段内跨环尾的点必须靠取模接上 */
|
||
n = wave_ring_read_ch(5u, 70u, 20u, buf);
|
||
ok = 1;
|
||
for (i = 0u; i < (uint32_t)n; i++) {
|
||
int32_t ks = wave_pt_sample(s_trig_first, 70u + i);
|
||
if (buf[i] != wave_sig((uint32_t)ks, 5u)) {
|
||
ok = 0;
|
||
}
|
||
}
|
||
CHECK((n == 20) && (ok != 0), "跨越环尾的窗取模展开正确（段首基址 241）");
|
||
n = wave_ring_read_cb(NULL, 2u, 0u, (uint32_t)WAVE_RING_PTS, buf);
|
||
CHECK(n == (int32_t)WAVE_RING_PTS, "read_cb 32 位形态整段可读");
|
||
CHECK(wave_ring_read_cb(NULL, 2u, 0u, 9999u, buf) == WAVE_ST_E_PARAM, "read_cb 点数超过环长拒绝");
|
||
CHECK(wave_ring_read_cb(NULL, 2u, 9999u, 1u, buf) == WAVE_ST_E_RANGE, "read_cb 起点越界拒绝");
|
||
CHECK(wave_ring_read_ch(8u, 0u, 1u, buf) == WAVE_ST_E_RANGE, "列号越界");
|
||
CHECK(wave_ring_read_ch(0u, (uint16_t)WAVE_RING_PTS, 1u, buf) == WAVE_ST_E_RANGE, "起点越界");
|
||
CHECK(wave_ring_read_ch(0u, 0u, 0u, buf) == WAVE_ST_E_PARAM, "点数为 0");
|
||
CHECK(wave_ring_read_ch(0u, 0u, 1u, NULL) == WAVE_ST_E_PARAM, "读口空指针");
|
||
}
|
||
|
||
/* ---------- 用例：列号映射 ---------- */
|
||
printf("-- 用例：列号映射 --\n");
|
||
{
|
||
int ok = 1;
|
||
uint8_t i;
|
||
for (i = 0u; i < (uint8_t)WAVE_RING_CH; i++) {
|
||
if (wave_ring_col(i) != (int32_t)i) {
|
||
ok = 0;
|
||
}
|
||
}
|
||
CHECK(ok != 0, "0..7 语义号 -> 同列号（本波恒等）");
|
||
CHECK(wave_ring_col(8u) == WAVE_ST_E_RANGE, "TEMP 不录 -> 越界");
|
||
CHECK(wave_ring_col(200u) == WAVE_ST_E_RANGE, "非法语义号 -> 越界");
|
||
}
|
||
|
||
/* ---------- 用例：ACK 成功 + 冷却 + 二次触发 ---------- */
|
||
printf("-- 用例：ACK 与冷却 --\n");
|
||
{
|
||
wave_ring_stat_t st;
|
||
int16_t buf[8];
|
||
CHECK(wave_ring_write_done(0) == WAVE_ST_OK, "ACK 成功");
|
||
(void)wave_ring_get_stat(&st);
|
||
CHECK(wave_ring_state() == (uint8_t)WAVE_RING_ST_COOL, "ACK 后转冷却");
|
||
CHECK(st.cool_left == (uint16_t)WAVE_RING_COOL_MS, "冷却起表 500 拍");
|
||
CHECK((st.seg_total == 1u) && (st.seg_idx == 1u), "成功才推进轮转号与段计数");
|
||
CHECK(wave_ring_sealed() == 0u, "解冻后立刻不可读");
|
||
CHECK(wave_ring_read_ch(0u, 0u, 8u, buf) == WAVE_ST_E_STATE, "解冻后读被拒（不返旧数据）");
|
||
CHECK(wave_ring_write_done(0) == WAVE_ST_E_STATE, "重复 ACK 拒绝");
|
||
/* 冷却期内再触发：只加 ovf，绝不重录 */
|
||
CHECK(wave_ring_request((uint8_t)WAVE_TRIG_PROTECT, 3u) == WAVE_ST_DONE, "冷却期内请求被忽略");
|
||
(void)wave_ring_get_stat(&st);
|
||
CHECK(st.ovf_cnt == 1u, "ovf 计一次");
|
||
CHECK(wave_ring_state() == (uint8_t)WAVE_RING_ST_COOL, "被忽略的请求没有改状态");
|
||
wave_step(100u);
|
||
CHECK(wave_ring_state() == (uint8_t)WAVE_RING_ST_COOL, "冷却未走完仍在 COOL");
|
||
wave_step(400u);
|
||
CHECK(wave_ring_state() == (uint8_t)WAVE_RING_ST_IDLE, "冷却走完后回 IDLE");
|
||
}
|
||
|
||
/* ---------- 用例：ACK 失败不推进轮转号 ---------- */
|
||
printf("-- 用例：ACK 失败不推进号 --\n");
|
||
wave_seal_once((uint8_t)WAVE_TRIG_PROTECT, 2u);
|
||
wave_fill_cal(&s_cal, 1u);
|
||
CHECK(wave_ring_latch_meta(&s_cal) == WAVE_ST_OK, "第二段交棒 OK");
|
||
CHECK(wave_cmp_all(s_trig_first) != 0, "第二段内容 = 第二次故障的影子样本");
|
||
{
|
||
wave_ring_stat_t st;
|
||
CHECK(wave_ring_write_done(-5) == WAVE_ST_OK, "失败 ACK 仍解冻（错误只计数）");
|
||
(void)wave_ring_get_stat(&st);
|
||
CHECK(st.err_cnt == 1u, "err 计一次");
|
||
CHECK((st.seg_idx == 1u) && (st.seg_total == 1u), "失败不推进轮转号与段计数（下段同号）");
|
||
}
|
||
|
||
/* ---------- 用例：滞留超时自弃 ---------- */
|
||
printf("-- 用例：SEALED 滞留超时自弃 --\n");
|
||
wave_step((uint32_t)WAVE_RING_COOL_MS);
|
||
CHECK(wave_ring_state() == (uint8_t)WAVE_RING_ST_IDLE, "冷却走完回 IDLE");
|
||
wave_seal_once((uint8_t)WAVE_TRIG_BENCH, 0u);
|
||
wave_fill_cal(&s_cal, 2u);
|
||
CHECK(wave_ring_latch_meta(&s_cal) == WAVE_ST_OK, "第三段交棒 OK");
|
||
wave_step((uint32_t)WAVE_SEAL_TIMEOUT_MS - 1u);
|
||
CHECK(wave_ring_state() == (uint8_t)WAVE_RING_ST_SEALED, "差一拍还没到超时：仍 SEALED");
|
||
{
|
||
wave_ring_stat_t st0;
|
||
wave_ring_stat_t st1;
|
||
(void)wave_ring_get_stat(&st0);
|
||
wave_step(1u);
|
||
(void)wave_ring_get_stat(&st1);
|
||
CHECK(wave_ring_state() == (uint8_t)WAVE_RING_ST_COOL, "超时自弃并起冷却（绝不让环永久焊死）");
|
||
CHECK(st1.err_cnt == (st0.err_cnt + 1u), "自弃计 err");
|
||
CHECK(st1.seal_hold == 0u, "滞留计数清零");
|
||
CHECK((st1.seg_idx == st0.seg_idx) && (st1.seg_total == st0.seg_total),
|
||
"自弃不算成功：号与段计数都不动");
|
||
CHECK(wave_ring_sealed() == 0u, "自弃后不可读");
|
||
}
|
||
/* 自弃之后必须还能录下一段 */
|
||
wave_step((uint32_t)WAVE_RING_COOL_MS);
|
||
wave_seal_once((uint8_t)WAVE_TRIG_MANUAL, 0u);
|
||
wave_fill_cal(&s_cal, 3u);
|
||
CHECK(wave_ring_latch_meta(&s_cal) == WAVE_ST_OK, "自弃之后仍能录第四段");
|
||
CHECK(wave_cmp_all(s_trig_first) != 0, "第四段内容是新的故障（没被上一段污染）");
|
||
|
||
/* ---------- 用例：环未填满就触发 ---------- */
|
||
printf("-- 用例：环未填满就触发 --\n");
|
||
wave_ring_write_done(0);
|
||
wave_step((uint32_t)WAVE_RING_COOL_MS);
|
||
wave_ring_init();
|
||
s_k = 0u;
|
||
s_evt_sealed = 0u;
|
||
wave_step(30u);
|
||
wave_seal_once((uint8_t)WAVE_TRIG_MANUAL, 0u);
|
||
wave_fill_cal(&s_cal, 4u);
|
||
CHECK(wave_ring_latch_meta(&s_cal) == WAVE_ST_OK, "只采了 31 点也能封段交棒");
|
||
{
|
||
int16_t buf[WAVE_RING_PTS];
|
||
uint32_t i;
|
||
int zeros = 1;
|
||
int reals = 1;
|
||
(void)wave_ring_read_ch(0u, 0u, (uint16_t)WAVE_RING_PTS, buf);
|
||
for (i = 0u; i < 129u; i++) {
|
||
if (buf[i] != 0) {
|
||
zeros = 0;
|
||
}
|
||
}
|
||
for (i = 129u; i < (uint32_t)WAVE_RING_PTS; i++) {
|
||
if (buf[i] != wave_sig(i - 129u, 0u)) {
|
||
reals = 0;
|
||
}
|
||
}
|
||
CHECK(zeros != 0, "前导 129 点是 0（不是上一段残留，init 清零生效）");
|
||
CHECK(reals != 0, "真实样本从点 129 起接上（点 159 = 第 30 拍）");
|
||
}
|
||
|
||
printf("-- 用例：挂号载荷单字节往返（lead 评审 2026-10-29 交错缺陷） --\n");
|
||
{
|
||
static const uint8_t k_src[3] = { 1u, 2u, 3u };
|
||
static const uint8_t k_elm[3] = { 0u, 1u, 31u };
|
||
uint32_t a;
|
||
uint32_t b;
|
||
int accept_all = 1;
|
||
int second_rejected = 1;
|
||
int ovf_once = 1;
|
||
int decoded_ok = 1;
|
||
int head_identity = 1;
|
||
|
||
for (a = 0u; a < 3u; a++) {
|
||
for (b = 0u; b < 3u; b++) {
|
||
wave_ring_stat_t st0;
|
||
wave_ring_stat_t st1;
|
||
wave_seg_meta_t meta;
|
||
uint8_t src = k_src[a];
|
||
uint8_t elm = k_elm[b];
|
||
|
||
wave_ring_init();
|
||
s_k = 0u;
|
||
s_evt_sealed = 0u;
|
||
wave_step(20u);
|
||
if (wave_ring_request(src, elm) != WAVE_ST_OK) {
|
||
accept_all = 0;
|
||
}
|
||
/* 交错形状：adcTask 还没 tick（挂号未被消费）时又来了第二个请求。
|
||
* 旧实现在这里已经写完了挂号位、载荷还没写完，本条用例就是那个形状 */
|
||
if (wave_ring_request(k_src[(a + 1u) % 3u], 9u) != WAVE_ST_DONE) {
|
||
second_rejected = 0;
|
||
}
|
||
(void)wave_ring_get_stat(&st0);
|
||
if (st0.ovf_cnt != 1u) {
|
||
ovf_once = 0;
|
||
}
|
||
wave_step(1u);
|
||
(void)wave_ring_get_stat(&st1);
|
||
if ((st1.trig_src != src) || (st1.trig_elm != elm)) {
|
||
decoded_ok = 0;
|
||
}
|
||
wave_step((uint32_t)WAVE_RING_POST);
|
||
wave_fill_cal(&s_cal, 0u);
|
||
if ((wave_ring_latch_meta(&s_cal) != WAVE_ST_OK)
|
||
|| (wave_ring_sealed_meta(&meta) != WAVE_ST_OK)
|
||
|| (meta.trig_src != src) || (meta.trig_elm != elm)) {
|
||
head_identity = 0;
|
||
}
|
||
(void)wave_ring_write_done(0);
|
||
wave_step((uint32_t)WAVE_RING_COOL_MS);
|
||
}
|
||
}
|
||
CHECK(accept_all == 1, "九个触发源与元件号组合全部受理");
|
||
CHECK(second_rejected == 1, "挂号未被消费的窗口里第二个请求一律被拒（交错形状）");
|
||
CHECK(ovf_once == 1, "被拒那次只加一次 ovf，不重录不排队");
|
||
CHECK(decoded_ok == 1, "下一拍解码出的触发源与元件号就是本次投递值");
|
||
CHECK(head_identity == 1, "封段交棒后段头身份仍是本次投递值（文件格式没多一个字节）");
|
||
}
|
||
|
||
printf("-- 用例：元件号越界当场拒且不记 ovf 账 --\n");
|
||
{
|
||
wave_ring_stat_t st;
|
||
|
||
wave_ring_init();
|
||
s_k = 0u;
|
||
s_evt_sealed = 0u;
|
||
wave_step(10u);
|
||
CHECK(wave_ring_request((uint8_t)WAVE_TRIG_PROTECT, 32u) == WAVE_ST_E_PARAM, "元件号 32 拒绝（载荷只有 5 位，越界不许静默截断）");
|
||
CHECK(wave_ring_request((uint8_t)WAVE_TRIG_PROTECT, 255u) == WAVE_ST_E_PARAM, "元件号 255 拒绝");
|
||
CHECK(wave_ring_request(0u, 5u) == WAVE_ST_E_PARAM, "触发源 0 带合法元件号也拒");
|
||
CHECK(wave_ring_request(4u, 5u) == WAVE_ST_E_PARAM, "触发源 4 带合法元件号也拒");
|
||
(void)wave_ring_get_stat(&st);
|
||
CHECK(st.ovf_cnt == 0u, "四条参数错一条都没记进 ovf（参数错不是第二次触发）");
|
||
CHECK(wave_ring_state() == (uint8_t)WAVE_RING_ST_IDLE, "参数错没有留下任何挂号");
|
||
wave_step(1u);
|
||
CHECK(wave_ring_state() == (uint8_t)WAVE_RING_ST_IDLE, "空跑一拍仍是 IDLE（没有凭空开录）");
|
||
CHECK(wave_ring_request((uint8_t)WAVE_TRIG_PROTECT, 31u) == WAVE_ST_OK, "越界值拒完之后 31 号元件照样能挂号");
|
||
}
|
||
|
||
printf("\n=== Wave Ring Tests: %d/%d PASSED (failed=%d) ===\n", s_passed, s_total, s_failed);
|
||
return (s_failed == 0) ? 0 : 1;
|
||
}
|