Files
STM32F4-Base/test/board/ioboard_test_task.c
T
wandering1 3e80c301e5 fix(ioboard): repair three judgement bugs in the DI/DO board suite
The suite ran on the bench and reset the target every 56 seconds, right
after the last Phase 3 assertion. Root cause was the suite itself: the
worker thread entry function returned instead of calling vTaskDelete.
Returning from a FreeRTOS task function is undefined behaviour, and on the
Cortex-M4F port the saved LR points at prvTaskExitError, so the return
trips configASSERT. This project routes configASSERT to
vApplicationAssertFailed, which resets the MCU. The assert banner never
reached the console because the reset happened 0.27 s after the last
line, while its bytes were still queued.

Two assertions were also wrong in ways that hid real state:

- The "which relay is commanded" mask was computed as MASK_ALL & ~bit,
  i.e. the complement of what the comment claimed, so the suite reported
  the three idle relays as commanded and failed every Phase 3 row even
  though the shadow register was correct.
- The "other relays stay released" check was written as (a|b)==b, which
  is the same predicate as "at least bit b set" and therefore duplicated
  the check above it instead of testing the remaining channels. It now
  asserts (active & ~only)==0.

Phase counters are also reset on entry to each phase. The report macro
only prints, so without a reset each phase summary carried every earlier
phase's failures and Phase 2 read 44/62 with no failures of its own.

Hard-coded 0x0F masks are replaced by IOBOARD_TEST_DO_MASK_ALL.

Bench result after the fix: the suite completes in about 54 s with one
reset cause line (boot only), and prints Phase 4, the final release check
and "IOBOARD Tests: 17/17 PASSED". Phase 2 moves to 21/21 and Phase 3 to
16/16.

Still unverified, and not claimed as passing: the eight DI channel order
needs a person to short the terminals, and the relay polarity needs a
person to hear the contacts. Note that ioboard_do_read_level reads ODR,
so the Phase 3 level assertions prove write intent propagation, not
electrical actuation.

Keil build with the suite enabled: Code=264880, 0 errors 0 warnings.
Product build after the suite switch is restored: Code=257932, unchanged.
2026-11-16 19:58:52 +08:00

809 lines
40 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/******************************************************************************
* 模块名称:开入开出板(IOBOARD)板级测试套件
* 模块功能:为 74HC165 八路开入与四路光耦继电器开出提供台架观察窗口——
* 逐路给出「哪一路变了 / 变成什么」,而不是只给一个 0xFF 的混合图样。
*
* 为什么是**半自动**(本平台三条事实决定了它不能做成交互式):
* 一、没有串口输入通道:serial_tool.py 只有采集(log)与发送(send),
* 而 defaultTask 是唯一串口写者——套件读不到「操作员敲的命令」。
* 二、testTask 是 osPriorityBelowNormal,低于 defaultTask:defaultTask 的
* 1 ms 控制台排空循环会把低优先级的「靠 osDelay 等人」饿死。所以本套件
* **自起一个 Normal 优先级线程**(见 ioboard_test_run),不在 testTask
* 上下文里等人工。
* 三、人工动作只能靠**时间轴 + 提示**:日志打印「请短接 DI_A」,等 3 s,
* 然后采信。操作员要跟着日志节奏走。
*
* 开入位序为什么用「单比特两端 + 双射」而不是混合图样:
* 全短接读 0xFF / 全断开读 0x00 对位序完全不敏感(无论 bit 怎么排都是那两个值)。
* 逐个单比特短接才能把「第 k 路物理端子 ↔ mask 第 k 位」钉死;8 次单比特结果
* 必须是 8 个互不相同、各含 1 个 1 的掩码,且并起来恰好覆盖 bit0..bit7
* (双射)——这才排除了「两位同时被读成同一路」这类串扰。
*
* 与 defaultTask 的 HC165 竞争(调研结论,不是猜测):**本套件不干预 defaultTask 的轮询**
* 产品构建下 default_task_di_poll() 每主循环一轮(基准 50 ms)调 ioboard_di_read()
* 读同一组 PC2/PC3/PE3。驱动把「装载 + 8 拍移位」整段包在一个
* taskENTER_CRITICAL() 里(ioboard_di_read_impl)。据此四条结论:
* · **单次读内部不可能被另一处插进来**——两处绝不会读出"混杂位序"的半截数据;
* · 两处都**只读不写**引脚(SH/LD 装载 + 移位,不碰输出锁存),
* 且套件与 defaultTask 读的是同一物理状态,因此不存在数据损坏;
* · **时序上碰得到,但碰得到无害**:本套件的采样窗是 20 次读、彼此间隔 2 ms、
* 整窗约 40 ms;defaultTask 每 50 ms 读一次——40 ms 窗与 50 ms 周期**必然交叠**
* (几乎每窗至少一次),两者无法互避。交叠不影响单次读的完整性
* (两份都是临界区内的完整样本,见上面第一条),只影响**跨读者一致性**
* (即判据基准的纯粹性);而本套件自身判据的成立**不依赖** defaultTask 是否
* 同时读——它只依赖"套件自己这 20 次读的一致性与相对基线的差异";
* · 注意 40 ms 是**采样窗总时长,不是全程关中断**:每次读的临界区仅
* IOBOARD_DI_READ_MAX_US = 26 us,窗内绝大部分时间在 ioboard_io_delay 里让 CPU。
* 结论:风险不成立,故**不做任何干预**——不加编译开关、不加标志位、不改分片。
* 若台架实跑确实出现两份不一致的开入视图(例如本套件的
* "[PASS] other 7 unchanged" 判据假红),最小规避手段是让 defaultTask 的 poll
* 在套件期间跳过;**那需要改 App/task/default_task.c**,届时先报 Lead 定夺。
* 驱动实现(Drivers/BSP/IOBOARD/)与 App/util/ioboard_di.* 一行未改。
*
* 两处开入读的耗时口径:IOBOARD_DI_READ_MAX_US = 26 us(8 拍移位的时序上限,
* 见 ioboard.h),相对 50 ms 一拍占 0.05%,套件的 20 次采样也不会被它拖慢。
*
* 入口:ioboard_test_run()(由 start_test_task 经 TEST_SUITE_IOBOARD 调度)
* 创建日期:2026-11-16
******************************************************************************/
#include <string.h>
#include "ioboard.h" /* 板级套件在目标上编译:驱动函数声明 + IOBOARD_DO_* 位与极性宏 */
#include "bsp_err.h"
#include "ioboard_bits.h" /* IOBOARD_DI_COUNT / IOBOARD_DO_MASK_ALL(纯逻辑层,无 HAL 依赖) */
/* 先 include 套件头(它只依赖 test_common.h + stdint),再 include 驱动头;
* 与 sd2506 套件同序,保证「套件自述」出现在任何驱动依赖之前。 */
#include "ioboard_test.h"
#include "test_config.h"
#ifdef TEST_SUITE_IOBOARD
#include "ioboard.h" /* 板级套件在目标上编译:可直接取掩码宏与极性宏 */
#include "ioboard_bits.h"
#include "bsp_err.h"
#include "cmsis_os.h"
#include "FreeRTOS.h"
#include "task.h"
#include "main.h" /* HAL_GetTick(Inc/main.h → HAL 头);不能只依赖 cmsis_os.h 的间接包含 */
#define DBG_TAG "[IOBOARD_TEST]"
#include "dbg_log.h"
/* 套件汇总行名称:run_all_suites.py 的 --require-suite-summary 按它匹配 */
#define IOBOARD_TEST_SUMMARY_NAME "IOBOARD Tests"
/* 自起线程:Normal(= defaultTask 同级)。为什么不做 AboveNormal:
* 本线程绝大多数时间在 ioboard_io_delay 里让 CPU,只在打印与几十微秒的移位读时占用;
* 与 defaultTask 同级即可保证「osDelay 到期后与 defaultTask 公平竞争」,
* 不会因优先级太低被 defaultTask 的 1 ms 排空循环反复抢走而错过人工窗口。 */
#define IOBOARD_TEST_THREAD_STACK (1024U * 4U) /* 4 KB(1024 words) */
#define IOBOARD_TEST_THREAD_PRIO osPriorityNormal
/* 开入/开出路数的编译期一致性钉:ioboard.h 与 ioboard_di.h 刻意互不 include
* (后者是纯逻辑层),两者的一致性由这里钉死。 */
#define IOBOARD_TEST_DI_COUNT_EXPECT 8U
#define IOBOARD_TEST_DO_COUNT_EXPECT 4U
#if (IOBOARD_DI_COUNT != IOBOARD_TEST_DI_COUNT_EXPECT)
#error "IOBOARD_DI_CH_NUM/IOBOARD_DI_COUNT must be 8 (suite assumes 8 DI channels)"
#endif
#if (IOBOARD_DO_COUNT != IOBOARD_TEST_DO_COUNT_EXPECT)
#error "IOBOARD_DO_COUNT must be 4 (suite assumes 4 DO channels)"
#endif
#if (IOBOARD_TEST_DI_SAMPLE_GAP_MS > IOBOARD_TEST_DI_SAMPLE_GAP_MAX_MS)
#error "IOBOARD_TEST_DI_SAMPLE_GAP_MS too large"
#endif
#if (IOBOARD_TEST_DI_SAMPLES == 0U)
#error "IOBOARD_TEST_DI_SAMPLES must be > 0"
#endif
#define IOBOARD_TEST_DI_MASK_ALL ((uint8_t)IOBOARD_DI_MASK_ALL)
#define IOBOARD_TEST_DO_MASK_ALL ((uint8_t)IOBOARD_DO_MASK_ALL)
/* 进入各 Phase 前把统计清零:TEST_REPORT_IMPL 只打印、不自清零,若不清,
* Phase N 的汇总行会带上 Phase 1..N-1 的累计失败数(台架 2026-11-16 实证:
* Phase 2 报 "44/62 PASSED (failed=18)",那 18 条全是 Phase 1 的)。
* 套件级约定见 docs/测试说明/板级测试/SD2506_Test_Guide.md,先例见
* test/board/sd2506_test_task.c 进入各 Phase 前的 memset。 */
#define IOBOARD_TEST_STATS_RESET() do { \
(void)memset(&g_ioboard_test_stats, 0, sizeof(g_ioboard_test_stats)); \
} while (0)
/* 全局测试统计(宏自动管理) */
ioboard_test_stats_t g_ioboard_test_stats;
/* 自起线程的 TCB(静态分配,不走堆;本仓禁用 C 库堆分配) */
static StaticTask_t s_ioboard_thread_tcb;
static StackType_t s_ioboard_thread_stack[IOBOARD_TEST_THREAD_STACK / sizeof(StackType_t)];
/* 开入通道名(纯 ASCII 字符串字面量;中文只在注释里) */
static const char *const k_di_name[IOBOARD_TEST_DI_COUNT_EXPECT] = {
"DI_A", "DI_B", "DI_C", "DI_D", "DI_E", "DI_F", "DI_G", "DI_H"
};
/* 开出通道名(与八位语义位的顺序一一对应,见 ioboard.h 的 IOBOARD_DO_* 宏) */
static const uint8_t k_do_bit[IOBOARD_TEST_DO_COUNT_EXPECT] = {
(uint8_t)IOBOARD_DO_KO6, (uint8_t)IOBOARD_DO_TRIP,
(uint8_t)IOBOARD_DO_ERT, (uint8_t)IOBOARD_DO_CLZ
};
static const char *const k_do_name[IOBOARD_TEST_DO_COUNT_EXPECT] = {
"KO6", "TRIP", "ERT", "CLZ"
};
/* Phase 1 的单比特结果(0 = 本路未通过,不进双射核对的集合) */
static uint8_t s_phase1_mask[IOBOARD_TEST_DI_COUNT_EXPECT];
static uint8_t s_phase1_valid[IOBOARD_TEST_DI_COUNT_EXPECT];
/* ===================== 延时与开出安全 ===================== */
/* 基于 HAL_GetTick 的绝对时刻节拍延时。
* 为什么不用 `for (;;) { osDelay(1); }` 的近似凑数:tick 是 HAL 时基(TIM7,1 ms),
* 与调度器无关,绝对时刻判定在 tick 回绕处用无符号减法也安全。
*
* 函数功能:阻塞指定毫秒数,期间以 osDelay(1) 让出 CPU。
* 入口参数:ms - 延时毫秒数(0 时立即返回)
* 返回值:无
* 限定条件:仅限任务上下文(内部调 osDelay);不保证精确到 1 ms,只会 >= ms。
* 函数说明:用 HAL_GetTick() 的绝对时刻而非累加 osDelay(1) 的次数,
* 因此调度的抖动不会累积成"人工窗口整体偏短"。
*/
static void ioboard_io_delay(uint32_t ms)
{
uint32_t start = HAL_GetTick();
/* 反码比较:tick 回绕(49 天)时判定仍然正确 */
while ((uint32_t)(HAL_GetTick() - start) < ms) {
osDelay(1);
}
}
/*
* 函数功能:把「4 路电气电平」折回「4 路是否吸合」的位掩码
* 入口参数:level - ioboard_do_read_level() 回的电气电平(bit0..bit3 = 4 路)
* 返回值:每一位 1 = 该路吸合,0 = 该路释放
* 限定条件:纯函数,无副作用,任意上下文可调
* 函数说明:**逐位**折算——每一位 XOR 该位自己的 RELEASE 电平。这是唯一正确的形态:
* 吸合 ⇔ 电平 ≠ RELEASE。见 ioboard_release_all 上方注释里的反例。
*/
static uint8_t ioboard_level_to_attracted(uint8_t level)
{
#if (IOBOARD_DO_LEVEL_RELEASE != 0U)
/* RELEASE = 1 时逐位取反;否则电平本身就是"是否吸合" */
return (uint8_t)(~level & (uint8_t)IOBOARD_TEST_DO_MASK_ALL);
#else
return (uint8_t)(level & (uint8_t)IOBOARD_TEST_DO_MASK_ALL);
#endif
}
/*
* 全释放的**唯一出口**:任何失败路径、任何 Phase 收尾、线程退出前都必须过这里。
* 打印与断言分开——这样"释放"这个动作本身不会被套件的统计口径影响。
*
* 「与极性一致」的判法:ioboard_do_read_level() 给的是**电气电平**(1 = 引脚为高),
* 而 IOBOARD_DO_LEVEL_ACTIVE 定义了「吸合 = 高还是低」。把电气电平**折回"是否吸合"**
* 是「每一位都换成该位自己的语义」,所以折算必须**逐位**做:每位 XOR 上 RELEASE 电平。
* ⚠ 不能写成 `level ^ IOBOARD_DO_LEVEL_RELEASE` —— 那是把一个标量电平异或进整个掩码,
* RELEASE=0 时恒等(等于没折算),RELEASE=1 时把 4 位全部取反、语义彻底反过来。
* 2026-11-16 台架实证:本文件曾写 `level ^ (IOBOARD_DO_LEVEL_RELEASE & 0x0Fu)`,
* 在当前 RELEASE=0 下它是恒等变换,等价于「把电气电平原样当成吸合位掩码」。
* 这一写法在 RELEASE=0 时碰巧给出正确结果(因为那时"电平"就等于"吸合"),
* 但一旦有人把 IOBOARD_DO_LEVEL_ACTIVE 改成 0(极性反接),它会把 4 位全部取反,
* 判据整体自相矛盾地翻面。折算已收敛到下面这个函数,全文件只此一处。
*
* 函数功能:ioboard_do_write(0) 全释放,并回读电气电平核对是否真回到 RELEASE。
* 入口参数:where - 调用点标识(纯 ASCII,进日志用于定位是哪个 Phase 释放的)
* 返回值:无
* 限定条件:仅套件线程调用;内部不修改测试统计(避免"释放"动作污染 PASS/FAIL 计数)。
* 函数说明:写失败或回读不符都只打 !!! 级告警而不计 FAIL —— 这类故障意味着
* 硬件/驱动异常,台架日志里那条 !!! 比统计数字显眼得多。
*/
static void ioboard_release_all(const char *where)
{
uint8_t level = 0xFFu;
bsp_err_t rc = ioboard_do_write(0u);
if (rc != BSP_OK) {
DBG_ERROR("!!! RELEASE FAILED (%s): ioboard_do_write(0) ret=%d !!!",
where, (int)rc);
return;
}
(void)ioboard_do_read_level(&level);
if ((uint8_t)(level & IOBOARD_TEST_DO_MASK_ALL) !=
(uint8_t)(IOBOARD_DO_LEVEL_RELEASE & IOBOARD_TEST_DO_MASK_ALL)) {
DBG_ERROR("!!! RELEASE READBACK MISMATCH (%s): level=0x%02X expect release !!!",
where, (unsigned int)level);
}
}
/* 失败即刹车的醒目告警 + 全释放
*
* 函数功能:先在日志里打一条高可见度分隔告警(台架日志滚屏时不会被忽略),
* 再走 ioboard_release_all() 全释放。
* 入口参数:why - 失败原因(纯 ASCII,直接进日志)
* 返回值:无
* 限定条件:仅套件线程调用。本函数不修改测试统计——
* "释放动作是否成功"由 release_all 内部自行告警,不计入 PASS/FAIL 数。
*/
static void ioboard_emergency_release(const char *why)
{
DBG_ERROR("================ IOBOARD ALARM ================");
DBG_ERROR("!! %s -> all 4 relays released NOW !!", why);
ioboard_release_all("emergency");
DBG_ERROR("===============================================");
}
/* ===================== Phase 0:自检 ===================== */
/*
* 函数功能:Phase 0 —— 确认开入开出驱动在本构建下可用,并打出开出的当前原始电平。
* 入口参数:无
* 返回值:1 = 自检通过(驱动就绪、开出可读可写);0 = 不通过,调用方应整体判 FAIL
* 限定条件:仅套件线程调用;内部分别走一次 ioboard_di_read() 与 ioboard_do_read_level()。
* 函数说明:本题不做「值对不对」的判断——那要靠 Phase 1/3 的人工配合。
* 这里只回答一个前置问题:驱动是不是活的。
* 若驱动未初始化(g_ioboard_main_rc 失败)或读回 BSP 错误,
* 后面所有 Phase 的失败都会失去归因意义,故必须先停下来。
*/
static int ioboard_phase_selftest(void)
{
bsp_err_t rc;
uint8_t shadow = 0xFFu;
uint8_t level = 0xFFu;
int ok = 1;
DBG_INFO("=== IOBOARD Phase 0: self test (init / release state) ===");
rc = ioboard_init();
IOBOARD_TEST_CHECK(rc == BSP_OK,
"ioboard_init() ret=%d (expect 0; BSP_ERR_STATE=pin idle check failed)",
(int)rc);
if (rc != BSP_OK) {
DBG_ERROR("Phase 0 FAIL: ioboard_init() != BSP_OK -> ABORT whole suite");
ok = 0;
}
rc = ioboard_do_get(&shadow);
IOBOARD_TEST_CHECK(rc == BSP_OK, "ioboard_do_get() ret=%d", (int)rc);
rc = ioboard_do_read_level(&level);
IOBOARD_TEST_CHECK(rc == BSP_OK, "ioboard_do_read_level() ret=%d", (int)rc);
DBG_INFO(" DO shadow=0x%02X (bit0=KO6 bit1=TRIP bit2=ERT bit3=CLZ), GPIO level=0x%02X",
(unsigned int)shadow, (unsigned int)level);
DBG_INFO(" DO polarity: ACTIVE=%u RELEASE=%u",
(unsigned int)IOBOARD_DO_LEVEL_ACTIVE,
(unsigned int)IOBOARD_DO_LEVEL_RELEASE);
IOBOARD_TEST_CHECK((uint8_t)(shadow & IOBOARD_TEST_DO_MASK_ALL) == 0u,
"all 4 DO released at entry (shadow=0x%02X expect 0x00)",
(unsigned int)shadow);
IOBOARD_TEST_CHECK((uint8_t)(level & IOBOARD_TEST_DO_MASK_ALL) ==
(uint8_t)(IOBOARD_DO_LEVEL_RELEASE & IOBOARD_TEST_DO_MASK_ALL),
"all 4 DO pins at RELEASE level (level=0x%02X)",
(unsigned int)level);
IOBOARD_TEST_REPORT("Phase 0 self test");
return ok;
}
/* ===================== 开入采样内核 ===================== */
/*
* 采样一轮:在 gap_ms 内连读 samples 次,给出按位与/按位或与失败次数。
* 返回值:0 = 本轮的读成功次数都是 0(无法判定);1 = 至少读到一次。
*/
static uint8_t ioboard_di_sample(uint32_t samples, uint32_t gap_ms,
uint8_t *out_all, uint8_t *out_any,
uint32_t *out_ok, uint32_t *out_fail)
{
uint8_t allv = IOBOARD_TEST_DI_MASK_ALL;
uint8_t anyv = 0u;
uint32_t ok = 0u;
uint32_t fail = 0u;
uint32_t i;
uint8_t m = 0u;
for (i = 0u; i < samples; i++) {
if (ioboard_di_read(&m) == BSP_OK) {
allv = (uint8_t)(allv & m);
anyv = (uint8_t)(anyv | m);
ok++;
} else {
fail++;
}
if (gap_ms > 0u) {
ioboard_io_delay(gap_ms);
}
}
if (out_all != NULL) { *out_all = allv; }
if (out_any != NULL) { *out_any = anyv; }
if (out_ok != NULL) { *out_ok = ok; }
if (out_fail != NULL) { *out_fail = fail; }
return (ok > 0u) ? 1u : 0u;
}
/* 把 mask 写成 "bit7..bit0" 的可读串(1 = 该路开入为高)。
* buf 至少 IOBOARD_TEST_DI_COUNT_EXPECT + 1 字节。
*
* 函数功能:把 8 位开入 mask 渲染成 "01101001" 这样的定宽串,供日志逐位对照。
* 入口参数:mask - 开入 mask(bit7..bit0 对应 H..A 通道);buf - 输出缓冲
* 返回值:无
* 限定条件:buf 长度 >= IOBOARD_TEST_DI_COUNT_EXPECT + 1(含结尾 NUL),本函数不校验。
* 函数说明:为什么不用 %02X 就够了——十六进制要人在脑子里拆位,
* 而位序判据恰恰是"哪一位变了",定宽串让日志可以逐位目视比对。
*/
static void ioboard_di_mask_str(uint8_t mask, char *buf)
{
uint32_t bit;
for (bit = 0u; bit < (uint32_t)IOBOARD_TEST_DI_COUNT_EXPECT; bit++) {
uint32_t pos = (uint32_t)(IOBOARD_TEST_DI_COUNT_EXPECT - 1U) - bit;
buf[bit] = (((mask >> pos) & 1u) != 0u) ? '1' : '0';
}
buf[IOBOARD_TEST_DI_COUNT_EXPECT] = '\0';
}
/* ===================== Phase 1:开入位序(主判据) ===================== */
/*
* 函数功能:Phase 1 —— 逐路提示短接,验开入位序(本套件的**主判据**)。
* 入口参数:无
* 返回值:无(结果计入 g_ioboard_test_stats)
* 限定条件:需人工配合;每路给 IOBOARD_TEST_DI_ARM_MS 的动手窗口,超时不报错只采样。
* 函数说明:判据分三层,从弱到强——
* ① 单路:短接后**只有**该路对应的 bit 变化;
* ② 单路:**其余 7 位保持不变**(防"一短接就整体漂"的接线错误);
* ③ 双射(主判据):8 路各自得到的掩码必须是 8 个互不相同、各含 1 个 1 的掩码,
* 合起来恰好覆盖 bit0~bit7 全集。
* 为什么双射比"全短接读 0xFF / 全断开读 0x00"可靠:全 0 与全 1 对位序不敏感——
* 哪怕 A~H 的线整组接反,全 0/全 1 依然成立。只有"每路单独变化 + 8 个掩码互不相同"
* 才能把"接反"与"接错位"区分出来。混合图样只作辅助打印,不计入判据。
*/
static void ioboard_phase_di_order(void)
{
uint8_t baseline = 0u;
uint8_t allv = 0u;
uint8_t anyv = 0u;
uint32_t ok = 0u;
uint32_t fail = 0u;
uint32_t i;
uint8_t used = 0u;
int bij = 1;
char line[IOBOARD_TEST_DI_COUNT_EXPECT + 1U];
DBG_INFO("=== IOBOARD Phase 1: DI bit order (one channel at a time + bijection) ===");
IOBOARD_TEST_STATS_RESET();
/* 基线:全部断开时应为 0。先采一轮建立"静止基准",后面每一路都以它为参照。 */
if (ioboard_di_sample(IOBOARD_TEST_DI_SAMPLES, IOBOARD_TEST_DI_SAMPLE_GAP_MS,
&allv, &anyv, &ok, &fail) == 0u) {
DBG_ERROR("Phase 1 ABORT: cannot read DI at all (all %u reads failed)",
(unsigned int)IOBOARD_TEST_DI_SAMPLES);
IOBOARD_TEST_CHECK(0, "DI readable at Phase 1 entry (all reads failed)");
IOBOARD_TEST_REPORT("Phase 1 DI order");
return;
}
baseline = allv;
ioboard_di_mask_str(baseline, line);
IOBOARD_TEST_CHECK(anyv == allv,
"DI quiescent baseline stable during sampling (all=0x%02X any=0x%02X)",
(unsigned int)allv, (unsigned int)anyv);
DBG_INFO(" baseline (all DI open) = 0x%02X [bit7..bit0]=%s",
(unsigned int)baseline, line);
for (i = 0u; i < (uint32_t)IOBOARD_TEST_DI_COUNT_EXPECT; i++) {
uint8_t active = 0u;
uint8_t diff = 0u;
uint8_t others = 0u;
int one_bit;
s_phase1_mask[i] = 0u;
s_phase1_valid[i] = 0u;
DBG_INFO(" [%u/8] SHORT %s now (short DI terminal %u to common) .. sampling in %u ms",
(unsigned int)(i + 1u), k_di_name[i], (unsigned int)(i + 1u),
(unsigned int)IOBOARD_TEST_DI_ARM_MS);
ioboard_io_delay(IOBOARD_TEST_DI_ARM_MS);
if (ioboard_di_sample(IOBOARD_TEST_DI_SAMPLES, IOBOARD_TEST_DI_SAMPLE_GAP_MS,
&allv, &anyv, &ok, &fail) == 0u) {
IOBOARD_TEST_CHECK(0, "%s: DI unreadable while expected SHORTED (%u failed reads)",
k_di_name[i], (unsigned int)fail);
DBG_INFO(" -> release %s; waiting for next channel", k_di_name[i]);
continue;
}
active = allv;
diff = (uint8_t)(active ^ baseline);
/* "其余 7 位保持不变" = 只有 baseline 为 0 的那些位不许置 1;
* baseline 里本来就是 1 的位不参与这项(很多台架 DI 采用常闭/常开混接,
* 硬要求全 0 会把正确接线判成失败,见报告"与任务书的偏差")。 */
others = (uint8_t)(active & (uint8_t)(~baseline) & (uint8_t)(~diff));
one_bit = ((allv == anyv) && (diff != 0u) &&
(((uint32_t)diff & ((uint32_t)diff - 1u)) == 0u));
s_phase1_mask[i] = diff;
s_phase1_valid[i] = one_bit ? 1u : 0u;
ioboard_di_mask_str(active, line);
DBG_INFO(" read=0x%02X [bit7..bit0]=%s diff=0x%02X ok_reads=%u fails=%u",
(unsigned int)active, line, (unsigned int)diff,
(unsigned int)ok, (unsigned int)fail);
IOBOARD_TEST_CHECK(allv == anyv,
"%s: stable across %u samples (all=0x%02X any=0x%02X)",
k_di_name[i], (unsigned int)IOBOARD_TEST_DI_SAMPLES,
(unsigned int)allv, (unsigned int)anyv);
IOBOARD_TEST_CHECK(diff != 0u,
"%s: shorting it changed DI mask vs baseline=0x%02X (diff=0x%02X)",
k_di_name[i], (unsigned int)baseline, (unsigned int)diff);
IOBOARD_TEST_CHECK(others == 0u,
"%s: only this bit rose (other bits raised=0x%02X expect 0x00)",
k_di_name[i], (unsigned int)others);
IOBOARD_TEST_CHECK(one_bit,
"%s: exactly one bit changed (diff=0x%02X popcount must be 1)",
k_di_name[i], (unsigned int)diff);
if (one_bit) {
uint32_t p = 0u;
while ((((uint32_t)diff >> p) & 1u) == 0u) {
p++;
}
DBG_INFO(" -> %s maps to DI bit%u (terminal %u)",
k_di_name[i], (unsigned int)p, (unsigned int)(i + 1u));
} else {
DBG_ERROR(" -> %s did NOT produce a single-bit change; check terminal %u wiring",
k_di_name[i], (unsigned int)(i + 1u));
}
DBG_INFO(" RELEASE %s now; next channel in %u ms",
k_di_name[i], (unsigned int)IOBOARD_TEST_DI_ARM_MS);
/* 通道间留出"松开上一个、准备下一个"的时间,同时让本路变化回落到基线 */
ioboard_io_delay(IOBOARD_TEST_DI_ARM_MS);
}
/* 双射核对:8 次单比特结果必须两两不同,且并起来恰好覆盖 bit0..bit7 */
for (i = 0u; i < (uint32_t)IOBOARD_TEST_DI_COUNT_EXPECT; i++) {
if (s_phase1_valid[i] == 0u) {
bij = 0;
} else {
uint8_t dup = (uint8_t)(used & s_phase1_mask[i]);
if (dup != 0u) {
bij = 0;
}
used = (uint8_t)(used | s_phase1_mask[i]);
}
}
DBG_INFO(" bijection: union of per-channel masks = 0x%02X (expect 0x%02X)",
(unsigned int)used, (unsigned int)IOBOARD_TEST_DI_MASK_ALL);
IOBOARD_TEST_CHECK(used == IOBOARD_TEST_DI_MASK_ALL,
"bijection: 8 single-bit masks cover bit0..bit7 (union=0x%02X)",
(unsigned int)used);
IOBOARD_TEST_CHECK(bij == 1,
"bijection: 8 masks are 8 distinct single-bit values (no duplicate/multi-bit)");
/* 混合图样只作辅助:全断开读 0x00 / 全短接读 0xFF 对位序不敏感 */
IOBOARD_TEST_CHECK(baseline == 0x00u,
"aux: all DI open reads 0x00 (got 0x%02X; non-zero may be field wiring)",
(unsigned int)baseline);
DBG_INFO(" if any DI_x FAILED with 'exactly one bit': the terminal numbering in this"
" log is what you shorted - check the wiring of that terminal");
IOBOARD_TEST_REPORT("Phase 1 DI order");
}
/* ===================== Phase 2:回差与稳定性 ===================== */
/*
* 函数功能:Phase 2 —— 全断开保持期间连采多轮,验开入读数无抖动、无回差。
* 入口参数:无
* 返回值:无(结果计入 g_ioboard_test_stats)
* 限定条件:需人工保持全部 DI 端子断开;中途读取失败即中止本轮判据。
* 函数说明:每轮连读 IOBOARD_TEST_DI_SAMPLES 次,本轮内 all == any 才算"无抖动";
* 轮与轮之间的读数必须完全一致才算"无回差"。
* 判据选"轮内 all==any + 跨轮相等"而不是"20 次全等",是因为前者能区分
* 两种不同故障:轮内抖 = 触点/去抖没生效;跨轮不等 = 回差或干扰。
* 读失败时报 FAIL 并中止,不把"读不到"稀释成"数值不一致"。
*/
static void ioboard_phase_di_stable(void)
{
uint8_t allv = 0u;
uint8_t anyv = 0u;
uint32_t ok = 0u;
uint32_t fail = 0u;
uint32_t round;
uint8_t first = 0xFFu;
uint8_t differs = 0u;
char line[IOBOARD_TEST_DI_COUNT_EXPECT + 1U];
DBG_INFO("=== IOBOARD Phase 2: DI stability with all channels open ===");
IOBOARD_TEST_STATS_RESET();
DBG_INFO(" KEEP ALL DI TERMINALS OPEN for the next ~%u ms",
(unsigned int)(IOBOARD_TEST_DI_STABLE_ROUNDS *
(IOBOARD_TEST_DI_SAMPLES * IOBOARD_TEST_DI_SAMPLE_GAP_MS)));
for (round = 0u; round < (uint32_t)IOBOARD_TEST_DI_STABLE_ROUNDS; round++) {
/* 读失败即中止采样:继续读只会把「读不到」稀释成「数值不一致」,
* 那是把硬件故障误报成稳定性问题。用 break 退出(规范 CODE-RULE-07 禁 goto),
* 已采到的 first/differs 在循环后照常打印。 */
if (ioboard_di_sample(IOBOARD_TEST_DI_SAMPLES, IOBOARD_TEST_DI_SAMPLE_GAP_MS,
&allv, &anyv, &ok, &fail) == 0u) {
IOBOARD_TEST_CHECK(0, "stability round %u: DI unreadable (%u failed reads)",
(unsigned int)round, (unsigned int)fail);
break;
}
if (round == 0u) {
first = allv;
} else if (allv != first) {
differs++;
ioboard_di_mask_str(allv, line);
DBG_ERROR(" round %u differs: 0x%02X [bit7..bit0]=%s",
(unsigned int)round, (unsigned int)allv, line);
}
IOBOARD_TEST_CHECK(allv == anyv,
"stability round %u: no jitter inside round (all=0x%02X any=0x%02X)",
(unsigned int)round, (unsigned int)allv, (unsigned int)anyv);
}
/* 无论是否中途 break,都把「读到的第一轮值」和一致性结论打出来:
* abort_round 只影响「本轮判据是否算数」,不影响已经采到的证据。 */
(void)ok;
ioboard_di_mask_str(first, line);
DBG_INFO(" first-round reading = 0x%02X [bit7..bit0]=%s",
(unsigned int)first, line);
IOBOARD_TEST_CHECK(differs == 0u,
"stability: %u rounds all read the same value (differs=%u)",
(unsigned int)IOBOARD_TEST_DI_STABLE_ROUNDS, (unsigned int)differs);
IOBOARD_TEST_REPORT("Phase 2 DI stability");
}
/* ===================== Phase 3:开出逐个点动 ===================== */
/*
* 函数功能:Phase 3 —— 4 路开出逐个点动(空载),验动作与回读极性。
* 入口参数:无
* 返回值:无(结果计入 g_ioboard_test_stats)
* 限定条件:需人工听继电器动作声;**开出当前空载**,可安全点动。
* 函数说明:每路点动时长 IOBOARD_TEST_DO_ARM_MS(1 s,空载继电器动作声足以辨认)。
* 判据三条:
* ① ioboard_do_read_level() 回读电平与 IOBOARD_DO_LEVEL_ACTIVE 极性一致;
* ② 其余 3 路保持不吸合(防"一位写全组动"的锁存错误);
* ③ 释放后回读全部回到 IOBOARD_DO_LEVEL_RELEASE。
* ⚠ 若判据 ① 全线失败,第一嫌疑是**极性宏写反**而不是硬件损坏:
* ioboard.h 的 README 步骤 2 明确"DO 极性未在板上验证"。
* 日志里同时打出 RELEASE 与 ACTIVE 两个电平值,就是为了一眼分辨这一点。
* 任何一路写失败立即 ioboard_emergency_release 刹车并终止后续点动。
*/
static void ioboard_phase_do_actuation(void)
{
uint32_t i;
DBG_INFO("=== IOBOARD Phase 3: DO relay tap test (4 relays, NO LOAD) ===");
IOBOARD_TEST_STATS_RESET();
DBG_INFO(" listen for the relay click; release level = %u, active level = %u",
(unsigned int)IOBOARD_DO_LEVEL_RELEASE, (unsigned int)IOBOARD_DO_LEVEL_ACTIVE);
for (i = 0u; i < (uint32_t)IOBOARD_TEST_DO_COUNT_EXPECT; i++) {
uint8_t only = (uint8_t)(k_do_bit[i] & (uint8_t)IOBOARD_TEST_DO_MASK_ALL);
uint8_t shadow = 0xFFu;
uint8_t level = 0xFFu;
uint32_t active_bits;
bsp_err_t rc;
DBG_INFO(" [%u/4] CUE: %s relay will CLOSE for %u ms .. listen for click",
(unsigned int)(i + 1u), k_do_name[i], (unsigned int)IOBOARD_TEST_DO_ARM_MS);
rc = ioboard_do_write(only);
if (rc != BSP_OK) {
IOBOARD_TEST_CHECK(0, "%s: ioboard_do_write(0x%02X) ret=%d",
k_do_name[i], (unsigned int)only, (int)rc);
ioboard_emergency_release("ioboard_do_write failed");
ioboard_release_all("after emergency");
continue;
}
ioboard_io_delay(IOBOARD_TEST_DO_ARM_MS);
(void)ioboard_do_get(&shadow);
(void)ioboard_do_read_level(&level);
/* "与极性一致":按 IOBOARD_DO_LEVEL_ACTIVE 把电气电平折回"是否吸合" */
active_bits = ioboard_level_to_attracted(level);
DBG_INFO(" shadow=0x%02X level=0x%02X -> attracted=0x%02X (expected 0x%02X)",
(unsigned int)shadow, (unsigned int)level,
(unsigned int)active_bits, (unsigned int)k_do_bit[i]);
/* 三条断言分工不同,不要合并:
* ① 影子寄存器 == 只有这一路(写入意图是否正确落地)
* ② 该路确实处于吸合电平(极性折算是否正确)
* ③ 其余 3 路都没有被带起来(其余位全为 0,不是"至少有一位") */
IOBOARD_TEST_CHECK((uint8_t)(shadow & IOBOARD_TEST_DO_MASK_ALL) == only,
"%s: shadow=0x%02X (expect 0x%02X: only this bit set)",
k_do_name[i], (unsigned int)shadow, (unsigned int)only);
IOBOARD_TEST_CHECK((active_bits & k_do_bit[i]) != 0u,
"%s: pin at ACTIVE level while commanded (level=0x%02X)",
k_do_name[i], (unsigned int)level);
IOBOARD_TEST_CHECK((uint8_t)(active_bits & ~only) == 0u,
"%s: other 3 relays stay released (attracted=0x%02X)",
k_do_name[i], (unsigned int)active_bits);
/* 立即释放,并核对全部回到不吸合 */
ioboard_release_all("after tap");
(void)ioboard_do_read_level(&level);
IOBOARD_TEST_CHECK((uint8_t)(level & IOBOARD_TEST_DO_MASK_ALL) ==
(uint8_t)(IOBOARD_DO_LEVEL_RELEASE & IOBOARD_TEST_DO_MASK_ALL),
"%s: all 4 released after tap (level=0x%02X)",
k_do_name[i], (unsigned int)level);
ioboard_io_delay(IOBOARD_TEST_DO_RELEASE_MS);
}
IOBOARD_TEST_REPORT("Phase 3 DO actuation");
}
/* ===================== 序列主体 ===================== */
/*
* 函数功能:按 Phase 0→4 的顺序跑完整条半自动序列。
* 入口参数:无
* 返回值:无(结果全部计入 g_ioboard_test_stats)
* 限定条件:仅由套件线程调用;Phase 0 自检失败即整体中止(后续判据失去归因意义)。
* 函数说明:开头无条件 ioboard_release_all("suite entry"),Phase 之间每次跳转前
* 都过一次 release_all —— 这样"任何一条路径都不留下吸合的继电器"
* 只依赖一处实现,而不是每个分支各写一遍。
*/
static void ioboard_test_body(void)
{
int selftest_ok;
DBG_INFO("");
DBG_INFO("#### IOBOARD test suite: semi-automatic bench sequence ####");
DBG_INFO("#### You will be asked to SHORT DI terminals one by one, then ####");
DBG_INFO("#### to listen for relay clicks. Follow the cues; 3 s per step. ####");
DBG_INFO("#### Strings are English-only; order matches the log lines. ####");
DBG_INFO("");
IOBOARD_TEST_STATS_RESET();
/* 任何异常退出(Phase 之间 return、断言崩溃之外)都保证全释放 */
ioboard_release_all("suite entry");
#ifdef ENABLE_IOBOARD_SELFTEST_TESTS
selftest_ok = ioboard_phase_selftest();
if (selftest_ok == 0) {
DBG_ERROR("suite ABORT after Phase 0: ioboard_init() failed, DI/DO tests skipped");
ioboard_release_all("abort after Phase 0");
return;
}
#else
selftest_ok = 1;
#endif
#ifdef ENABLE_IOBOARD_DI_ORDER_TESTS
ioboard_phase_di_order();
#else
(void)selftest_ok;
#endif
#ifdef ENABLE_IOBOARD_DI_STABLE_TESTS
ioboard_phase_di_stable();
#endif
/* Phase 3 前再确认一次释放:DI 阶段结束后开出必须仍是全释放 */
ioboard_release_all("before Phase 3");
#ifdef ENABLE_IOBOARD_DO_TESTS
ioboard_phase_do_actuation();
#endif
/* Phase 4:重置(无论前序成败) */
DBG_INFO("=== IOBOARD Phase 4: reset (all DO released) ===");
ioboard_release_all("Phase 4 reset");
}
/*
* 函数功能:套件线程入口 —— 跑序列主体、结束后无条件全释放、打印汇总、自行退出。
* 入口参数:argument - 未使用(xTaskCreateStatic 传 NULL)
* 返回值:无(线程退出即删除自己)
* 限定条件:只允许由 ioboard_test_run() 经 xTaskCreateStatic 创建,且只创建一次。
* 函数说明:release_all 在这里再走一次是**刻意冗余**——主体内部各 Phase 已经释放过,
* 但线程退出是最后一刻,"末尾再确认一次"让安全口径不依赖主体的控制流。
* 随后单独断言并 REPORT,保证即使主体提前 return 也一定打出汇总行。
*/
static void ioboard_thread_entry(void *argument)
{
uint8_t level = 0xFFu;
(void)argument;
ioboard_test_body();
/* 序列结束(无论成败)必须全释放,并单独记一条断言:这是安全口径的最后一道 */
ioboard_release_all("suite end");
(void)ioboard_do_read_level(&level);
IOBOARD_TEST_CHECK((uint8_t)(level & IOBOARD_TEST_DO_MASK_ALL) ==
(uint8_t)(IOBOARD_DO_LEVEL_RELEASE & IOBOARD_TEST_DO_MASK_ALL),
"final: all 4 DO at RELEASE level after suite (level=0x%02X)",
(unsigned int)level);
IOBOARD_TEST_REPORT(IOBOARD_TEST_SUMMARY_NAME);
DBG_INFO("IOBOARD test suite done (relays released, thread exits)");
/* 必须显式自杀:FreeRTOS 的任务函数**返回**是未定义行为(Cortex-M4F 端口里
* LR 被初始化成 prvTaskExitError,返回即触发 configASSERT)。本仓 configASSERT
* 接到 vApplicationAssertFailed → 打 ASSERT FAILED 后 NVIC_SystemReset(),
* 台架表现为"套件跑完就静默复位"。原先此处只 return、注释却写"线程退出即删除
* 自己",是错的:任务不会因为函数返回而被删除。 */
vTaskDelete(NULL);
/* 防御:vTaskDelete(NULL) 之后不返回。若将来有人把它注释掉,这条守住语义。 */
for (;;) {
osDelay(1000);
}
}
/* ===================== 套件入口 ===================== */
/*
* 为什么自起线程而不是在 testTask 上下文直接跑:
* testTask 的优先级是 osPriorityBelowNormal(Src/freertos.c 的 testTask_attributes),
* 低于 defaultTask(Normal)。本套件绝大部分时间是 osDelay 等人工窗口,
* 若在 testTask 里等,defaultTask 每轮 1 ms 的控制台排空循环会让它久久抢不到 CPU,
* 人工窗口随之失真(提示打印后还没开始采样就又被推迟)。自起的线程用 Normal,
* 与 defaultTask 同级公平轮转。
*
* 线程 TCB 走 xTaskCreateStatic:本仓禁用 C 库堆分配,且静态 TCB 让栈尺寸固定可核算
* (Inc/FreeRTOSConfig.h 的 configSUPPORT_STATIC_ALLOCATION = 1)。
* 栈 4 KB(1024 words)。**实测值**(scripts/stack_report.py,由本次 IOBOARD 构建的
* 静态调用图得出):本线程最坏链 1760 B、own frame 248 B、余量 2336 B(57%),
* 判据要求 margin >= max(1024, 30%*4096=1228) 故 PASS。最坏链落在**失败分支**
* (emergency_release 打告警那条),正是最该留余量的地方。
*
* 函数功能:套件入口。打启动横幅与开出现状、先全释放、自起套件线程后立即返回。
* 入口参数:无
* 返回值:无
* 限定条件:由 start_test_task 在 testTask 上下文调用一次;**本函数不等线程结束**。
* 函数说明:返回而不是 join 的原因见上面两段——testTask 优先级低且只做 osDelay,
* 套件的时序必须由 Normal 优先级的独立线程掌握。
* 若线程创建失败:记一条 FAIL + REPORT 后返回(此时开出已在上面强制释放)。
*/
void ioboard_test_run(void)
{
TaskHandle_t h_thread = NULL;
uint8_t do_shadow = 0xFFu;
uint8_t do_level = 0xFFu;
DBG_INFO("IOBOARD test suite started (semi-automatic; self-spawned thread prio=Normal)");
DBG_INFO("thread stack: %u B static (TCB static, no heap)", (unsigned int)sizeof(s_ioboard_thread_stack));
/* 启动期先全释放并核对一次:套件条目之前若有人(上电残留、上一轮台架)动过开出,
* 这一行会把事实连同电气电平一起打出来,而不是等到 Phase 0。 */
(void)ioboard_do_get(&do_shadow);
(void)ioboard_do_read_level(&do_level);
(void)ioboard_do_write(0u); /* 启动期无条件全释放 */
DBG_INFO(" DO before start: shadow=0x%02X level=0x%02X -> forced to release",
(unsigned int)do_shadow, (unsigned int)do_level);
h_thread = xTaskCreateStatic(ioboard_thread_entry, "iobTest",
(uint32_t)(sizeof(s_ioboard_thread_stack) / sizeof(StackType_t)),
NULL, (UBaseType_t)IOBOARD_TEST_THREAD_PRIO,
s_ioboard_thread_stack, &s_ioboard_thread_tcb);
if (h_thread == NULL) {
DBG_ERROR("xTaskCreateStatic failed -> suite NOT run (relays already released)");
IOBOARD_TEST_CHECK(0, "xTaskCreateStatic() for suite thread returned NULL");
IOBOARD_TEST_REPORT(IOBOARD_TEST_SUMMARY_NAME);
return;
}
DBG_INFO("suite thread created (static TCB + static stack); testTask returns to idle loop");
}
#endif /* TEST_SUITE_IOBOARD */