feat(iec104): 把 104 骨架完整迁到 MCU 板端并在台架跑通总召

把 IEC104 从模拟器端整体搬到板端:协议栈原先由独立 iec104Task 驱动,
现在改为 netTask 单 owner 的 threadless 驱动,退役独立任务。

驱动与后端:
- 新增 iec104_net_mcu.c/.h,实现 IEC104_Net.h 的 11 个 ABI 函数,
  用槽表加单调句柄映射 net_socket 的单 fd 模型;CLIENT 拆除只走
  net_drop_conn_locked,绝不 net_close 监听 fd。
- net_socket 增 5 个 owner-only 接口(net_accept_locked、
  net_drop_conn_locked、net_pending_bytes、net_send_try、
  net_mono_now_ms)。
- iec104_serv.c 重写为 iec104_serv_net_tick(),在 netTask 1ms 主循环
  里驱动 core;无 osDelay/阻塞调用,喂狗是第一句。
- Src/freertos.c 删除 iec104Task 三件套,对应栈水位探针表项同步删除。

内存:目标板 192KB SRAM 装不下 vendor 默认容量档,按实测裁剪到
skeleton 档(TCP 缓冲、业务池、SOE 256->128、值槽密集化),
RW_IRAM1 118,408 B / 90.3%,留 2,178 B 余量。

台架修复(只在真硬件暴露):
- SNTP s_ctx.fd 零初始化后为 0,而 net fd 0 是合法槽位下标,
  首次代次变化时误 net_close(0) 关掉 ftpTask 的监听槽,导致 104
  连接被 FTP 的 220 banner 抢走;改为显式 .fd = -1。
- Accept 幂等:单 fd 模型下 vendor 每轮重试 Accept 会拿到同一 fd,
  后端改为会话在役时返 WOULD_BLOCK,Close 不再清槽。

验证:
- Keil 全量重建 0 error 0 warning,uvprojx 零抖动。
- 模拟器真实 TCP 13/13、transport 10/10。
- netmcu 后端单测 13/13(新增 N12)。
- 台架 serial-boot-test required 全中;板端 2404 总召 129 帧收到
  59 遥信(53 有源、全 IV)+ 16 双点 + 30 遥测(PT1 三相非零、
  UN/频率/温度按未标定置 IV)、遥控选择执行全否定、校时 COT 7。
- 期间顺带修正 UI 漂移自检文案、.serialtest required 陈旧项、
  coding-standard 对 vendor 与外部 ABI 名字的排除口径。
This commit is contained in:
2026-11-18 10:29:18 +08:00
parent 2e9272cc8a
commit 90cc9a7d99
125 changed files with 7463 additions and 5335 deletions
+832
View File
@@ -0,0 +1,832 @@
/*
* FAKE net_socket 实现 —— 见 net_socket_fake.h 的定位说明。
* 只服务 test/host/iec104_netmcu/,不进产品构建。
*/
#include "net_socket_fake.h"
#include <stdio.h>
#include <string.h>
/* fake_fd_t 定义见下方(fd_at 的前向声明在结构体之后)。 */
#define FAKE_MAX_FD 8
#define FAKE_RX_CAP 2048
#define FAKE_PEER_QUEUE 4
typedef struct {
int used;
int is_listener;
int listening;
int established;
int peer_fin;
int peer_reset;
int rx_len;
uint8_t rx[FAKE_RX_CAP];
/* 发送侧“内核还没接受”的暂存量:测试靠它验证“返回后改 buffer 不影响在途数据”。
* 真实驱动里这段数据已经进了芯片 FIFO,所以 fake 必须在 net_send 里就拷走。 */
int tx_pending;
uint8_t tx[FAKE_RX_CAP];
} fake_fd_t;
typedef struct {
uint8_t octet;
uint16_t port;
} fake_peer_t;
/* net_socket.h 在 NET_NO_OS 下不声明 fd_at;本 fake 的静态辅助函数保持该文件内私有。 */
static fake_fd_t *fd_at(int fd);
static uint16_t fake_recv_len(uint8_t sock);
static fake_fd_t fds[FAKE_MAX_FD];
static fake_peer_t peers[FAKE_PEER_QUEUE];
static int peer_count;
static uint32_t generation = 1;
/* 注意:板端 tick 源已由 net-cutover 钉为 HAL_GetTick(),fake 直接受控。
* N-2 口径:netTask 每轮调用 net_mono_now_ms() 采样一次 tick;这里模拟
* 两次采样之间的累计,不把“不调用就不丢时间”塞进用例。 */
static uint32_t tick_low;
static int fake_errno;
static uint8_t fake_owner = 1;
static uint64_t mono_ms;
static uint32_t mono_last;
static int mono_seeded;
static net_sock_t fake_socks[FAKE_MAX_FD];
/* net_socket.h 声明但后端可能查询这些轻量接口;fake 用内存状态回答。 */
int net_listener_armed(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
return f != NULL && f->is_listener && (f->listening || f->established) ? 1 : 0;
}
int net_can_read(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
return f != NULL && (f->rx_len > 0 || f->peer_fin || f->peer_reset) ? 1 : 0;
}
static net_fake_send_mode_t send_mode;
static int send_mode_left;
static int send_short_limit;
static net_fake_accept_mode_t accept_mode;
static int accept_mode_left;
static net_fake_send_mode_t recv_mode;
static int recv_mode_left;
static int recv_len_degraded;
static int reuse_after_close = 1;
static net_fake_stats_t stats;
static fake_fd_t *fd_at(int fd)
{
if (fd < 0 || fd >= FAKE_MAX_FD) {
return NULL;
}
return fds[fd].used ? &fds[fd] : NULL;
}
static int alloc_fd(void)
{
int i;
for (i = 0; i < FAKE_MAX_FD; ++i) {
if (!fds[i].used) {
memset(&fds[i], 0, sizeof(fds[i]));
fds[i].used = 1;
return i;
}
}
return -1;
}
void net_fake_reset(void)
{
memset(fds, 0, sizeof(fds));
memset(peers, 0, sizeof(peers));
memset(&stats, 0, sizeof(stats));
peer_count = 0;
generation = 1;
tick_low = 0;
send_mode = FAKE_SEND_NORMAL;
send_mode_left = 0;
send_short_limit = 0;
accept_mode = FAKE_ACCEPT_NORMAL;
accept_mode_left = 0;
recv_mode = FAKE_SEND_NORMAL;
recv_mode_left = 0;
recv_len_degraded = 0;
reuse_after_close = 1;
fake_owner = 1;
fake_errno = 0;
mono_ms = 0;
mono_last = tick_low;
mono_seeded = 0;
memset(fake_socks, 0, sizeof(fake_socks));
/* 预置一个已监听 fd=3:所有用例都从“板端后端已经 Listen 成功”起步。 */
fds[3].used = 1;
fds[3].is_listener = 1;
fds[3].listening = 1;
}
int net_fake_peer_arrive(uint8_t last_octet, uint16_t port)
{
if (peer_count >= FAKE_PEER_QUEUE) {
return 0;
}
peers[peer_count].octet = last_octet;
peers[peer_count].port = port;
++peer_count;
return 1;
}
int net_fake_session_fd(void)
{
int i;
for (i = 0; i < FAKE_MAX_FD; ++i) {
/* 单连接模型:accept 后监听 fd 自身就是会话 fd,所以不能排除 is_listener。 */
if (fds[i].used && fds[i].established) {
return i;
}
}
return -1;
}
int net_fake_listen_fd(void)
{
int i;
for (i = 0; i < FAKE_MAX_FD; ++i) {
if (fds[i].used && fds[i].is_listener && fds[i].listening) {
return i;
}
}
return -1;
}
int net_fake_listener_armed(void)
{
int fd = net_fake_listen_fd();
return (fd >= 0 && net_listener_armed(fd) != 0) ? 1 : 0;
}
int net_fake_push_rx(const void *data, int len)
{
int fd = net_fake_session_fd();
fake_fd_t *f;
int room;
if (fd < 0 || len <= 0) {
return -1;
}
f = &fds[fd];
room = FAKE_RX_CAP - f->rx_len;
if (len > room) {
len = room;
}
memcpy(f->rx + f->rx_len, data, (size_t)len);
f->rx_len += len;
return len;
}
void net_fake_peer_fin(void)
{
int fd = net_fake_session_fd();
if (fd >= 0) {
fds[fd].peer_fin = 1;
}
}
void net_fake_peer_reset(void)
{
int fd = net_fake_session_fd();
if (fd >= 0) {
fds[fd].peer_reset = 1;
}
}
void net_fake_set_send_mode(net_fake_send_mode_t mode, int times, int short_limit)
{
send_mode = mode;
send_mode_left = times;
send_short_limit = short_limit;
}
void net_fake_set_accept_mode(net_fake_accept_mode_t mode, int times)
{
accept_mode = mode;
accept_mode_left = times;
}
void net_fake_set_recv_mode(net_fake_send_mode_t mode, int times)
{
recv_mode = mode;
recv_mode_left = times;
}
void net_fake_set_recv_len_degraded(int mode)
{
recv_len_degraded = mode;
}
void net_fake_set_reuse_after_close(int on)
{
reuse_after_close = on ? 1 : 0;
}
void net_generation_inc(void)
{
++generation;
/* 代次变化 = 芯片复位:监听退回未监听,等待外层重建。
* 注意:故意保留 established 状态——真实芯片复位后旧 fd 数值可能被新连接
* 复用,驱动层不会替上层做“代次校验”;那正是后端必须自己查代次的原因。 */
{
int i;
for (i = 0; i < FAKE_MAX_FD; ++i) {
if (fds[i].used) {
fds[i].listening = 0;
}
}
}
peer_count = 0;
}
void net_fake_generation_inc(void)
{
net_generation_inc();
}
uint32_t net_get_generation(void)
{
return generation;
}
uint32_t net_fake_generation(void)
{
return net_get_generation();
}
void net_fake_set_tick(uint32_t tick)
{
tick_low = tick;
}
uint32_t net_fake_tick_low(void)
{
return tick_low;
}
void net_fake_set_owner(uint8_t owner)
{
fake_owner = owner ? 1U : 0U;
}
uint8_t net_fake_owner(void)
{
return fake_owner;
}
uint32_t HAL_GetTick(void)
{
return tick_low;
}
uint8_t net_ctx_is_owner_task(void)
{
return fake_owner;
}
int net_set_errno(int err)
{
fake_errno = err;
return err;
}
int net_get_errno(void)
{
return fake_errno;
}
uint16_t net_dynamic_port_next(void)
{
static uint16_t next = 49152U;
uint16_t out = next;
next = (uint16_t)(out == 65535U ? 49152U : out + 1U);
return out;
}
uint16_t net_htons(uint16_t hostshort)
{
return (uint16_t)((hostshort >> 8) | (hostshort << 8));
}
uint16_t net_ntohs(uint16_t netshort)
{
return net_htons(netshort);
}
uint32_t net_inet_addr(const char *cp)
{
unsigned a, b, c, d;
if (cp == NULL || sscanf_s(cp, "%u.%u.%u.%u", &a, &b, &c, &d) != 4) {
return 0U;
}
if (a > 255U || b > 255U || c > 255U || d > 255U) {
return 0U;
}
/* 与产品同族:s_addr 的第 0 个内存字节 == 点分第一段(小端数值反转)。 */
return (uint32_t)(a | (b << 8) | (c << 16) | (d << 24));
}
char *net_inet_ntoa(uint32_t addr, char *buf)
{
unsigned a = addr & 0xFFU;
unsigned b = (addr >> 8) & 0xFFU;
unsigned c = (addr >> 16) & 0xFFU;
unsigned d = (addr >> 24) & 0xFFU;
if (buf != NULL) {
(void)_snprintf_s(buf, 16, 15, "%u.%u.%u.%u", a, b, c, d);
}
return buf;
}
net_sock_t *net_get_sock(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
if (f == NULL) {
return NULL;
}
return &fake_socks[sockfd];
}
net_sock_t *net_sock_raw(int sockfd)
{
if (sockfd < 0 || sockfd >= FAKE_MAX_FD) {
return NULL;
}
return &fake_socks[sockfd];
}
net_sock_state_t net_sock_state(int sockfd)
{
net_sock_t *s = net_sock_raw(sockfd);
return (s != NULL) ? s->state : NET_SOCK_STATE_CLOSED;
}
static void sync_sock(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
net_sock_t *s = net_sock_raw(sockfd);
if (f == NULL || s == NULL) {
return;
}
s->ch395_sock = (uint8_t)sockfd;
s->in_use = 1U;
if (f->established) {
s->state = NET_SOCK_STATE_ESTABLISHED;
} else if (f->is_listener && f->listening) {
s->state = NET_SOCK_STATE_LISTENING;
} else if (f->used) {
s->state = NET_SOCK_STATE_CREATED;
} else {
s->state = NET_SOCK_STATE_CLOSED;
s->in_use = 0U;
}
s->send_ready = 1U;
s->readable = (uint8_t)(f->rx_len > 0 || f->peer_fin || f->peer_reset);
s->remote_port = (uint16_t)(stats.last_peer_port);
if (f->established) {
memcpy(s->remote_ip_arr, stats.last_peer_ip, sizeof(s->remote_ip_arr));
}
}
int net_listen_locked(int sockfd)
{
int rc = net_listen(sockfd);
sync_sock(sockfd);
return rc;
}
int net_accept_locked(int sockfd, struct net_sockaddr *addr, int *addrlen)
{
int rc = net_accept(sockfd, addr, addrlen);
sync_sock(sockfd);
if (rc >= 0 && addr != NULL && addrlen != NULL && *addrlen >= (int)sizeof(struct net_sockaddr_in)) {
struct net_sockaddr_in *in = (struct net_sockaddr_in *)(void *)addr;
in->sin_family = NET_AF_INET;
in->sin_port = net_htons(stats.last_peer_port);
memcpy(&in->sin_addr.s_addr, stats.last_peer_ip, sizeof(in->sin_addr.s_addr));
}
return rc;
}
int net_drop_conn_locked(net_sock_t *p_sock)
{
int rc;
if (p_sock == NULL) {
return -1;
}
rc = net_drop_conn((int)p_sock->ch395_sock);
sync_sock((int)p_sock->ch395_sock);
return rc;
}
int net_close_sock(net_sock_t *p_sock)
{
int rc;
if (p_sock == NULL) {
return -1;
}
rc = net_close((int)p_sock->ch395_sock);
sync_sock((int)p_sock->ch395_sock);
return rc;
}
int net_send_sock(net_sock_t *p_sock, const void *buf, int len)
{
return net_send((int)p_sock->ch395_sock, buf, len, 0);
}
int net_recv_sock(net_sock_t *p_sock, void *buf, int len, int flags)
{
return net_recv((int)p_sock->ch395_sock, buf, len, flags);
}
int net_pending_bytes(int sockfd)
{
fake_fd_t *f;
if (fake_owner == 0U) {
net_set_errno(NET_ERR_NOT_IN_NETTASK);
return -1;
}
f = fd_at(sockfd);
if (f == NULL || !f->established) {
net_set_errno(NET_ERR_BADF);
return -1;
}
++stats.recv_len_calls;
if (recv_len_degraded == 1) {
net_set_errno(NET_ERR_BUSY);
return -1;
}
return (int)fake_recv_len((uint8_t)sockfd);
}
int net_send_try(net_sock_t *p_sock, const void *buf, int len, int *sent)
{
int rc;
if (fake_owner == 0U) {
net_set_errno(NET_ERR_NOT_IN_NETTASK);
return NET_ERR_NOT_IN_NETTASK;
}
if (sent == NULL || p_sock == NULL || buf == NULL || len < 0) {
net_set_errno(NET_ERR_INVAL);
return NET_ERR_INVAL;
}
*sent = 0;
if (len > 1024) {
len = 1024;
}
rc = net_send((int)p_sock->ch395_sock, buf, len, 0);
if (rc >= 0) {
*sent = rc;
return 0;
}
return rc;
}
uint64_t net_mono_now_ms(void)
{
uint32_t now = HAL_GetTick();
uint32_t delta;
if (fake_owner == 0U) {
net_set_errno(NET_ERR_NOT_IN_NETTASK);
return mono_ms;
}
if (!mono_seeded) {
mono_last = now;
mono_seeded = 1;
}
delta = now - mono_last;
mono_last = now;
mono_ms += (uint64_t)delta;
return mono_ms;
}
int net_send_locked(net_sock_t *p_sock, const void *buf, int len, TaskHandle_t caller)
{
int rc;
(void)caller;
if (p_sock == NULL || buf == NULL || len < 0) {
net_set_errno(NET_ERR_INVAL);
return NET_ERR_INVAL;
}
rc = net_send((int)p_sock->ch395_sock, buf, len, 0);
if (rc < 0) {
net_set_errno(NET_ERR_WOULDBLOCK);
}
return rc;
}
void net_fake_stats(net_fake_stats_t *out)
{
if (out != NULL) {
*out = stats;
}
}
void net_fake_stats_reset(void)
{
memset(&stats, 0, sizeof(stats));
}
/* 把 fake 内核中“已接受但尚未被对端取走”的字节拷给测试,验证 no-borrow。
* 返回可用长度;data 可为 NULL(只查询长度)。 */
int net_fake_copy_tx(uint8_t *data, int capacity)
{
int fd = net_fake_session_fd();
int n;
if (fd < 0) {
return -1;
}
n = fds[fd].tx_pending;
if (data != NULL && capacity > 0) {
int take = n < capacity ? n : capacity;
memcpy(data, fds[fd].tx, (size_t)take);
return take;
}
return n;
}
/* --------------------------- BSD 兼容面和 net_socket.h --------------------------- */
int net_socket(int domain, int type)
{
int i;
int fd;
(void)domain;
(void)type;
if (!reuse_after_close) {
/* 分配一个此前没用过的 fd,制造“旧整数被新会话复用”的对照。 */
for (i = 0; i < FAKE_MAX_FD; ++i) {
if (!fds[i].used) {
memset(&fds[i], 0, sizeof(fds[i]));
fds[i].used = 1;
sync_sock(i);
return i;
}
}
return -1;
}
fd = alloc_fd();
if (fd >= 0) {
sync_sock(fd);
}
return fd;
}
int net_bind(int sockfd, const struct net_sockaddr *addr, int addrlen)
{
(void)addr;
(void)addrlen;
return fd_at(sockfd) != NULL ? 0 : -1;
}
int net_listen(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
if (f == NULL) {
return -1;
}
f->listening = 1;
f->is_listener = 1;
sync_sock(sockfd);
return 0;
}
int net_accept(int sockfd, struct net_sockaddr *addr, int *addrlen)
{
fake_fd_t *f = fd_at(sockfd);
(void)addr;
(void)addrlen;
++stats.accept_calls;
++stats.hardware_calls;
if (accept_mode_left > 0 || accept_mode != FAKE_ACCEPT_NORMAL) {
net_fake_accept_mode_t mode = accept_mode;
if (accept_mode_left > 0) {
--accept_mode_left;
}
if (accept_mode_left == 0) {
accept_mode = FAKE_ACCEPT_NORMAL;
}
switch (mode) {
case FAKE_ACCEPT_WOULDBLOCK:
++stats.would_block_returns;
return NET_ERR_WOULDBLOCK;
case FAKE_ACCEPT_BUSY:
++stats.busy_returns;
return NET_ERR_BUSY;
case FAKE_ACCEPT_RESOURCE_LOW:
return NET_ERR_NOMEM;
default:
break;
}
}
if (f == NULL || !f->listening || peer_count == 0) {
++stats.would_block_returns;
return NET_ERR_WOULDBLOCK;
}
/* 单连接模型的核心:交回的“客户端 fd”就是监听 fd 本身。 */
f->established = 1;
f->peer_fin = 0;
f->peer_reset = 0;
f->rx_len = 0;
f->tx_pending = 0;
stats.last_peer_ip[0] = 10;
stats.last_peer_ip[1] = 0;
stats.last_peer_ip[2] = 0;
stats.last_peer_ip[3] = peers[0].octet;
stats.last_peer_port = peers[0].port;
memmove(&peers[0], &peers[1], sizeof(peers[0]) * (size_t)(peer_count - 1));
--peer_count;
sync_sock(sockfd);
return sockfd;
}
int net_send(int sockfd, const void *buf, int len, int flags)
{
fake_fd_t *f = fd_at(sockfd);
int accepted;
(void)flags;
++stats.send_calls;
++stats.hardware_calls;
if (f == NULL || !f->established || buf == NULL || len <= 0) {
return NET_ERR_BADF;
}
if (send_mode_left > 0 || send_mode != FAKE_SEND_NORMAL) {
net_fake_send_mode_t mode = send_mode;
if (send_mode_left > 0) {
--send_mode_left;
}
if (send_mode_left == 0) {
send_mode = FAKE_SEND_NORMAL;
}
switch (mode) {
case FAKE_SEND_SHORT:
accepted = len < send_short_limit ? len : send_short_limit;
if (accepted <= 0) {
++stats.would_block_returns;
return NET_ERR_WOULDBLOCK;
}
break;
case FAKE_SEND_WOULDBLOCK:
++stats.would_block_returns;
return NET_ERR_WOULDBLOCK;
case FAKE_SEND_BUSY:
++stats.busy_returns;
return NET_ERR_BUSY;
case FAKE_SEND_ZERO_OK:
return 0;
default:
accepted = len;
break;
}
} else {
accepted = len;
}
/* 拷贝语义:数据在调用返回前就已进“芯片”,调用方随后改 buffer 不得影响它。 */
if (f->tx_pending + accepted > FAKE_RX_CAP) {
accepted = FAKE_RX_CAP - f->tx_pending;
}
if (accepted > 0) {
memcpy(f->tx + f->tx_pending, buf, (size_t)accepted);
f->tx_pending += accepted;
stats.bytes_sent += accepted;
}
return accepted;
}
int net_recv(int sockfd, void *buf, int len, int flags)
{
fake_fd_t *f = fd_at(sockfd);
int take;
(void)flags;
++stats.recv_calls;
++stats.hardware_calls;
if (f == NULL || !f->established || buf == NULL || len <= 0) {
return NET_ERR_BADF;
}
if (f->peer_reset) {
return NET_ERR_CONNRESET;
}
if (recv_mode_left > 0 || recv_mode != FAKE_SEND_NORMAL) {
net_fake_send_mode_t mode = recv_mode;
if (recv_mode_left > 0) {
--recv_mode_left;
}
if (recv_mode_left == 0) {
recv_mode = FAKE_SEND_NORMAL;
}
if (mode == FAKE_SEND_WOULDBLOCK) {
++stats.would_block_returns;
return NET_ERR_WOULDBLOCK;
}
if (mode == FAKE_SEND_BUSY) {
++stats.busy_returns;
return NET_ERR_BUSY;
}
}
if (f->rx_len == 0) {
if (f->peer_fin) {
return 0; /* EOF */
}
++stats.would_block_returns;
return NET_ERR_WOULDBLOCK;
}
take = len < f->rx_len ? len : f->rx_len;
memcpy(buf, f->rx, (size_t)take);
memmove(f->rx, f->rx + take, (size_t)(f->rx_len - take));
f->rx_len -= take;
return take;
}
int net_recv_nb(int sockfd, void *buf, int len)
{
return net_recv(sockfd, buf, len, 0);
}
int net_recv_to(int sockfd, void *buf, int len, uint32_t timeout_ms)
{
(void)timeout_ms;
return net_recv(sockfd, buf, len, 0);
}
int net_setblocking(int sockfd, int on)
{
(void)on;
return fd_at(sockfd) != NULL ? 0 : -1;
}
int net_close(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
++stats.close_calls;
++stats.hardware_calls;
if (f == NULL) {
return -1;
}
if (f->is_listener) {
/* 真实板端:单连接模型下对监听 fd 调 net_close 会连监听一起毁掉。
* fake 如实模拟:返回成功但监听消失,同时留下违规计数供断言。 */
++stats.listen_closed_attempts;
memset(f, 0, sizeof(*f));
return 0;
}
memset(f, 0, sizeof(*f));
return 0;
}
int net_drop_conn(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
++stats.drop_conn_calls;
++stats.hardware_calls;
if (f == NULL) {
return -1;
}
/* 拆会话、保监听:监听 fd 自身保留,会话状态清零。 */
f->established = 0;
f->peer_fin = 0;
f->peer_reset = 0;
f->rx_len = 0;
f->tx_pending = 0;
f->listening = 1;
f->is_listener = 1;
sync_sock(sockfd);
return 0;
}
/* 板端后端需要的 32 位节拍源;签名以最终 plan.md / 后端源码为准。
* 当前先用无参形式提供测试可控 tick,后端若用 osKernelGetTickCount() 等
* 别的源,runner 通过 -D 重映射,用例不变。 */
uint32_t ch395f_get_tick_1ms(void)
{
return tick_low;
}
/* 驱动提供的接收队列长度查询(板端后端 Pending_Input 的数据来源)。
* 真实签名(Drivers/BSP/CH395F/ch395f.h:573):uint16_t ch395f_get_recv_len(uint8_t sock)。
* 降级模式返回 0 / 0xFFFF:后者模拟芯片异常,强制后端走 ERROR 契约。 */
static uint16_t fake_recv_len(uint8_t sock);
static uint16_t fake_recv_len(uint8_t sock)
{
fake_fd_t *f = fd_at((int)sock);
++stats.recv_len_calls;
if (f == NULL) {
return 0xFFFFU;
}
if (recv_len_degraded == 2) {
return 1U; /* 报小:每次只说 1 字节有界,剩余靠上层续收 */
}
if (recv_len_degraded == 1) {
return 0xFFFFU; /* 查询不可信:强制后端走 ERROR 降级路径 */
}
return (uint16_t)f->rx_len;
}