Files
STM32F4-Base/test/host/iec104_netmcu/netmcu_stub_test.c
T
wandering1 90cc9a7d99 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 名字的排除口径。
2026-11-18 10:29:18 +08:00

301 lines
11 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.
/*
* IEC104 Net MCU 后端隔离契约测试 runner。
* 编译:假 net_socket + TEST DOUBLE 假后端 + 本文件;坏变体由 -DNETMCU_BAD=Bx 注入。
* 所有结果只证明 fake 契约与测试有效性,不证明产品实现。
*/
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include "IEC104_Net.h"
#include "net_socket_fake.h"
#include "stub_iec104_netmcu.h"
#ifndef NETMCU_BAD
#define NETMCU_BAD 0
#endif
static int failures;
static const char *current_case;
#define CHECK(cond, msg) do { \
if (!(cond)) { \
printf(" FAIL %s: %s\n", current_case, msg); \
++failures; \
} \
} while (0)
static IEC104_NetSocket_t setup_listen(uint16_t port)
{
IEC104_NetSocket_t listener = IEC104_NET_INVALID_SOCKET;
uint16_t bound = 0;
CHECK(IEC104_Net_Init(NULL) == IEC104_NET_OK, "Init");
CHECK(IEC104_Net_Listen("0.0.0.0", port, &listener, &bound, NULL) == IEC104_NET_OK, "Listen");
CHECK(listener != IEC104_NET_INVALID_SOCKET && bound == port, "Listen outputs");
return listener;
}
static IEC104_NetSocket_t setup_accept(IEC104_NetSocket_t listener, uint8_t octet)
{
IEC104_NetSocket_t client = IEC104_NET_INVALID_SOCKET;
IEC104_NetPeer_t peer;
memset(&peer, 0, sizeof(peer));
CHECK(net_fake_peer_arrive(octet, 40000U + octet) == 1, "peer arrive");
CHECK(IEC104_Net_Accept(listener, &client, &peer, NULL) == IEC104_NET_OK, "Accept");
CHECK(peer.port == (uint16_t)(40000U + octet), "peer port");
return client;
}
static void N1_close_keeps_listener(void)
{
IEC104_NetSocket_t l, c;
net_fake_stats_t st;
current_case = "N1";
stub_reset();
l = setup_listen(24001);
c = setup_accept(l, 11);
CHECK(c == l, "single-connection same fd");
CHECK(IEC104_Net_Close(c, NULL) == IEC104_NET_OK, "Close session");
net_fake_stats(&st);
CHECK(st.listen_closed_attempts == 0, "listener never net_close'd");
CHECK(st.drop_conn_calls >= 1, "net_drop_conn used");
CHECK(net_fake_listen_fd() >= 0, "listener survives");
(void)setup_accept(l, 12);
net_fake_stats(&st);
CHECK(st.accept_calls >= 2, "second Accept works");
CHECK(st.listen_closed_attempts == 0, "still no listener close");
}
static void drain_input(IEC104_NetSocket_t client, size_t expected, int degraded)
{
uint8_t buf[128];
size_t total = 0;
int rounds = 0;
while (total < expected && rounds++ < 256) {
uint32_t available = 0xFFFFFFFFU;
IEC104_NetResult_t pr = IEC104_Net_Pending_Input(client, &available, NULL);
size_t budget;
IEC104_NetIoResult_t r;
if (pr == IEC104_NET_OK && available == 0 && degraded == 0) {
/* 精确契约下的 OK/0 才表示“此刻真的空”;降级场景不接受此捷径。 */
break;
}
if (degraded == 2 || pr == IEC104_NET_ERROR) {
/* 报小/不可信:退回完整缓冲,逼出有界续收而不把数据永久藏住。 */
available = (uint32_t)sizeof(buf);
}
budget = available > sizeof(buf) ? sizeof(buf) : available;
r = IEC104_Net_Recv(client, buf, budget);
if (r.result == IEC104_NET_OK) {
total += r.transferred;
} else if (r.result == IEC104_NET_EOF) {
break;
} else {
/* WOULD_BLOCK/RETRY:有界继续,不据此重算超时。 */
}
}
CHECK(total == expected, "all bytes delivered");
}
static void N2_pending_input(void)
{
IEC104_NetSocket_t l, c;
static const uint8_t data[300] = {0};
current_case = "N2a";
stub_reset();
l = setup_listen(24002);
c = setup_accept(l, 21);
CHECK(net_fake_push_rx(data, (int)sizeof(data)) == (int)sizeof(data), "queue 300B");
drain_input(c, sizeof(data), 0);
current_case = "N2b";
stub_reset();
l = setup_listen(24003);
c = setup_accept(l, 22);
/* 精确契约:不谎报 0/1——RX 有 7 字节报 7,RX 空报 0。 */
{
uint32_t n = 0xFFFFFFFFU;
static const uint8_t seven[7] = {1, 2, 3, 4, 5, 6, 7};
CHECK(net_fake_push_rx(seven, 7) == 7, "queue 7B exact probe");
CHECK(IEC104_Net_Pending_Input(c, &n, NULL) == IEC104_NET_OK && n == 7,
"Pending_Input exact 7");
{
uint8_t tmp[8];
IEC104_NetIoResult_t rr = IEC104_Net_Recv(c, tmp, sizeof(tmp));
CHECK(rr.result == IEC104_NET_OK && rr.transferred == 7, "drain 7B exact probe");
}
n = 0xFFFFFFFFU;
CHECK(IEC104_Net_Pending_Input(c, &n, NULL) == IEC104_NET_OK && n == 0,
"Pending_Input exact 0 (empty)");
}
CHECK(net_fake_push_rx(data, (int)sizeof(data)) == (int)sizeof(data), "queue 300B degraded");
net_fake_set_recv_len_degraded(1); /* 内核仍有 300B,但驱动只报不可信哨兵 */
drain_input(c, sizeof(data), 1);
/* 报小:每次只报 1 字节,仍不能让剩余数据永久藏住;独立重灌一遍。 */
stub_reset();
l = setup_listen(24009);
c = setup_accept(l, 23);
CHECK(net_fake_push_rx(data, (int)sizeof(data)) == (int)sizeof(data), "queue 300B under-report");
net_fake_set_recv_len_degraded(2);
drain_input(c, sizeof(data), 2);
}
static void N3_send_short_write(void)
{
IEC104_NetSocket_t l, c;
uint8_t bufs[20][20]; /* 每次 Send 用不同 buffer;返回后立刻涂改刚用过的那块 */
uint8_t sent[64];
net_fake_stats_t st;
size_t i, off = 0;
int rounds = 0;
current_case = "N3";
stub_reset();
l = setup_listen(24004);
c = setup_accept(l, 31);
for (i = 0; i < sizeof(bufs) / sizeof(bufs[0]); ++i) {
size_t k;
for (k = 0; k < sizeof(bufs[0]); ++k) {
bufs[i][k] = (uint8_t)(0x41 + k);
}
}
net_fake_set_send_mode(FAKE_SEND_SHORT, 2, 3);
while (off < sizeof(bufs[0]) && rounds++ < 20) {
IEC104_NetIoResult_t r = IEC104_Net_Send(c, bufs[rounds - 1] + off,
sizeof(bufs[0]) - off);
if (r.result == IEC104_NET_OK) { off += r.transferred; }
/* 调用方返回后立刻整块覆写:后端若借用指针,下次就会发出 0xEE。 */
memset(bufs[rounds - 1], 0xEE, sizeof(bufs[0]));
}
CHECK(off == sizeof(bufs[0]), "short-write progressed to completion");
net_fake_stats(&st);
CHECK(st.bytes_sent == (int)sizeof(bufs[0]), "kernel accepted all bytes");
CHECK(net_fake_copy_tx(sent, (int)sizeof(sent)) == (int)sizeof(bufs[0]),
"fake kernel holds all 20 bytes");
{
size_t k;
for (k = 0; k < sizeof(bufs[0]); ++k) {
CHECK((unsigned char)sent[k] == (unsigned char)(0x41 + k),
"in-flight bytes match pre-mutation payload");
}
}
}
static void N4_now_ms_wrap(void)
{
uint64_t a, b, c;
current_case = "N4";
stub_reset();
(void)IEC104_Net_Init(NULL);
net_fake_set_tick(0xFFFFFFF0U);
a = IEC104_Net_Now_Ms();
net_fake_set_tick(0xFFFFFFFFU);
b = IEC104_Net_Now_Ms();
net_fake_set_tick(0x00000000U);
c = IEC104_Net_Now_Ms();
CHECK(b > a, "monotonic before wrap");
CHECK(c > b, "monotonic across 0xFFFFFFFF -> 0");
CHECK((int)(c - b) == 1, "one tick = one ms across wrap");
}
static void N5_generation_invalidates(void)
{
IEC104_NetSocket_t l, c;
uint8_t b[4] = {1, 2, 3, 4};
uint32_t gen0;
current_case = "N5";
stub_reset();
l = setup_listen(24005);
c = setup_accept(l, 51);
gen0 = net_fake_generation();
net_fake_generation_inc();
CHECK(net_fake_generation() == gen0 + 1, "generation bumped");
{
IEC104_NetIoResult_t rr = IEC104_Net_Send(c, b, sizeof(b));
CHECK(rr.result == IEC104_NET_ERROR, "old handle invalid");
CHECK(rr.transferred == 0, "old handle transferred zero");
}
/* 代次变化后旧句柄 Send/Recv 都必须被拒绝。 */
{
char rb[8];
IEC104_NetIoResult_t rr = IEC104_Net_Recv(c, rb, sizeof(rb));
CHECK(rr.result == IEC104_NET_ERROR, "old handle recv invalid");
CHECK(rr.transferred == 0, "old handle recv transferred zero");
}
net_fake_set_tick(0x00000010U);
CHECK(IEC104_Net_Now_Ms() > 0, "clock still works");
/* 重建:Init + Listen + Accept 新 peer */
stub_reset();
l = setup_listen(24006);
c = setup_accept(l, 52);
CHECK(IEC104_Net_Send(c, b, sizeof(b)).result == IEC104_NET_OK,
"new handle usable after reset");
}
static void N6_fd_reuse_no_cross_talk(void)
{
IEC104_NetSocket_t l, c1;
uint8_t b[4] = {9, 9, 9, 9};
net_fake_stats_t st;
current_case = "N6";
stub_reset();
l = setup_listen(24007);
c1 = setup_accept(l, 61);
CHECK(IEC104_Net_Close(c1, NULL) == IEC104_NET_OK, "close first session");
net_fake_stats(&st);
CHECK(st.listen_closed_attempts == 0, "listener intact after close");
CHECK(net_fake_listen_fd() >= 0, "listener fd alive");
/* 单连接模型下 fd 数值会被复用:陈旧句柄不得再读写“空会话”。 */
CHECK(IEC104_Net_Send(c1, b, sizeof(b)).result == IEC104_NET_ERROR,
"stale handle cannot write after close");
{
IEC104_NetIoResult_t rr = IEC104_Net_Recv(c1, (char[8]){0}, 8);
CHECK(rr.result == IEC104_NET_ERROR || rr.transferred == 0,
"stale handle cannot read after close");
}
/* 陈旧句柄重复 Close 必须幂等 no-op,不得把复用后的监听毁掉。 */
CHECK(IEC104_Net_Close(c1, NULL) == IEC104_NET_OK, "stale close is idempotent");
net_fake_stats(&st);
CHECK(st.listen_closed_attempts == 0, "stale close never touches listener");
CHECK(net_fake_listen_fd() >= 0, "listener alive after stale close");
/* 新会话仍能接入并收发。 */
c1 = setup_accept(l, 62);
CHECK(IEC104_Net_Send(c1, b, sizeof(b)).result == IEC104_NET_OK,
"new session usable after stale close");
}
static void N7_reconnect_startdt(void)
{
IEC104_NetSocket_t l, c;
current_case = "N7";
stub_reset();
l = setup_listen(24008);
c = setup_accept(l, 71);
stub_link_send_startdt(c);
stub_link_push_con();
CHECK(stub_link_ready(c) == 1, "STARTDT/STARTDT CON first session");
/* RST -> Recv 返回 ERROR;Close 会话;重新接入 */
net_fake_peer_reset();
CHECK(IEC104_Net_Recv(c, (char[8]){0}, 8).result == IEC104_NET_ERROR, "RST observed");
CHECK(IEC104_Net_Close(c, NULL) == IEC104_NET_OK, "close broken session");
CHECK(stub_link_ready(c) == 0, "reconnect starts with no stale STARTDT");
c = setup_accept(l, 72);
CHECK(c != IEC104_NET_INVALID_SOCKET, "re-accepted");
stub_link_send_startdt(c);
stub_link_push_con();
CHECK(stub_link_ready(c) == 1, "STARTDT link rebuilt after reconnect");
}
int main(void)
{
printf("=== IEC104 Net MCU fake-contract tests (bad=%d) ===\n", NETMCU_BAD);
N1_close_keeps_listener();
N2_pending_input();
N3_send_short_write();
N4_now_ms_wrap();
N5_generation_invalidates();
N6_fd_reuse_no_cross_talk();
N7_reconnect_startdt();
printf("=== IEC104 Net MCU fake-contract tests: %d failures ===\n", failures);
return failures ? 1 : 0;
}