/* * 模块名称:ADC 采样有效性校验(L1-6)主机侧单元测试 * 模块功能:在 PC 上对 App/algo/adc_health.c 做离线验证。 * * 被测对象:真实源文件(以 #include 原样纳入,保证测的是生产代码而非副本): * ../../../App/algo/adc_health.c * 本层为**纯逻辑**(仅 stdint.h),**无需任何桩**。 * * 为什么要主机侧单测(而不是只用板端闭环): * 1. 静默/倒退/错误增量在健康台架上**不可复现**(复现 = 拔芯片/改驱动), * 板端只能证明"健康时不误报",证不了"故障时必报"; * 2. 边界(恰好 100ms 门限 / tick 回绕 / 序号倒退后再前进 / 事件只发一拍) * 只有合成计数序列能精确构造; * 3. 不占 MCU 的 RAM,毫秒级完成。 * * 覆盖点(对应 docs/算法/继电保护功能复现规划.md §3.1 L1-6): * TC-AH-001 init + 首拍只建基线(不误报) * TC-AH-002 正常 1 kHz 推进 2000 拍:零故障零事件(健康不误报) * TC-AH-003 TPAFE 静默:99ms 不报 / 100ms 报 / 恢复清除电平位、锁存位留痕 * TC-AH-004 STM32 静默:TPAFE 正常时只报 STM32 侧 * TC-AH-005 TPAFE 丢帧:d=3 → tgap+=2、事件仅当拍(边沿语义) * TC-AH-006 STM32 gap 计数增量 → 事件(不入锁存:超拍非故障) * TC-AH-007 序号倒退 → SEQ_BACKWARD 锁存(前进后仍留痕) * TC-AH-008 FRSTDATA / STM32_ERR / HW_ERR 增量 → 事件位与锁存位编号一致 * TC-AH-009 tick 回绕:跨 0xFFFFFFFF 的正常推进不误报静默;回绕后冻结仍报 * TC-AH-010 NULL 守卫:in=NULL 跳过;out=NULL 只更新内部状态 * TC-AH-011 init 幂等:故障后 re-init 全清 * * 通过:全部 TC PASS(main 返回 0)。 * 入口:int main(void),返回 0=PASS / 1=FAIL(由 run 脚本判读)。 * * 创建日期:2026-10-11 */ #include #include /* ===================== 断言 ===================== */ 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 "adc_health.c" /* ===================== 工具 ===================== */ /* 构造一份"健康"计数快照模板:两侧序号同拍号 seq,错误计数全 0 */ static adc_health_in_t mk_in(uint32_t seq, uint32_t now_ms) { adc_health_in_t in; in.tpafe_seq = seq; in.tpafe_frst_err = 0u; in.stm32_seq = seq; in.stm32_errs = 0u; in.stm32_gaps = 0u; in.stm32_hw_errs = 0u; in.now_ms = now_ms; return in; } /* ===================== TC ===================== */ /* TC-AH-001:init + 首拍只建基线 */ static void tc_prime(void) { adc_health_in_t in; adc_health_status_t st; adc_health_init(); in = mk_in(12345u, 1000u); /* 开机时序号已非 0 */ adc_health_check(&in, &st); CHECK((st.flags == 0u) && (st.events == 0u) && (st.sticky == 0u) && (st.tpafe_gaps == 0u), "TC-AH-001 first check only primes: no flags/events/sticky"); /* 第二拍序号未动但仅 1ms(< 门限)→ 仍不报 */ in.now_ms = 1001u; adc_health_check(&in, &st); CHECK(st.flags == 0u, "TC-AH-001 1ms without advance is not a stall"); } /* TC-AH-002:正常 1 kHz 推进 2000 拍零误报 */ static void tc_healthy(void) { adc_health_status_t st; adc_health_in_t in; uint32_t seq = 0u, now = 0u; int i, ok = 1; adc_health_init(); for (i = 0; i < 2000; i++) { in = mk_in(seq, now); adc_health_check(&in, &st); if ((st.flags != 0u) || (st.events != 0u) || (st.sticky != 0u)) { ok = 0; } seq++; now++; } CHECK(ok, "TC-AH-002 healthy 1kHz sweep 2000 beats: zero flags/events"); } /* TC-AH-003:TPAFE 静默 99/100ms 门限 + 恢复留痕 */ static void tc_tpafe_stall(void) { adc_health_status_t st; adc_health_in_t in; uint32_t seq = 500u, now = 500u; int i; adc_health_init(); /* 先跑 10 拍健康节拍建立"前进中"基线 */ for (i = 0; i < 10; i++) { in = mk_in(seq, now); adc_health_check(&in, &st); seq++; now++; } /* 仅 TPAFE 冻结(STM32 继续走):前 100 拍(elapsed 0..99ms)不报。 * 注意第 1 拍会消费掉 healthy 循环末尾"未消费的那次 +1", * 故静默计时从 now=510 起算,第 i 拍 elapsed = i。 */ for (i = 0; i < 100; i++) { in = mk_in(seq, now); in.stm32_seq = seq + (uint32_t)i + 1u; /* STM32 侧照常前进 */ adc_health_check(&in, &st); now++; } CHECK((st.flags & ADC_HF_TPAFE_STALL) == 0u, "TC-AH-003 no TPAFE stall before 100ms"); /* 第 100ms:报 */ in = mk_in(seq, now); in.stm32_seq = seq + 100u; adc_health_check(&in, &st); CHECK((st.flags & ADC_HF_TPAFE_STALL) != 0u, "TC-AH-003 TPAFE stall at 100ms"); CHECK((st.sticky & ADC_HF_TPAFE_STALL) != 0u, "TC-AH-003 stall latched into sticky"); CHECK(st.tpafe_stall_ms >= ADC_HEALTH_STALL_MS, "TC-AH-003 stall_ms reported >= threshold"); /* 恢复:TPAFE 序号重新前进 → 电平位清除、sticky 留痕 */ in = mk_in(seq + 1u, now + 1u); in.stm32_seq = seq + 101u; adc_health_check(&in, &st); CHECK((st.flags & ADC_HF_TPAFE_STALL) == 0u, "TC-AH-003 stall level clears on recovery"); CHECK((adc_health_sticky() & ADC_HF_TPAFE_STALL) != 0u, "TC-AH-003 sticky keeps the fault trace after recovery"); } /* TC-AH-004:STM32 静默(TPAFE 正常) */ static void tc_stm32_stall(void) { adc_health_status_t st; adc_health_in_t in; uint32_t seq = 100u, now = 100u; int i; adc_health_init(); for (i = 0; i < 10; i++) { in = mk_in(seq, now); adc_health_check(&in, &st); seq++; now++; } /* STM32 冻结(TPAFE 继续走)。⚠ 第 1 拍消费 healthy 循环末尾的"未消费 +1" * 并把静默计时起点重置为该拍 now → 第 i 拍 elapsed = i,需 101 拍才到 100ms */ for (i = 0; i < 101; i++) { in = mk_in(seq + (uint32_t)i + 1u, now + (uint32_t)i + 1u); in.stm32_seq = seq; /* 冻结在旧值 */ adc_health_check(&in, &st); } CHECK((st.flags & ADC_HF_STM32_STALL) != 0u, "TC-AH-004 STM32 stall at 100ms"); CHECK((st.flags & ADC_HF_TPAFE_STALL) == 0u, "TC-AH-004 healthy TPAFE not falsely stalled"); } /* TC-AH-005:TPAFE 丢帧计数 + 边沿语义 */ static void tc_tpafe_gap(void) { adc_health_status_t st; adc_health_in_t in; adc_health_init(); in = mk_in(10u, 10u); adc_health_check(&in, &st); /* 基线 */ in.tpafe_seq = 13u; in.stm32_seq = 11u; in.now_ms = 11u; /* TPAFE d=3 */ adc_health_check(&in, &st); CHECK((st.events & ADC_HE_TPAFE_GAP) != 0u, "TC-AH-005 gap event on d>1"); CHECK(st.tpafe_gaps == 2u, "TC-AH-005 d=3 accumulates 2 lost points"); in.tpafe_seq = 14u; in.stm32_seq = 12u; in.now_ms = 12u; /* 恢复正常 d=1 */ adc_health_check(&in, &st); CHECK(st.events == 0u, "TC-AH-005 gap event is edge-only (next beat clean)"); CHECK(st.tpafe_gaps == 2u, "TC-AH-005 gap counter is cumulative"); } /* TC-AH-006:STM32 gap 计数增量 → 事件、不入锁存 */ static void tc_stm32_gap(void) { adc_health_status_t st; adc_health_in_t in; adc_health_init(); in = mk_in(1u, 1u); adc_health_check(&in, &st); in.stm32_gaps = 1u; in.tpafe_seq = 2u; in.stm32_seq = 2u; in.now_ms = 2u; adc_health_check(&in, &st); CHECK((st.events & ADC_HE_STM32_GAP) != 0u, "TC-AH-006 STM32 gap increment raises event"); CHECK((st.sticky & (ADC_HF_FRSTDATA | ADC_HF_STM32_ERR | ADC_HF_HW_ERR)) == 0u, "TC-AH-006 gap does NOT latch sticky (overrun is not a fault)"); } /* TC-AH-007:序号倒退 → 锁存 */ static void tc_backward(void) { adc_health_status_t st; adc_health_in_t in; uint32_t s, t; int i; adc_health_init(); in = mk_in(1000u, 100u); adc_health_check(&in, &st); in.tpafe_seq = 995u; in.stm32_seq = 995u; in.now_ms = 101u; /* 倒退 */ adc_health_check(&in, &st); CHECK((st.flags & ADC_HF_SEQ_BACKWARD) != 0u, "TC-AH-007 backward seq raises latched flag"); CHECK((st.sticky & ADC_HF_SEQ_BACKWARD) != 0u, "TC-AH-007 backward latched into sticky"); /* 恢复正常推进 50 拍:SEQ_BACKWARD 不清(锁存语义) */ s = 996u; t = 102u; for (i = 0; i < 50; i++) { in = mk_in(s, t); adc_health_check(&in, &st); s++; t++; } CHECK((adc_health_flags() & ADC_HF_SEQ_BACKWARD) != 0u, "TC-AH-007 SEQ_BACKWARD persists after normal advance"); } /* TC-AH-008:三类错误计数增量 → 事件位与锁存位编号一致 */ static void tc_err_counters(void) { adc_health_status_t st; adc_health_in_t in; adc_health_init(); in = mk_in(1u, 1u); adc_health_check(&in, &st); in.tpafe_seq = 2u; in.stm32_seq = 2u; in.now_ms = 2u; in.tpafe_frst_err = 1u; adc_health_check(&in, &st); CHECK(((st.events & ADC_HE_FRSTDATA) != 0u) && ((st.sticky & ADC_HF_FRSTDATA) != 0u), "TC-AH-008 FRSTDATA increment: event + sticky (same bit number)"); in.tpafe_seq = 3u; in.stm32_seq = 3u; in.now_ms = 3u; in.stm32_errs = 1u; adc_health_check(&in, &st); CHECK(((st.events & ADC_HE_STM32_ERR) != 0u) && ((st.sticky & ADC_HF_STM32_ERR) != 0u), "TC-AH-008 STM32 err increment: event + sticky (same bit number)"); in.tpafe_seq = 4u; in.stm32_seq = 4u; in.now_ms = 4u; in.stm32_hw_errs = 1u; adc_health_check(&in, &st); CHECK(((st.events & ADC_HE_HW_ERR) != 0u) && ((st.sticky & ADC_HF_HW_ERR) != 0u), "TC-AH-008 HAL err increment: event + sticky (same bit number)"); /* 计数不再变化 → 事件不再重复触发 */ in.tpafe_seq = 5u; in.stm32_seq = 5u; in.now_ms = 5u; adc_health_check(&in, &st); CHECK(st.events == 0u, "TC-AH-008 steady error counters raise no repeat events"); } /* TC-AH-009:tick 回绕安全 */ static void tc_tick_wrap(void) { adc_health_status_t st; adc_health_in_t in; uint32_t seq = 70000u, now = 0xFFFFFF00u; int i, ok = 1; adc_health_init(); /* 跨 0xFFFFFFFF 正常推进 512 拍:不得误报静默 */ for (i = 0; i < 512; i++) { in = mk_in(seq, now); adc_health_check(&in, &st); if (st.flags != 0u) { ok = 0; } seq++; now++; /* uint32 自然回绕 */ } CHECK(ok, "TC-AH-009 tick wrap sweep: no false stall"); /* 回绕后两侧同时冻结。⚠ 第 1 拍消费 sweep 末尾的"未消费 +1"并重置计时起点 * → 第 i 拍 elapsed = i,需 101 拍才到 100ms */ for (i = 0; i < 101; i++) { in = mk_in(seq, now); adc_health_check(&in, &st); now++; } CHECK(((st.flags & ADC_HF_TPAFE_STALL) != 0u) && ((st.flags & ADC_HF_STM32_STALL) != 0u), "TC-AH-009 stall still detected after tick wrap"); } /* TC-AH-010:NULL 守卫 */ static void tc_null_guard(void) { adc_health_status_t st; adc_health_in_t in; int i; adc_health_init(); in = mk_in(1u, 1u); adc_health_check(&in, &st); st.flags = 0xA5A5A5A5u; adc_health_check(NULL, &st); CHECK(st.flags == 0xA5A5A5A5u, "TC-AH-010 in=NULL leaves out untouched"); /* out=NULL:内部状态照常更新(两侧冻结 101 拍 → 静默位应出现) */ for (i = 0; i < 101; i++) { in = mk_in(1u, (uint32_t)(2 + i)); adc_health_check(&in, NULL); } CHECK((adc_health_flags() & ADC_HF_TPAFE_STALL) != 0u, "TC-AH-010 out=NULL still updates internal state"); } /* TC-AH-011:init 幂等 / 故障后全清 */ static void tc_reinit(void) { adc_health_status_t st; adc_health_in_t in; int i; adc_health_init(); in = mk_in(1u, 1u); adc_health_check(&in, &st); for (i = 0; i < 150; i++) { /* 制造双侧静默 */ in = mk_in(1u, (uint32_t)(2 + i)); adc_health_check(&in, &st); } CHECK(st.sticky != 0u, "TC-AH-011 pre: sticky non-zero before re-init"); adc_health_init(); CHECK((adc_health_flags() == 0u) && (adc_health_sticky() == 0u) && (adc_health_tpafe_gaps() == 0u), "TC-AH-011 re-init clears flags/sticky/gaps"); in = mk_in(9u, 9u); /* 序号跳变也无妨:首拍只建基线 */ adc_health_check(&in, &st); CHECK((st.flags == 0u) && (st.events == 0u), "TC-AH-011 re-prime after re-init is clean"); } int main(void) { printf("=== ADC Health Tests ===\n"); printf("-- prime / healthy --\n"); tc_prime(); tc_healthy(); printf("-- stall (TPAFE / STM32) --\n"); tc_tpafe_stall(); tc_stm32_stall(); printf("-- gap / backward / err counters --\n"); tc_tpafe_gap(); tc_stm32_gap(); tc_backward(); tc_err_counters(); printf("-- tick wrap / guards / re-init --\n"); tc_tick_wrap(); tc_null_guard(); tc_reinit(); printf("\n=== ADC Health Tests: %d/%d PASSED (failed=%d) ===\n", s_passed, s_total, s_failed); return (s_failed == 0) ? 0 : 1; }