@@ -0,0 +1,756 @@
/******************************************************************************
* 模块名称:开入开出板(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)
/* 全局测试统计(宏自动管理) */
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 ) ;
}
}
/*
* 全释放的**唯一出口**:任何失败路径、任何 Phase 收尾、线程退出前都必须过这里。
* 打印与断言分开——这样"释放"这个动作本身不会被套件的统计口径影响。
*
* 「与极性一致」的判法:ioboard_do_read_level() 给的是**电气电平**( 1 = 引脚为高),
* 而 IOBOARD_DO_LEVEL_ACTIVE 定义了「吸合 = 高还是低」。两者按位异或 RELEASE 电平,
* 就把电气电平折回「是否吸合」,极性宏一旦被改,本判据自动跟着改。
*
* 函数功能: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 & 0x0Fu ) ,
" 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) === " ) ;
/* 基线:全部断开时应为 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 === " ) ;
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) === " ) ;
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 one = ( uint8_t ) ( IOBOARD_TEST_DO_MASK_ALL & ( uint8_t ) ( ~ k_do_bit [ i ] ) ) ;
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 ( one ) ;
if ( rc ! = BSP_OK ) {
IOBOARD_TEST_CHECK ( 0 , " %s: ioboard_do_write(0x%02X) ret=%d " ,
k_do_name [ i ] , ( unsigned int ) one , ( 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 = ( ( level ^ ( uint8_t ) ( IOBOARD_DO_LEVEL_RELEASE & 0x0Fu ) ) & 0x0Fu ) ;
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 ] ) ;
IOBOARD_TEST_CHECK ( ( uint8_t ) ( shadow & 0x0Fu ) = = one ,
" %s: shadow=0x%02X (expect 0x%02X: only this bit set) " ,
k_do_name [ i ] , ( unsigned int ) shadow , ( unsigned int ) one ) ;
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 ( ( active_bits | k_do_bit [ i ] ) = = k_do_bit [ i ] ,
" %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 & 0x0Fu ) = =
( uint8_t ) ( IOBOARD_DO_LEVEL_RELEASE & 0x0Fu ) ,
" %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 ( " " ) ;
( void ) memset ( & g_ioboard_test_stats , 0 , sizeof ( g_ioboard_test_stats ) ) ;
/* 任何异常退出(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 & 0x0Fu ) = =
( uint8_t ) ( IOBOARD_DO_LEVEL_RELEASE & 0x0Fu ) ,
" 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) " ) ;
}
/* ===================== 套件入口 ===================== */
/*
* 为什么自起线程而不是在 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 */