diff --git a/App/task/ui_task.c b/App/task/ui_task.c index a9d46375..bd2fca41 100644 --- a/App/task/ui_task.c +++ b/App/task/ui_task.c @@ -18,6 +18,14 @@ * "UI 自己被调度到了"。注：若往返**永久**阻塞，本改仍不能救 * （心跳只发一次）→ 真要彻底去掉依赖须走事件驱动 accept * （NET_EVENT_CONNECTED 回调），待复现快照确认阻塞机理后再定。 + * v1.4 2026-10-25 DTU 项目组 F3（大窗判读）：向 ui_net_sink 注册心跳回调 + * （ui_task_sink_beat）——推流段内**每个可等待 net 往返** + * （accept/recv/send/close/重建）返回点即喂本任务心跳， + * 风暴期「单轮多个慢往返之和」不再串成 800ms 缺席链 + * （2026-10-25 实测 bit4 8 连击、uisn=154ms 仍在段内； + * 按位连击判据 = docs/子系统设计/看门狗设计说明.md §5.3）。 + * 单个往返自身仍无上界——该上界与彻底解耦（事件驱动 + * accept）归登记簿 E-27/E-28（批 3），本票只做心跳续命。 */ #include "ui_task.h" @@ -147,6 +155,18 @@ static int ui_task_soe_get(uint32_t idx, ui_w_soe_rec_t *p_out) { static const ui_soe_reader_t s_soe_reader = { ui_task_soe_count, ui_task_soe_get }; +/* + * 函数功能：推流往返边界的心跳续命钩（F3，注册给 ui_net_sink） + * 入口参数：无 + * 返回值：无 + * 限定条件：uiTask 轮询上下文（sink 在往返返回处调用），只做置位、不阻塞 + * 函数说明：为何经回调注入而非 sink 直调 task_wd_beat()——分层边界（BSP 不得 + * include App 头，layer-deps 门禁）；心跳属主仍是本任务。 + */ +static void ui_task_sink_beat(void) { + task_wd_beat(TASK_WD_UI); +} + #define DBG_TAG "[UI_TASK]" #include "dbg_log.h" @@ -228,6 +248,9 @@ void ui_task_func(void *argument) { } else { DBG_INFO("UI net sink: started (port %u)", (unsigned)UI_NET_SINK_PORT); } + /* F3：往返边界心跳钩（契约见 ui_net_sink.h；须在首轮 poll 之前注册）。 + * start 失败也要注：失败路径的 close/重建重试同样经往返 */ + ui_net_sink_set_beat_cb(ui_task_sink_beat); #if defined(TEST_LATENCY_PROBE) /* M3 探针 ui_loop：主循环实测周期（= LVGL 渲染 + 推流轮询 + osDelay(10)）。 @@ -269,7 +292,10 @@ void ui_task_func(void *argument) { * 致实测 uiw≈uis≈50ms（心跳被 netTask 往返主导）。提到往返之前后， * 即使往返偶发变慢，心跳也不被其拖垮。 * ⚠ 若往返**永久**阻塞（xTaskNotifyWait portMAX_DELAY 不返回），本改只能发 - * 一次心跳，救不了 → 彻底解耦须走事件驱动 accept，见文件头修改记录 v1.3。 */ + * 一次心跳，救不了 → 彻底解耦须走事件驱动 accept，见文件头修改记录 v1.3。 + * v1.4 补充：sink 内每个往返**返回点**已各自补喂（set_beat_cb 注入）， + * 「单轮多个慢往返之和」不再构成缺席链；剩单往返 >800ms 才报——那是 + * netTask 自身停摆，按位判据抓对了人（上界归 E-27/E-28）。 */ task_wd_beat(TASK_WD_UI); /* 推流轮询段单独 enter/exit：它内部经 net_accept → net_wait_result 走到 * xTaskNotifyWait(portMAX_DELAY) 的**无限期阻塞**。若 uiTask 永久卡在这里， diff --git a/Drivers/BSP/UI/ui_net_sink.c b/Drivers/BSP/UI/ui_net_sink.c index 8d75cbf3..e9cdf164 100644 --- a/Drivers/BSP/UI/ui_net_sink.c +++ b/Drivers/BSP/UI/ui_net_sink.c @@ -30,6 +30,15 @@ * net_lost_connect_probe 对该端口等于从未运行；同时 EOF / * 真错误两条路径不再自行 bind_listen（重建交回 net 层， * 消灭第三/第四个重建所有者），仅 fd 真消失时置 -1 + * 2026-10-25 DTU 项目组 F3（2026-10-25 大窗判读）：看门狗心跳回调钩子 + * ui_net_sink_set_beat_cb()，在每个可等待 net 往返 + * （accept / recv_nb / send / close / 重建三件套）返回点 + * 调用——风暴期单轮多往返串成 UI 心跳缺口（实测 bit4 + * 8 连击、uisn=154ms 仍在段内样本），往返本身不动 + * （语义不变，上界收口 = 登记簿 E-27/E-28 批 3），心跳 + * 在往返边界续命。钩子未注册 = 零行为变化（模拟器/黄金 + * 回归不注册）。判读与设计口径见 + * docs/UI设计/UI_设计架构.md §5.8 */ #include "ui_net_sink.h" @@ -83,6 +92,33 @@ static uint8_t s_sink_blocked; /* 推送阻断标志（1 = 停发帧，等 #define RM_LIVENESS_DIV 32U static uint8_t s_liveness_ctr; /* 兜底计数器（单写者 = 推流宿主任务） */ +/* 看门狗心跳回调钩子（F3，契约见 ui_net_sink.h）：NULL = 不调用（模拟器形态）。 + * 用回调注入而非直调 task_wd_beat() = 分层边界（Drivers/BSP 不得 include + * App 侧头，layer-deps 门禁），宿主（uiTask）自己决定喂哪位。 */ +static void (*s_beat_cb)(void); + +/* + * 函数功能：心跳钩子安全调用点（本文件所有可等待 net 往返的返回处） + * 入口参数：无 + * 返回值：无 + * 限定条件：轮询上下文（宿主任务） + */ +static void sink_beat(void) { + if (s_beat_cb != NULL) { + s_beat_cb(); + } +} + +/* + * 函数功能：注册/注销看门狗心跳回调钩子 + * 入口参数：cb - 回调钩子；NULL = 注销（行为与本特性引入前逐字一致） + * 返回值：无 + * 限定条件：宿主任务在首次 ui_net_sink_poll() 之前调用一次（契约见头文件） + */ +void ui_net_sink_set_beat_cb(void (*cb)(void)) { + s_beat_cb = cb; +} + /* * 函数功能：计算 RemoDispBus 帧 payload 的 CRC 校验值 * 入口参数：d - 待校验数据指针（len 为 0 时不访问） @@ -162,6 +198,7 @@ static int remo_send(uint8_t cmd, const uint8_t *data, uint16_t len) { p[4 + len] = remo_crc(data, len); total = (int)(4 + len + 1); ret = net_send(g_client, p, total, 0); + sink_beat(); /* F3：发送往返返回即喂心跳（KEEPLIVE/INIT/KEY/LCDMEM 同路） */ if (ret == total) { s_send_fail_run = 0U; return 0; @@ -444,6 +481,7 @@ static int bind_listen(void) { } g_listen = ls; + sink_beat(); /* F3：重建三件套（socket/bind/listen 三次往返）结束 */ return 0; } @@ -502,6 +540,7 @@ void ui_net_sink_poll(void) { net_close(g_listen); g_listen = -1; } + sink_beat(); /* F3：重建前的一对 close 往返结束 */ g_client = -1; rm_parser_reset(); s_send_fail_run = 0U; /* 网络重建：失败累计清零、解除推送阻断（E-04） */ @@ -534,6 +573,7 @@ void ui_net_sink_poll(void) { return; } int c = net_accept(g_listen, NULL, NULL); + sink_beat(); /* F3：accept 往返返回即喂（风暴期该往返实测 150ms 级） */ if (c >= 0) { g_client = c; rm_parser_reset(); @@ -558,6 +598,7 @@ void ui_net_sink_poll(void) { s_liveness_ctr = 0U; } n = net_recv_nb(g_client, g_rx, (int)sizeof(g_rx)); + sink_beat(); /* F3：recv 往返返回即喂（nb 不等数据，但队列排队照样等回执） */ if (n > 0) { for (int i = 0; i < n; i++) { rm_parser_feed((uint8_t)g_rx[i]); @@ -592,6 +633,7 @@ void ui_net_sink_poll(void) { if (g_client != g_listen) { net_close(g_client); /* 多连接后端（PC 模拟器）：数据通道独立，需显式关闭 */ } + sink_beat(); /* F3：EOF/错误路径的 close 往返结束 */ g_client = -1; rm_parser_reset(); /* N-32（P1 不变量 II）：同 EOF 分支——不再自行 bind_listen， diff --git a/Drivers/BSP/UI/ui_net_sink.h b/Drivers/BSP/UI/ui_net_sink.h index 51a32f76..7a2f2d05 100644 --- a/Drivers/BSP/UI/ui_net_sink.h +++ b/Drivers/BSP/UI/ui_net_sink.h @@ -1,4 +1,4 @@ -/* +/* * 模块名称：UI Network Sink (RemoDispBus 服务端) * 模块功能：实现 RemoDispBus 协议服务端，接收远端连接与导航按键，回送 1bpp 帧缓冲 * 适用平台：STM32F407ZGTx + CH395F 以太网 @@ -7,6 +7,8 @@ * 修改记录： * 2026-08-29 王建锋 创建初始版本 * 2026-08-29 王建锋 修正监听端口为 7003，与 DTU-RemoteLCD 客户端默认端口对齐 + * 2026-10-25 DTU 项目组 F3：新增 ui_net_sink_set_beat_cb()（看门狗心跳 + * 回调注入，往返返回点喂位；未注册 = 零行为变化） */ #ifndef UI_NET_SINK_H #define UI_NET_SINK_H @@ -59,6 +61,26 @@ int ui_net_sink_start(uint16_t port); */ void ui_net_sink_poll(void); +/* + * 函数功能：注册看门狗心跳回调钩子（F3，2026-10-25 大窗判读） + * 入口参数：cb - 回调钩子（宿主轮询上下文调用）；NULL = 注销 + * 返回值：无 + * 限定条件：宿主任务在首次 ui_net_sink_poll() 之前调用一次；注册者 = 推流 + * 属主（MCU = uiTask，须保证钩子内只做置位类动作、不阻塞） + * 函数说明：本模块在每次**可等待 net 往返**（accept / recv_nb / send / close / + * 重建三件套）返回处调用钩子。动因：netTask 重建风暴期，单轮内多个 + * 往返串行排队，把宿主（uiTask，IWDG 必需位）的心跳间隔拖过 800ms + * （2026-10-25 台架实测 bit4 单任务 8 连击窗、uisn=154ms 仍在段内）； + * 往返时长本身不改（上界收口 = 登记簿 E-27/E-28，批 3），但心跳在每个 + * 往返边界续命——单任务停摆判据（按位连击，docs/子系统设计/看门狗设计说明.md + * §5.3）只应 + * 抓真挂死，不该抓「多个都回来了但各自偏慢的往返之和」。 + * 未注册（模拟器/黄金回归形态）= 行为与本特性引入前逐字一致。 + * 为何回调注入而非直调 task_wd_beat()：Drivers/BSP 不得 include + * App 侧头（layer-deps 门禁，方向性铁律） + */ +void ui_net_sink_set_beat_cb(void (*cb)(void)); + #ifdef __cplusplus } #endif diff --git a/docs/UI设计/UI_设计架构.md b/docs/UI设计/UI_设计架构.md index 126e9ae7..0a00e2a6 100644 --- a/docs/UI设计/UI_设计架构.md +++ b/docs/UI设计/UI_设计架构.md @@ -267,6 +267,28 @@ ENTER/→ 进子框： - 主循环若再 `SDL_PollEvent`，会**先消费**事件队列 → 驱动定时器轮询时队列已空 → 键盘全部失效 - 关窗退出由驱动 `LV_SDL_DIRECT_EXIT=1` 自动 `exit(0)`，主循环无需处理 SDL_QUIT +### 5.8 推流往返的心跳边界（F3，2026-10-25 大窗判读） + +- **现象**：netTask 监听重建风暴期，`ui_net_sink_poll()` 内「单个可等待往返都回来了、 + 但一轮里串了好几个」，把 uiTask 两次心跳之间的间隔顶过 800ms——看门狗按位连击 + 判据（`docs/子系统设计/看门狗设计说明.md` §5.3）抓到 bit4 单任务 8 连击窗 + （2026-10-25 台架实测，uisn=154ms 仍在段内样本，`:7003` churn 与探针重建并发叠加）。 +- **处置（本票 = 心跳面）**：`ui_net_sink_set_beat_cb()` 回调注入——sink 在每次 + accept / recv_nb / send / close / 重建三件套的**返回处**调用钩子，uiTask 注册 + `task_wd_beat(TASK_WD_UI)`。效果 = 心跳间隔从「整轮往返之和」收敛到「单个往返」； + 只要每次往返都会回来，UI 就不该被记停摆。往返本身**不改**（有界化/请求序号 = + `docs/任务规划/README.md` 的 E-27/E-28 跨上下文收口，批 3；§11.6 否决过的 + 「给 net_* 裸加超时」不重演）。 +- **分层**：Drivers/BSP 不得 include App 头（layer-deps），故心跳经回调注入而非直调； + 钩子内只做置位类动作、不阻塞（契约写在 `Drivers/BSP/UI/ui_net_sink.h`）。 +- **零行为变化面**：钩子未注册（模拟器 / 黄金回归 / start 之前）= 与 F3 之前逐字一致； + 协议、帧格式、门控、兜底节拍全部不动。回归钉 = `test/host/ui_sink/`（17 断言： + 未注册全协议路径 / 门控零 RPC 零心跳 / 每往返恰好一次心跳 / 重建与 EOF 的 close + 护栏不变）。 +- **残留暴露**（刻意不归本票）：单个往返自身仍无上界（osMessageQueuePut(osWaitForever) + + xTaskNotifyWait(portMAX_DELAY)），netTask 若被单消息拖 >800ms，UI 位连击照成立—— + 那是「判据抓对了人」，处置在 net 侧（E-27/E-28），不在心跳侧。 + ## 六、变更记录（简表） | 日期 | 变更 | @@ -285,4 +307,5 @@ ENTER/→ 进子框： | 2026-09-09 | 用户密钥密码页落地（首个表单/操作页，§4.7 / `内容页架构.md` §4.1）：框架描述符新增 title_y/hide_deco/hide_footer/key_intercept + 新 API `ui_content_page_invalidate`；新模块 `ui_page_password`（3 数字框反显光标 + arm API）；菜单受保护叶子路由（arm→开密码页，确认一致后回调**先关页再续做进入动作**）；字体 97→102 汉字（198 字形）；双端注册；回归扩至 7 页 + 往返水位，五门禁全绿 | | 2026-09-10 | 网口设置内容页（§4.7 / `内容页架构.md`）：新增 `Drivers/BSP/NETCFG`（Flash 持久化 + CRC-16，工厂默认 192.168.1.100/24）+ 页面插件 `ui_page_net_cfg`（5 行动态值 + 可编辑：↑↓调字节/←→移光标/ENTER 确认，保存行 ENTER → `net_cfg_save` 下次上电生效）；框架新增钩子 `init_cb` + API `ui_content_page_selected_row`；`net_init` 增 `mac` 参数、netTask 等 `SYS_EVT_STORAGE_READY` → `net_cfg_load` → `net_init(ip,mask,gw,mac)` → 回写实际 MAC 影子；字体 102→111 字符（208 字形，修复低码位符号丢失）；双端注册；回归扩至 11 页，五门禁全绿 | | 2026-09-14 | 运行记录/自检记录内容页 + 待机显示模块：新增 `App/log/sys_log`（定长 64B 文本记录引擎，MCU 落 NAND `/log/run.log`、`/log/selftest.log`，FTP 可直下）+ 页面插件 `ui_page_runlog` / `ui_page_selftest`（动态列表：count_cb + refresh，每条 2 行时间戳/描述）+ `ui_standby`（空闲超时自动切待机屏，仅确认键回菜单）；密码页错误提示"密码输入错误"+清空重输；字体 111→122 字（217 字形）；详见 `docs/子系统设计/运行与自检记录设计说明.md` | +| 2026-10-25 | **F3 推流心跳边界（§5.8）**：`ui_net_sink_set_beat_cb()` 回调注入，accept/recv_nb/send/close/重建三件套返回处喂 UI 心跳（2026-10-25 大窗 bit4 8 连击实证：单轮多慢往返之和串成 800ms 缺席）；往返语义不改（上界归 E-27/E-28）；未注册 = 零行为变化（模拟器/黄金回归形态）；新增 `test/host/ui_sink/` 主机套件 17 断言 | | 2026-10-25 | 字库扩充（页面扩充规划预置字 +60，含罗马数字 Ⅰ/Ⅱ/Ⅲ）：默认字体升至 179 字符/274 字形，像素基线不变，ROM +1,528 B、RAM 0；修复生成器 `make_font.py` 的 cmap 插入顺序缺陷——LVGL `get_glyph_dsc_id()` 线性扫描首个包含即返回，补回字形（▶）单码位条目被下探后的宽稀疏 range 吞掉即全渲染方框，现按首命中语义插位/守卫/校验（详见 `docs/UI设计/UI_中文字体生成与配置.md` 文末事故记录） | diff --git a/test/host/ui_sink/run_unit_test.py b/test/host/ui_sink/run_unit_test.py new file mode 100644 index 00000000..a675e8e6 --- /dev/null +++ b/test/host/ui_sink/run_unit_test.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +"""ui_net_sink 心跳边界主机侧单元测试运行器（L0.5，纯标准库）。 + +做什么： + 用本机 MSVC 编译 test/host/ui_sink/ui_sink_test.c（以 #include 纳入生产源 + Drivers/BSP/UI/ui_net_sink.c），用桩 net_* 假件驱动推流协议全路径，钉死 + F3（2026-10-25 大窗判读）两条判据：未注册钩子 = 行为逐字不变（模拟器形态）； + 注册后每个可等待 net 往返的返回处恰好喂一次心跳（风暴期单轮多往返不再串成 + UI 心跳缺口，看门狗按位连击判据只抓真挂死）。 + +为什么要主机侧单测： + 台架能复现风暴但造不出确定性的 RPC 计数；而心跳漏喂是回归性风险（改一行 + 调用位置就静默失效），必须在门禁层用计数断言钉死。 + +用法（仓库根目录）： + & '.venv\\Scripts\\python.exe' test/host/ui_sink/run_unit_test.py + +退出码：0=PASS / 1=测试失败 / 2=环境错误。 + +设计依据：docs/UI设计/UI_设计架构.md（推流心跳边界）； + docs/子系统设计/看门狗设计说明.md §5.3（按位连击判据） +创建日期：2026-10-25 +""" +import os +import sys + +HERE = os.path.dirname(os.path.abspath(__file__)) +ROOT = os.path.dirname(os.path.dirname(os.path.dirname(HERE))) +sys.path.insert(0, os.path.join(ROOT, "test", "host", "common")) + +from unit_test_harness import TestBuild, run_host_unit_test # noqa: E402 + +# stub 目录必须**先于** Drivers/BSP/UI：net_socket.h / ui_port.h / dbg_log.h / +# test_config.h 由桩提供，ui_net_sink.h 与 ui_net_sink_backend.h 用真实头 +# （几何令牌与协议常量一改即编译期报错）。 +BUILD = TestBuild( + name="UI Sink Beat Tests", + src=os.path.join(HERE, "ui_sink_test.c"), + include_dirs=[ + os.path.join(HERE, "stub"), + os.path.join(ROOT, "Drivers", "BSP", "UI"), + HERE, + ], + summary_marker="=== UI Sink Tests:", +) + +if __name__ == "__main__": + sys.exit(run_host_unit_test(BUILD)) diff --git a/test/host/ui_sink/stub/dbg_log.h b/test/host/ui_sink/stub/dbg_log.h new file mode 100644 index 00000000..36d641db --- /dev/null +++ b/test/host/ui_sink/stub/dbg_log.h @@ -0,0 +1,12 @@ +#ifndef DBG_LOG_H +#define DBG_LOG_H + +/* 主机侧桩：DBG_ERROR 计数（观测告警行为），其余宏消音 */ + +extern int g_uisink_err_count; + +#define DBG_INFO(...) do { } while (0) +#define DBG_WARN(...) do { } while (0) +#define DBG_ERROR(...) do { g_uisink_err_count++; } while (0) + +#endif /* DBG_LOG_H */ \ No newline at end of file diff --git a/test/host/ui_sink/stub/net_latency_test.h b/test/host/ui_sink/stub/net_latency_test.h new file mode 100644 index 00000000..36c16a6f --- /dev/null +++ b/test/host/ui_sink/stub/net_latency_test.h @@ -0,0 +1,6 @@ +#ifndef NET_LATENCY_TEST_H +#define NET_LATENCY_TEST_H + +/* 主机侧桩：M3 探针头（TEST_LATENCY_PROBE 未定义时 ui_net_sink.c 不用其符号） */ + +#endif /* NET_LATENCY_TEST_H */ \ No newline at end of file diff --git a/test/host/ui_sink/stub/net_socket.h b/test/host/ui_sink/stub/net_socket.h new file mode 100644 index 00000000..6404ea13 --- /dev/null +++ b/test/host/ui_sink/stub/net_socket.h @@ -0,0 +1,45 @@ +#ifndef NET_SOCKET_H +#define NET_SOCKET_H + +/* + * 主机侧桩（test/host/ui_sink）：镜像真实 Drivers/BSP/NET/net_socket.h 中 + * ui_net_sink.c 用到的 API 面（签名逐字一致），实现由测试文件提供假件。 + */ +#include + +#define NET_AF_INET 2 +#define NET_SOCK_STREAM 1 +#define NET_INADDR_ANY 0u +#define NET_ERR_WOULDBLOCK 11 + +struct net_sockaddr { + unsigned short sa_family; + char sa_data[14]; +}; + +struct net_in_addr { + unsigned long s_addr; +}; + +struct net_sockaddr_in { + short sin_family; + unsigned short sin_port; + struct net_in_addr sin_addr; + char sin_zero[8]; +}; + +uint32_t net_get_generation(void); +uint16_t net_htons(uint16_t hostshort); +int net_socket(int domain, int type); +int net_bind(int sockfd, const struct net_sockaddr *addr, int addrlen); +int net_listen(int sockfd); +int net_accept(int sockfd, struct net_sockaddr *addr, int *addrlen); +int net_listener_armed(int sockfd); +int net_can_read(int sockfd); +int net_send(int sockfd, const void *buf, int len, int flags); +int net_recv_nb(int sockfd, void *buf, int len); +int net_close(int sockfd); +int net_get_errno(void); +void *net_get_sock(int sockfd); + +#endif /* NET_SOCKET_H */ \ No newline at end of file diff --git a/test/host/ui_sink/stub/net_types.h b/test/host/ui_sink/stub/net_types.h new file mode 100644 index 00000000..eab1c62d --- /dev/null +++ b/test/host/ui_sink/stub/net_types.h @@ -0,0 +1,6 @@ +#ifndef NET_TYPES_H +#define NET_TYPES_H + +/* 主机侧桩：ui_net_sink.c 仅经 net_socket.h 取类型；本头在 PC 上为空壳 */ + +#endif /* NET_TYPES_H */ \ No newline at end of file diff --git a/test/host/ui_sink/stub/test_config.h b/test/host/ui_sink/stub/test_config.h new file mode 100644 index 00000000..13684dc2 --- /dev/null +++ b/test/host/ui_sink/stub/test_config.h @@ -0,0 +1,6 @@ +#ifndef TEST_CONFIG_H +#define TEST_CONFIG_H + +/* 主机侧桩：产品形态（无任何板级套件宏 / 探针宏被打开） */ + +#endif /* TEST_CONFIG_H */ \ No newline at end of file diff --git a/test/host/ui_sink/stub/ui_port.h b/test/host/ui_sink/stub/ui_port.h new file mode 100644 index 00000000..e5f7920f --- /dev/null +++ b/test/host/ui_sink/stub/ui_port.h @@ -0,0 +1,16 @@ +#ifndef UI_PORT_H +#define UI_PORT_H + +/* 主机侧桩：屏幕几何令牌（与真 ui_port.h 同值；160x160 1bpp = 3200） + * + 按键码常量（ui_net_sink.c 只透传数值，真值无涉） */ + +#define UI_SCREEN_W 160 +#define UI_SCREEN_H 160 +#define UI_FB_SIZE (UI_SCREEN_W * UI_SCREEN_H / 8) + +#define UI_KEY_ENTER 13 +#define UI_KEY_UP 1 +#define UI_KEY_DOWN 2 +#define UI_KEY_ESC 27 + +#endif /* UI_PORT_H */ \ No newline at end of file diff --git a/test/host/ui_sink/ui_sink_test.c b/test/host/ui_sink/ui_sink_test.c new file mode 100644 index 00000000..6331a485 --- /dev/null +++ b/test/host/ui_sink/ui_sink_test.c @@ -0,0 +1,250 @@ +/* + * 模块名称：ui_net_sink 心跳边界主机侧单元测试（F3，2026-10-25 大窗判读） + * 模块功能：以桩 net_* 假件驱动生产 ui_net_sink.c，钉死两条判据： + * ① 未注册心跳钩 = 行为逐字不变（模拟器/黄金回归形态）； + * ② 注册后每个可等待 net 往返的返回处恰好喂一次心跳 + * （风暴期单轮多往返不再串成 UI 心跳缺口）。 + * 入口：int main(void)，返回 0=PASS / 1=FAIL（由 run 脚本判读）。 + * 创建日期：2026-10-25 + */ +#include +#include +#include + +#include "net_socket.h" +#include "ui_net_sink.h" +#include "ui_net_sink_backend.h" + +int g_uisink_err_count = 0; + +/* ===================== 假件：net 层 ===================== */ +static int f_rpc; /* 本轮已发生的 net RPC 次数 */ +static int f_closes; +static int f_accepts; +static int f_armed; +static int f_can_read; +static int f_accept_next; /* >=0 返回该 fd；<0 返回 -1 并置 WOULDBLOCK */ +static int f_recv_mode; /* 0=取队 1=WOULDBLOCK(-1) 2=EOF(0) */ +static uint32_t f_gen; +static int f_errno_v; +static int f_next_fd; +static int f_sock_alive; + +static uint8_t s_last_tx[4200]; +static int s_last_tx_len; +static uint8_t s_last_tx_cmd; + +static uint8_t rxq[1024]; +static int rxq_len, rxq_pos; + +uint32_t net_get_generation(void) { return f_gen; } +uint16_t net_htons(uint16_t v) { return (uint16_t)((v << 8) | (v >> 8)); } +int net_socket(int d, int t) { (void)d; (void)t; f_rpc++; return f_next_fd; } +int net_bind(int fd, const struct net_sockaddr *a, int l) { (void)fd; (void)a; (void)l; f_rpc++; return 0; } +int net_listen(int fd) { (void)fd; f_rpc++; return 0; } +int net_accept(int fd, struct net_sockaddr *a, int *l) { + (void)fd; (void)a; (void)l; + f_rpc++; f_accepts++; + if (f_accept_next >= 0) { + int c = f_accept_next; + f_accept_next = -1; + return c; + } + f_errno_v = NET_ERR_WOULDBLOCK; + return -1; +} +int net_listener_armed(int fd) { (void)fd; return f_armed; } +int net_can_read(int fd) { (void)fd; return f_can_read; } +int net_send(int fd, const void *b, int n, int fl) { + (void)fd; (void)fl; + f_rpc++; + memcpy(s_last_tx, b, (size_t)n); + s_last_tx_len = n; + s_last_tx_cmd = ((const uint8_t *)b)[1]; + return n; +} +int net_recv_nb(int fd, void *b, int n) { + (void)fd; + f_rpc++; + if (f_recv_mode == 1) { f_errno_v = NET_ERR_WOULDBLOCK; return -1; } + if (f_recv_mode == 2) { return 0; } + if (rxq_pos >= rxq_len) { f_errno_v = NET_ERR_WOULDBLOCK; return -1; } + int take = rxq_len - rxq_pos; + if (take > n) { take = n; } + memcpy(b, rxq + rxq_pos, (size_t)take); + rxq_pos += take; + return take; +} +int net_close(int fd) { (void)fd; f_rpc++; f_closes++; return 0; } +int net_get_errno(void) { return f_errno_v; } +void *net_get_sock(int fd) { (void)fd; return f_sock_alive ? (void *)&f_gen : (void *)0; } + +/* ===================== 假件：平台后端 ===================== */ +static int s_lcdmem_calls; +static int s_keys[16]; +static int s_key_n; + +int ui_net_sink_get_lcdmem(uint8_t *out, uint32_t size) { + s_lcdmem_calls++; + memset(out, 0xA5, size); + return 0; +} +void ui_net_sink_inject_key(uint8_t k) { + if (s_key_n < 16) { s_keys[s_key_n++] = k; } +} + +/* ===================== 被测代码 ===================== */ +#include "ui_net_sink.c" + +/* ===================== 测试框架 ===================== */ +static int s_total, s_passed, s_failed; +#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) + +/* 心跳钩计数（钩子注册面） */ +static int s_beats; +static void beat_cb(void) { s_beats++; } + +static void fresh(int hook) { + memset(rxq, 0, sizeof(rxq)); + rxq_len = rxq_pos = 0; + f_rpc = 0; f_closes = 0; f_accepts = 0; + f_armed = 0; f_can_read = 0; f_accept_next = -1; + f_recv_mode = 1; f_gen = 1; f_errno_v = 0; + f_next_fd = 3; f_sock_alive = 1; + s_key_n = 0; s_lcdmem_calls = 0; + g_uisink_err_count = 0; s_last_tx_len = 0; + ui_net_sink_set_beat_cb(hook != 0 ? beat_cb : (void (*)(void))0); + ui_net_sink_start(UI_NET_SINK_PORT); + f_rpc = 0; /* start 的三件套不计入本用例观察窗 */ + s_beats = 0; /* 重建三件套返回点的合法心跳同样不属于观察窗 */ +} + +static void qframe(uint8_t cmd, const uint8_t *d, int len) { + int i; + f_recv_mode = 0; /* 有排队帧 = recv 走取队分支（fresh 默认 WOULDBLOCK） */ + rxq[rxq_len++] = UI_REMO_TAG_CLIENT; + rxq[rxq_len++] = cmd; + rxq[rxq_len++] = (uint8_t)(len >> 8); + rxq[rxq_len++] = (uint8_t)(len & 0xFF); + for (i = 0; i < len; i++) { rxq[rxq_len++] = d[i]; } + uint8_t c = 0; + for (i = 0; i < len; i++) { c ^= d[i]; } + rxq[rxq_len++] = c; +} + +/* ---------- 用例 ---------- */ +static void case_null_hook_full_protocol(void) { + printf("case: unregistered hook runs the whole protocol path unchanged\n"); + fresh(0); + f_armed = 1; f_accept_next = 3; /* MCU 单连接模型：client fd = listen fd */ + ui_net_sink_poll(); /* accept -> g_client=3 */ + CHECK(s_beats == 0, "no hook: zero beat side effects"); + f_armed = 0; /* 已建连后不再走 accept */ + uint8_t k = 13; + qframe(UI_REMO_CMD_KEY, &k, 1); + f_can_read = 1; + ui_net_sink_poll(); + CHECK(s_key_n == 1 && s_keys[0] == 13, "KEY frame injected to backend"); + CHECK(s_last_tx_len == 5 && s_last_tx_cmd == UI_REMO_CMD_KEY, "KEY ack frame shape"); + uint8_t off0[4] = { 0, 0, 0, 0 }; + qframe(UI_REMO_CMD_LCDMEM, off0, 4); + ui_net_sink_poll(); + CHECK(s_lcdmem_calls == 1, "LCDMEM request reached backend"); + CHECK(s_last_tx_cmd == UI_REMO_CMD_LCDMEM && s_last_tx_len == 4 + 4 + UI_FB_SIZE + 1, + "LCDMEM answer frame shape (3209 B)"); + /* CRC = payload(4B 偏移全 0 ^ 3200 个 0xA5，偶数个 10100101) 异或 = 0x00 */ + CHECK(s_last_tx[4 + 4 + UI_FB_SIZE] == 0u, "LCDMEM frame CRC byte at tail (even 0xA5 run -> 0x00)"); +} + +static void case_gated_zero_rpc(void) { + printf("case: gated-off rounds issue zero RPC and zero beats\n"); + fresh(1); + for (int i = 0; i < 5; i++) { ui_net_sink_poll(); } /* armed=0，无监听活 */ + CHECK(f_rpc == 0 && s_beats == 0, "listener unarmed: 5 rounds no RPC no beat"); + f_armed = 1; f_accept_next = 3; + ui_net_sink_poll(); /* 建连（1 RPC + 1 心跳） */ + f_armed = 0; + int b0 = s_beats; + int r0 = f_rpc; + for (int i = 1; i < 32; i++) { /* 无数据 31 轮：门控全挡 */ + ui_net_sink_poll(); + } + CHECK(f_rpc == r0 && s_beats == b0, "31 no-data rounds: gate holds RPC and beats flat"); + ui_net_sink_poll(); /* 第 32 轮兜底 recv */ + CHECK(f_rpc == r0 + 1 && s_beats == b0 + 1, + "liveness round: exactly one recv RPC and exactly one beat on its return"); +} + +static void case_accept_beat(void) { + printf("case: accept roundtrip return feeds beat exactly once\n"); + fresh(1); + f_armed = 1; f_accept_next = -1; /* WOULDBLOCK 空手而归 */ + ui_net_sink_poll(); + CHECK(f_rpc == 1 && s_beats == 1, "one accept RPC -> one beat (even on failure return)"); +} + +static void case_storm_chain_beats(void) { + printf("case: storm of accept roundtrips beats every roundtrip (gap <= single RPC)\n"); + fresh(1); + f_armed = 1; + for (int i = 0; i < 10; i++) { ui_net_sink_poll(); } + CHECK(f_accepts == 10 && f_rpc == 10 && s_beats == 10, + "10 storm rounds: beats == RPCs (old code: no beat inside poll, chain summed) "); +} + +static void case_rebuild_beats(void) { + printf("case: generation rebuild feeds after close pair and after re-listen\n"); + fresh(1); + f_armed = 1; f_accept_next = 3; + ui_net_sink_poll(); /* client=3=listen */ + int r0 = f_rpc; int b0 = s_beats; + f_gen = 2; f_next_fd = 9; + ui_net_sink_poll(); /* 代次变化：close+start */ + CHECK(f_closes == 1 && f_rpc == r0 + 4, + "rebuild does close x1 (client==listen guard) + socket/bind/listen"); + CHECK(s_beats == b0 + 2, "two beat points: after close pair and after re-listen"); + f_armed = 0; f_accept_next = -1; + ui_net_sink_poll(); + CHECK(s_beats == b0 + 2, "gated-off round after rebuild adds nothing"); +} + +static void case_eof_keepalive(void) { + printf("case: EOF (MCU model, client==listen) never closes the listen fd\n"); + fresh(1); + f_armed = 1; f_accept_next = 3; + ui_net_sink_poll(); + f_armed = 0; /* EOF 后无 accept 通路的静默形态 */ + f_recv_mode = 2; f_can_read = 1; + int r0 = f_rpc; int b0 = s_beats; + for (int i = 0; i < 32; i++) { ui_net_sink_poll(); } + CHECK(f_closes == 0, "listen fd survives EOF in single-connection model"); + CHECK(s_beats == b0 + 1 && f_rpc == r0 + 1, + "EOF recv fed one beat; later rounds fully gated (client=-1, armed=0)"); + /* 风暴形态：armed 持续放行 -> EOF 后每轮 accept 空手而归也每轮喂位 */ + f_armed = 1; + int r1 = f_rpc; int b1 = s_beats; + for (int i = 0; i < 10; i++) { ui_net_sink_poll(); } + CHECK(f_rpc == r1 + 10 && s_beats == b1 + 10 && f_closes == 0, + "10 storm accept rounds: beats == RPCs, listen fd still never closed"); +} + +int main(void) { + printf("=== ui_net_sink beat-boundary tests ===\n\n"); + case_null_hook_full_protocol(); + fresh(0); + case_gated_zero_rpc(); + fresh(0); + case_accept_beat(); + fresh(0); + case_storm_chain_beats(); + fresh(0); + case_rebuild_beats(); + fresh(0); + case_eof_keepalive(); + printf("\n=== UI Sink Tests: %d/%d PASSED (failed=%d) ===\n", s_passed, s_total, s_failed); + return (s_failed == 0) ? 0 : 1; +}