perf(iec104): 参数区按 17 项真实消费者收窄并接上真实定值模型

104 协议侧参数通道此前镜像了厂商点表的全部 430 条参数(697 槽),
但其中 413 条在本设备上没有任何消费者——104 与设备侧真实定值模型
prot_set 之间零调用,主站改定值只落在无人读的 RAM 镜像里,保护功能
毫无感知。本次按"严格按消费者收窄"口径收口:

可见性以 iec104_dtu_protection_mapping() 语义桥表为唯一判据,只放行
三段过流投退/定值/延时(9 项)、低压与过压定值/延时(4 项)、PT 与
CT 一次/二次额定(4 项)。其余参数在位表枚举层即不可见,主站读取
得到 COT=47 + P/N=1 的显式否定确认,不静默丢弃。values[697]→values[53]、
staged[264]→staged[17],并删除生成式 iec104_source_ranks.h。

桥表接真实源:iec104_serv 的 parameter_read/apply 从 NULL 改为直读
prot_set 与整批原子提交,Q10 量化后一次事务落地,持久化仍由
defaultTask 的脏标志闭环负责。

prot_set 因此出现两个运行时写者(netTask 的 104 与 uiTask 的本地整
定),原"写者靠启动时序串行"的约定失效。加入写事务互斥与 seqlock
序号:四个写入口全部进锁,校验与提前返回一律在 enter 之前;序号卡
奇数连续 8 拍即判保护闭锁,避免自检被永久跳过而静默失去防篡改能力。
锁的安装在 defaultTask 的存储 bring-up 阶段,不在 app_main_init——
后者早于 osKernelInitialize,内核启动前禁止任何 RTOS 创建类 API。

实测:RW_IRAM1 117,304→113,720 B(−3,584 B,89.50%→86.76%);
ER_IROM1 413,392→411,668 B(−1,724 B);iec104_source.o 5,656→2,056 B;
prot_set.o 344→352 B(+8 B,写事务序号与锁句柄)。Keil 构建 0 错误
0 警告;主机侧 prot_set 175/175、iec104_dtu 7/7;真实 TCP 验收
13/13;暂存口径门禁 18 项全通过。

已知边界:模拟器不链接 iec104_serv.c,TCP 验收不覆盖 prot_set 绑定,
板端需实机确认主站写入能反映到本地定值页;17 项中 15 项的出厂默认
值与点表字面量不同,主站读到的是真实模型的值;绑定真实源后定值区
切换一律拒绝(单套活跃值无原子整区事务)。
This commit is contained in:
2026-11-19 15:48:21 +08:00
parent a40d52a116
commit 7d1db02164
22 changed files with 1235 additions and 328 deletions
+308 -46
View File
@@ -1,7 +1,9 @@
/* /*
* 模块名称:保护定值模型(P1,定值校验和 载体)——实现 * 模块名称:保护定值模型(P1,定值校验和 载体)——实现
*(保护功能清单见 docs/算法/继电保护功能复现规划.md) *(保护功能清单见 docs/算法/继电保护功能复现规划.md)
* 模块功能:见 prot_set.h。纯逻辑,零平台依赖(仅 stdint.h + 自身头)。 * 模块功能:见 prot_set.h。纯逻辑,零平台依赖(仅 stdint.h + size_t + 自身头);
* 写事务保护只持有**两个函数指针**(prot_set_lock_t),由平台侧在安装时注入,
* 本文件不认识任何 RTOS/HAL 符号——固件、模拟器、主机单测三方共用同一份源码。
* *
* ⚠ 默认值/范围为拟定值(参考 EEPROM 出厂默认表不在本仓库,规划 §10.3 待补); * ⚠ 默认值/范围为拟定值(参考 EEPROM 出厂默认表不在本仓库,规划 §10.3 待补);
* 通讯地址逐项对照参考 Comm/Pub/Const_CommSetPara.c g_tCommSetParaTab。 * 通讯地址逐项对照参考 Comm/Pub/Const_CommSetPara.c g_tCommSetParaTab。
@@ -18,8 +20,6 @@
*/ */
#include "prot_set.h" #include "prot_set.h"
#include <string.h> /* memcpy(set_sealed 影子区拷贝,B7) */
/* 元数据表:顺序必须与 prot_set_id_t 严格一致(逐行带地址注释,同 phasor /* 元数据表:顺序必须与 prot_set_id_t 严格一致(逐行带地址注释,同 phasor
* k_inst 的朴素行式风格) */ * k_inst 的朴素行式风格) */
const prot_set_meta_t g_prot_set_meta[PS_ID_COUNT] = { const prot_set_meta_t g_prot_set_meta[PS_ID_COUNT] = {
@@ -69,22 +69,41 @@ const prot_set_meta_t g_prot_set_meta[PS_ID_COUNT] = {
{ 0x0000, 0u, PROT_SET_Q10(1.01), PROT_SET_Q10(1.0), PROT_SET_Q10(1.1) }, /* 低频返回系数 */ { 0x0000, 0u, PROT_SET_Q10(1.01), PROT_SET_Q10(1.0), PROT_SET_Q10(1.1) }, /* 低频返回系数 */
}; };
static uint32_t s_val[2][PS_ID_COUNT]; /* 双缓冲值区(uint32 承载 int32,校验和按字覆盖) static volatile uint32_t s_val[2][PS_ID_COUNT];
/* 双缓冲值区(uint32 承载 int32,校验和按字覆盖)
* B7:写者改影子区后单字交换 s_act, * B7:写者改影子区后单字交换 s_act,
* 读侧(protectTask selfcheck/get)永远看到一致快照 */ * 读侧(protectTask selfcheck/get)永远看到一致快照
* 带 volatile:提交顺序(影子区写完 → 发布封存对 →
* 交换活跃区)必须真的按这个顺序落到内存,编译器
* 不得把值区读写挪到提交序号前后 */
static volatile uint8_t s_act; /* 活跃区下标(0/1);交换 = 单字存储 */ static volatile uint8_t s_act; /* 活跃区下标(0/1);交换 = 单字存储 */
static uint32_t s_sum; /* 封存的正码 */ static volatile uint32_t s_sum; /* 封存的正码(提交窗口内与 s_seq 配对发布) */
static uint32_t s_sumn; /* 封存的反码 */ static volatile uint32_t s_sumn; /* 封存的反码 */
static uint64_t s_bad_mask; /* load_raw/parse 越界位图(B8:40 项 → 64 位) */ static volatile uint32_t s_seq; /* 提交序号:奇数 = 提交进行中;见 prot_write_enter */
static uint8_t s_locked; /* 定值非法 → 闭锁(定值校验和) */ static uint8_t s_odd_streak; /* 连续撞见奇数序号的次数(自检的 fail-safe 计数) */
static uint64_t s_bad_mask; /* 只由整表装载/解析写(见 prot_set_bad_mask) */
static volatile uint8_t s_locked; /* 定值非法 → 闭锁(定值校验和) */
static uint8_t s_dirty; /* 未落盘定值改动(B7 持久化脏标志) */ static uint8_t s_dirty; /* 未落盘定值改动(B7 持久化脏标志) */
static prot_set_lock_t s_lock = { 0, 0 };/* 写事务锁钩子(成员为 0 = 未安装) */
/* 连续撞见"提交序号为奇"的容忍上限。正常提交窗口是微秒级,而 selfcheck 由
* protectTask 按 20 ms 节拍调用——连撞 8 拍(约 160 ms)还停在奇数,说明写者
* 不是"正在提交",而是死锁、被锁内异常路径卡住、或进入了永不返回的钩子。
* 此时值区的可信度无从判断,**闭锁保护是唯一 fail-safe 的选择**:宁可保护停走,
* 也不能带着不可信的定值继续判据。取值理由:8 远大于任何真实临界区时长
* (微秒级 × 8 拍 = 160 ms 已是五个数量级的余量),又远小于"现场容忍保护
* 带着坏定值运行"的时长。 */
#define PROT_SET_ODD_STREAK_MAX 8u
/* /*
* 函数功能:sum32 覆盖指定值区(参考 Fun_CalSum32 同款:32 位字累加自然回绕) * 函数功能:sum32 覆盖指定值区(参考 Fun_CalSum32 同款:32 位字累加自然回绕)
* 入口参数:vals - PS_ID_COUNT 个字的值区 * 入口参数:vals - PS_ID_COUNT 个字的值区
* 返 回 值:校验和正码 * 返 回 值:校验和正码
* 函数说明:形参带 volatile——读侧拿提交序号做 seqlock,求和若被编译器整体
* 提到序号读之前,序号校验就形同虚设(非 volatile 的数组访问没有
* 与 volatile 访问之间的顺序约束)
*/ */
static uint32_t prot_sum_buf(const uint32_t *vals) { static uint32_t prot_sum_buf(const volatile uint32_t *vals) {
uint32_t sum = 0u; uint32_t sum = 0u;
uint32_t i; uint32_t i;
@@ -94,6 +113,93 @@ static uint32_t prot_sum_buf(const uint32_t *vals) {
return sum; return sum;
} }
/* ==================== 写事务(多写者 + 读侧无锁快照) ====================
* 双缓冲只保证"读侧看到完整快照",不保证写者之间不交错。三个写入口
* (set_sealed / apply_batch / load_raw)统一这样进提交:
* enter:先拿平台锁(若已装钩子)→ 提交序号变奇(标记"提交进行中")
* 提交:影子区改值 → 写 s_sum/s_sumn → s_locked=0 → 单字交换 s_act
* exit :提交序号回偶 → 放平台锁
* 读侧(selfcheck)靠序号奇偶+双读判定"这轮撞上提交窗口",只跳过不判失配;
* 写者之间靠平台锁串行——否则两方会同时改同一块影子区,交换出撕裂值区。
* 单核 Cortex-M4 上对齐 32 位读写在指令级原子,序号发布无需屏障指令。
*/
/*
* 函数功能:进入写事务(拿平台锁 + 提交序号变奇)
* 入口参数:无
* 返 回 值:无
* 函数说明:调用方保证 enter/exit 严格成对——本模块把全部校验放在 enter 之前,
* enter 之后不存在"提前返回"分支,因此不需要成对清账的失败路径
*/
static void prot_write_enter(void) {
if (s_lock.enter != 0) {
s_lock.enter();
}
s_seq = s_seq + 1u; /* 奇数:从现在起读侧看到的可能是中间态 */
}
/*
* 函数功能:退出写事务(提交序号回偶 + 放平台锁)
* 入口参数:无
* 返 回 值:无
* 函数说明:先发布偶数(值区与封存对此刻已一致),再放锁——读侧不会读到
* "锁已放、序号仍奇"的稳态;本函数与 prot_write_enter 一一对应
*/
static void prot_write_exit(void) {
s_seq = s_seq + 1u; /* 偶数:提交完成 */
if (s_lock.exit != 0) {
s_lock.exit();
}
}
/*
* 函数功能:安装/卸载写事务锁钩子
* 入口参数:lock - 钩子(NULL = 卸载回单写者假设)
* 返 回 值:无
* 限定条件:任何写者启动前安装;本函数不加锁、不可重入(改的是两个函数指针)
*/
void prot_set_lock_install(const prot_set_lock_t *lock) {
if (lock == 0) {
s_lock.enter = 0;
s_lock.exit = 0;
return;
}
s_lock.enter = lock->enter;
s_lock.exit = lock->exit;
}
/*
* 函数功能:定值编号是否在表内(批量接口的守门)
* 入口参数:id - 待查编号
* 返 回 值:1 合法 / 0 越界
* 函数说明:只守上界。prot_set_id_t 的底层类型是无符号的(枚举成员全非负,
* ARMCC/MSVC 都取 unsigned int),负值强转进来会被解释成一个巨大的
* 无符号数,同样落在 >= PS_ID_COUNT 这一侧,由这条判据一并拦下——
* 所以不需要也不该写 (int32_t)id < 0 那种恒假分支。
*/
static uint8_t prot_id_valid(prot_set_id_t id) {
if ((uint32_t)id >= (uint32_t)PS_ID_COUNT) {
return 0u;
}
return 1u;
}
/*
* 函数功能:整块复制值区(影子区 ← 活跃区)
* 入口参数:dst - 目标值区;src - 源值区
* 返 回 值:无
* 函数说明:不用 memcpy——两个值区都是 volatile(见 s_val 的注释),memcpy 的
* 形参是普通指针,塞进去等于把 volatile 语义丢掉、编译器还可自由
* 重排;40 个字的手写循环一样短,顺序也一眼可读
*/
static void prot_copy_buf(volatile uint32_t *dst, const volatile uint32_t *src) {
uint32_t i;
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
dst[i] = src[i];
}
}
/* /*
* 函数功能:把元数据表默认值刷进 RAM 值区 * 函数功能:把元数据表默认值刷进 RAM 值区
* 入口参数:无 * 入口参数:无
@@ -117,13 +223,18 @@ void prot_set_init(void) {
s_bad_mask = 0u; s_bad_mask = 0u;
s_locked = 0u; s_locked = 0u;
s_dirty = 0u; s_dirty = 0u;
s_seq = 0u; /* 装载期不属于"提交",序号回静止态(偶数) */
s_odd_streak = 0u; /* 宽限计数同步归零:init 是唯一的重来一次入口 */
prot_set_seal(); prot_set_seal();
} }
/* /*
* 函数功能:取最近一次 load_raw 的越界位图 * 函数功能:取最近一次**整表装载/解析**的越界位图
* 入口参数:无 * 入口参数:无
* 返 回 值:bit i = 第 i 项越界(load_raw 失败后有效) * 返 回 值:bit i = 第 i 项越界
* 函数说明:只由 prot_set_load_raw / prot_set_store_parse 写(头文件把这条
* 契约写死了)。单项/批量增量写入既不写也不清它——增量写入失败一律
* 以返回值表达,看位图会读到上一次整表装载的旧结果。
*/ */
uint64_t prot_set_bad_mask(void) { uint64_t prot_set_bad_mask(void) {
return s_bad_mask; return s_bad_mask;
@@ -139,7 +250,7 @@ uint64_t prot_set_bad_mask(void) {
int prot_set_load_raw(const int32_t *vals) { int prot_set_load_raw(const int32_t *vals) {
uint64_t mask = 0u; uint64_t mask = 0u;
uint32_t cur_act; uint32_t cur_act;
uint32_t *shadow; volatile uint32_t *shadow;
uint32_t i; uint32_t i;
if (vals == 0) { if (vals == 0) {
@@ -154,7 +265,9 @@ int prot_set_load_raw(const int32_t *vals) {
if (mask != 0u) { if (mask != 0u) {
return -1; return -1;
} }
/* 原子装载(B7):写影子区 → 封存 → 单字交换;读侧无中间态 */ /* 原子装载(B7):写影子区 → 封存 → 单字交换;读侧无中间态。
* 写事务(多写者):校验全在锁外,锁内只做提交,出锁即完成 */
prot_write_enter();
cur_act = s_act; cur_act = s_act;
shadow = s_val[cur_act ^ 1u]; shadow = s_val[cur_act ^ 1u];
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) { for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
@@ -164,6 +277,7 @@ int prot_set_load_raw(const int32_t *vals) {
s_sumn = ~s_sum; s_sumn = ~s_sum;
s_locked = 0u; s_locked = 0u;
s_act = (uint8_t)(cur_act ^ 1u); s_act = (uint8_t)(cur_act ^ 1u);
prot_write_exit();
return 0; return 0;
} }
@@ -196,23 +310,121 @@ int prot_set_set(prot_set_id_t id, int32_t q10) {
*/ */
int prot_set_set_sealed(prot_set_id_t id, int32_t q10) { int prot_set_set_sealed(prot_set_id_t id, int32_t q10) {
uint32_t cur_act; uint32_t cur_act;
uint32_t *shadow; volatile uint32_t *shadow;
if (id >= PS_ID_COUNT) { if (!prot_id_valid(id)) {
return -1; return -1;
} }
if ((q10 < g_prot_set_meta[id].min) || (q10 > g_prot_set_meta[id].max)) { if ((q10 < g_prot_set_meta[id].min) || (q10 > g_prot_set_meta[id].max)) {
return -1; return -1;
} }
/* 校验在锁外(失败不进锁);锁内只有提交,无提前返回 */
prot_write_enter();
cur_act = s_act; cur_act = s_act;
shadow = s_val[cur_act ^ 1u]; shadow = s_val[cur_act ^ 1u];
(void)memcpy(shadow, s_val[cur_act], sizeof(s_val[0])); prot_copy_buf(shadow, s_val[cur_act]);
shadow[(uint32_t)id] = (uint32_t)q10; shadow[(uint32_t)id] = (uint32_t)q10;
s_sum = prot_sum_buf(shadow); s_sum = prot_sum_buf(shadow);
s_sumn = ~s_sum; s_sumn = ~s_sum;
s_locked = 0u; s_locked = 0u;
s_act = (uint8_t)(cur_act ^ 1u); /* 单字交换:读侧原子切换 */ s_act = (uint8_t)(cur_act ^ 1u); /* 单字交换:读侧原子切换 */
s_dirty = 1u; s_dirty = 1u;
prot_write_exit();
return 0;
}
/*
* 函数功能:读一批定值当前值(Q10 工程量)
* 入口参数:ids - 编号数组;n - 个数;out - 输出数组(out[i] 对应 ids[i])
* 返 回 值:0 成功 / -1 参数非法(空指针、n 为 0、n 超上限、任一号越界)
* 限定条件:任意上下文安全,不持锁、不进写事务、**绝不无界等待**
* 函数说明:先捕获提交序号与活跃区下标,整批都从这**同一块**值区取;
* 取完复核序号——期间发生过提交即重取(有限次)。写者只有 104 下发
* 与本地整定两类人工操作,重取次数实际为 0 或 1;不无界自旋是因为
* 读侧可能是高优先级任务,而它等的写者正被自己抢占——自旋就是死等。
* 连续多次提交时退化为"跨提交的混合值",与此前逐项 prot_set_get 的
* 语义同级,不会撕裂结构、更不会触发闭锁。
*/
int prot_set_read_batch(const prot_set_id_t *ids, size_t n, int32_t *out) {
uint32_t seq_a;
uint32_t seq_b;
const volatile uint32_t *row;
uint32_t tries = 0u;
size_t i;
if ((ids == 0) || (out == 0)) {
return -1;
}
if ((n == 0u) || (n > PROT_SET_BATCH_MAX)) {
return -1;
}
for (i = 0u; i < n; i++) {
if (!prot_id_valid(ids[i])) {
return -1;
}
}
do {
seq_a = s_seq;
row = s_val[s_act];
for (i = 0u; i < n; i++) {
out[i] = (int32_t)row[(uint32_t)ids[i]];
}
seq_b = s_seq;
tries++;
} while ((((seq_a & 1u) != 0u) || (seq_a != seq_b)) && (tries < 3u));
return 0;
}
/*
* 函数功能:原子写入一批定值
* 入口参数:changes - 变更数组;n - 个数;validate_only - 非 0 只校验
* 返 回 值:0 整批合法 / -1 有非法项(值区一字未改)
* 限定条件:validate_only 分支零副作用——不置脏、不动值区、不动闭锁位、不进写事务
* 函数说明:校验全在锁外(元数据表是 ROM 常量,校验不碰 RAM 状态);
* 提交在写事务锁内一次完成:拷活跃区到影子 → 改 n 项 → 重算封存对 →
* 清闭锁 → 单字交换 → 置脏。任一项非法即一字未改地返回。
* ⚠ 基准值必须**在锁内**取:若在锁外先把活跃区抄到栈上再进锁,
* 这中间被另一个写者提交,就会用旧基准覆盖掉它的改动(丢写)。
*/
int prot_set_apply_batch(const prot_set_change_t *changes, size_t n, int validate_only) {
uint32_t cur_act;
volatile uint32_t *shadow;
size_t i;
size_t j;
if ((changes == 0) || (n == 0u) || (n > PROT_SET_BATCH_MAX)) {
return -1;
}
for (i = 0u; i < n; i++) {
if (!prot_id_valid(changes[i].id)) {
return -1;
}
if ((changes[i].q10 < g_prot_set_meta[changes[i].id].min)
|| (changes[i].q10 > g_prot_set_meta[changes[i].id].max)) {
return -1;
}
for (j = i + 1u; j < n; j++) {
if (changes[j].id == changes[i].id) {
return -1; /* 同批同项两条:语义不确定,拒整批 */
}
}
}
if (validate_only != 0) {
return 0; /* 预检到此为止:以上只有局部变量与 ROM 表,零副作用 */
}
prot_write_enter();
cur_act = s_act;
shadow = s_val[cur_act ^ 1u];
prot_copy_buf(shadow, s_val[cur_act]);
for (i = 0u; i < n; i++) {
shadow[(uint32_t)changes[i].id] = (uint32_t)changes[i].q10;
}
s_sum = prot_sum_buf(shadow);
s_sumn = ~s_sum;
s_locked = 0u;
s_act = (uint8_t)(cur_act ^ 1u); /* 单字交换:读侧原子切换 */
s_dirty = 1u;
prot_write_exit();
return 0; return 0;
} }
@@ -222,7 +434,8 @@ int prot_set_set_sealed(prot_set_id_t id, int32_t q10) {
* 返 回 值:peek/take = 1 存在未落盘改动 / 0 干净;mark 无返回 * 返 回 值:peek/take = 1 存在未落盘改动 / 0 干净;mark 无返回
* 函数说明:peek 非消费(iec104Task 每轮通知,直到落盘成功); * 函数说明:peek 非消费(iec104Task 每轮通知,直到落盘成功);
* take 消费(defaultTask 落盘前);mark 写盘失败回置(等下轮重试)。 * take 消费(defaultTask 落盘前);mark 写盘失败回置(等下轮重试)。
* 单字节标志,多读者安全;写者只有 set_sealed(置)与属主任务(清/置)。 * 单字节标志,多读者安全;写者只有 set_sealed/apply_batch(置)与
* 属主任务(清/置)。
*/ */
uint8_t prot_set_dirty_peek(void) { uint8_t prot_set_dirty_peek(void) {
return s_dirty; return s_dirty;
@@ -299,17 +512,46 @@ void prot_set_seal(void) {
* 返 回 值:0 通过 / -1 失配(已置闭锁) * 返 回 值:0 通过 / -1 失配(已置闭锁)
* 函数说明:失配 → s_locked 置位并保持,直到下一次 seal; * 函数说明:失配 → s_locked 置位并保持,直到下一次 seal;
* 元件层每拍读 prot_set_locked() 决定整体复位(联动闭锁)。 * 元件层每拍读 prot_set_locked() 决定整体复位(联动闭锁)。
* B7 双缓冲 + seqlock 式复核:先读封存和、再读值区、再读封存和, * 读侧无锁,靠两重旁证识别"提交进行中":
* 两次不同 = 检查期间发生了原子提交 → 本轮不作数(下拍再查), * ① 提交序号 s_seq 为奇 = 有写者在提交窗口内 → 本轮不作数;
* 杜绝"提交瞬间被巡检撞见"的误锁(收口 B5 竞态窗口)。 * ② 起止各读一次序号与封存和,任一变化 = 期间发生过提交 → 本轮不作数。
* 两者只**跳过本轮**,绝不据此判失配——提交途中被巡检撞见就闭锁整台
* 保护,正是多写者引入的安全级风险。真正的失配(值区与封存对不符且
* 没有提交在飞)仍照常闭锁。
* ⚠ fail-safe:跳过必须**有界**。若写者在 prot_write_enter 之后走进
* 永不返回的路径(锁内提前 return 忘了 exit、钩子死锁、被永久抢占),
* s_seq 会永远停在奇数,而"跳过本轮"会让防篡改自检永久失效且无人察觉
* ——保护静默失去整台闭锁能力。故连撞 PROT_SET_ODD_STREAK_MAX 拍即判
* 闭锁:那时已不是"正在提交",而是写者已死,值区不可信。
*/ */
int prot_set_selfcheck(void) { int prot_set_selfcheck(void) {
uint32_t sum_a = s_sum; uint32_t seq_a = s_seq;
uint32_t calc = prot_sum_buf(s_val[s_act]); uint32_t sum_a;
uint32_t sum_b = s_sum; uint32_t sum_b;
uint32_t seq_b;
uint8_t act_a;
uint8_t act_b;
uint32_t calc;
if (sum_a != sum_b) { if ((seq_a & 1u) != 0u) {
/* 检查期间有 set_sealed/load_raw 提交:快照不一致,本轮跳过 */ if (s_odd_streak < 255u) {
s_odd_streak++;
}
if (s_odd_streak >= (uint8_t)PROT_SET_ODD_STREAK_MAX) {
s_locked = 1u; /* 写者长期停在提交窗口内:值区不可信 → 闭锁 */
}
return (s_locked != 0u) ? -1 : 0;
}
s_odd_streak = 0u; /* 序号已回静止态:宽限期重新开始计 */
sum_a = s_sum;
act_a = s_act; /* 先固定值区:下面的求和只依赖这一个 volatile 读 */
calc = prot_sum_buf(s_val[act_a]);
act_b = s_act;
sum_b = s_sum;
seq_b = s_seq;
if ((seq_a != seq_b) || (sum_a != sum_b) || (act_a != act_b)) {
/* 检查期间有 set_sealed/apply_batch/load_raw 提交:本轮跳过 */
return (s_locked != 0u) ? -1 : 0; return (s_locked != 0u) ? -1 : 0;
} }
if ((calc != sum_a) || (sum_a != ~s_sumn)) { if ((calc != sum_a) || (sum_a != ~s_sumn)) {
@@ -376,22 +618,35 @@ static uint32_t s_get32(const uint8_t *p) {
* 函数功能:把当前值区序列化为 blob(校验和按值区现算,不依赖封存值) * 函数功能:把当前值区序列化为 blob(校验和按值区现算,不依赖封存值)
* 入口参数:p_buf - 输出缓冲;cap - 容量;p_len - 实际长度输出 * 入口参数:p_buf - 输出缓冲;cap - 容量;p_len - 实际长度输出
* 返 回 值:0 / -1 参数非法或容量不足 * 返 回 值:0 / -1 参数非法或容量不足
* 函数说明:落盘是整表字节流,混进两次提交的值就会被原样写进文件、下次开机
* 当合法档案装载回来(校验对是按同一份混合值算的,自洽)。故与
* prot_set_read_batch 同用提交序号做有限次重取:期间有提交即重来。
*/ */
int prot_set_store_serialize(uint8_t *p_buf, uint32_t cap, uint32_t *p_len) { int prot_set_store_serialize(uint8_t *p_buf, uint32_t cap, uint32_t *p_len) {
const uint32_t *vals = s_val[s_act]; uint32_t seq_a = 0u;
uint32_t seq_b;
const volatile uint32_t *vals;
uint32_t sum = 0u; uint32_t sum = 0u;
uint32_t tries = 0u;
uint32_t i; uint32_t i;
if ((p_buf == 0) || (p_len == 0) || (cap < PROT_SET_BLOB_SZ)) { if ((p_buf == 0) || (p_len == 0) || (cap < PROT_SET_BLOB_SZ)) {
return -1; return -1;
} }
do {
seq_a = s_seq;
vals = s_val[s_act];
sum = 0u;
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
s_put32(p_buf + PROT_SET_BLOB_HDR_SZ + 4u * i, vals[i]);
sum += vals[i];
}
seq_b = s_seq;
tries++;
} while ((((seq_a & 1u) != 0u) || (seq_a != seq_b)) && (tries < 3u));
s_put32(p_buf, PROT_SET_BLOB_MAGIC); s_put32(p_buf, PROT_SET_BLOB_MAGIC);
s_put16(p_buf + 4u, (uint16_t)PROT_SET_BLOB_VER); s_put16(p_buf + 4u, (uint16_t)PROT_SET_BLOB_VER);
s_put16(p_buf + 6u, (uint16_t)PS_ID_COUNT); s_put16(p_buf + 6u, (uint16_t)PS_ID_COUNT);
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
s_put32(p_buf + PROT_SET_BLOB_HDR_SZ + 4u * i, vals[i]);
sum += vals[i];
}
s_put32(p_buf + PROT_SET_BLOB_SZ - 8u, sum); s_put32(p_buf + PROT_SET_BLOB_SZ - 8u, sum);
s_put32(p_buf + PROT_SET_BLOB_SZ - 4u, ~sum); s_put32(p_buf + PROT_SET_BLOB_SZ - 4u, ~sum);
*p_len = PROT_SET_BLOB_SZ; *p_len = PROT_SET_BLOB_SZ;
@@ -403,12 +658,15 @@ int prot_set_store_serialize(uint8_t *p_buf, uint32_t cap, uint32_t *p_len) {
* 入口参数:p_buf/len - blob 字节流 * 入口参数:p_buf/len - blob 字节流
* 返 回 值:0 已装载并封存 / -1 拒绝(magic/版本/长度/校验对不符或任一项 * 返 回 值:0 已装载并封存 / -1 拒绝(magic/版本/长度/校验对不符或任一项
* 越界 → 活跃值区一字不动;越界项经 prot_set_bad_mask() 指认) * 越界 → 活跃值区一字不动;越界项经 prot_set_bad_mask() 指认)
* 函数说明:解码/校验全在影子区进行,只有全部通过才交换活跃区—— * 函数说明:校验在写事务之外完成(只读入参字节流,不碰任何 RAM 状态),
* 损坏 blob 不可能污染在用的定值(掉电/写坏/版本换代同一路径)。 * 全部通过才进锁把值写进影子区并交换——损坏 blob 不可能污染在用的
* 定值(掉电/写坏/版本换代同一路径),也不可能在锁内做无用功。
* ⚠ 校验必须**不写影子区**:影子区是与其他写者共享的暂存面,
* 锁外往里写就等于绕过写事务(另一写者的提交会被覆盖)。
*/ */
int prot_set_store_parse(const uint8_t *p_buf, uint32_t len) { int prot_set_store_parse(const uint8_t *p_buf, uint32_t len) {
uint32_t cur_act; uint32_t cur_act;
uint32_t *shadow; volatile uint32_t *shadow;
uint32_t sum = 0u; uint32_t sum = 0u;
uint64_t mask = 0u; uint64_t mask = 0u;
uint32_t i; uint32_t i;
@@ -425,33 +683,37 @@ int prot_set_store_parse(const uint8_t *p_buf, uint32_t len) {
if (s_get16(p_buf + 6u) != (uint16_t)PS_ID_COUNT) { if (s_get16(p_buf + 6u) != (uint16_t)PS_ID_COUNT) {
return -1; return -1;
} }
cur_act = s_act; /* 第一遍:只算和 + 查范围,不落任何 RAM */
shadow = s_val[cur_act ^ 1u];
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) { for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
uint32_t v = s_get32(p_buf + PROT_SET_BLOB_HDR_SZ + 4u * i); uint32_t v = s_get32(p_buf + PROT_SET_BLOB_HDR_SZ + 4u * i);
shadow[i] = v;
sum += v; sum += v;
if (((int32_t)v < g_prot_set_meta[i].min)
|| ((int32_t)v > g_prot_set_meta[i].max)) {
mask |= (1uLL << i);
}
} }
if (sum != s_get32(p_buf + PROT_SET_BLOB_SZ - 8u)) { if (sum != s_get32(p_buf + PROT_SET_BLOB_SZ - 8u)) {
return -1; /* 校验和正码不符(影子区未交换前不可见,无害) */ return -1; /* 校验和正码不符 */
} }
if (~sum != s_get32(p_buf + PROT_SET_BLOB_SZ - 4u)) { if (~sum != s_get32(p_buf + PROT_SET_BLOB_SZ - 4u)) {
return -1; /* 反码对不符 */ return -1; /* 反码对不符 */
} }
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
if (((int32_t)shadow[i] < g_prot_set_meta[i].min)
|| ((int32_t)shadow[i] > g_prot_set_meta[i].max)) {
mask |= (1uLL << i);
}
}
s_bad_mask = mask; s_bad_mask = mask;
if (mask != 0u) { if (mask != 0u) {
return -1; /* 校验对一致但含越界项:同样整表拒绝 */ return -1; /* 校验对一致但含越界项:同样整表拒绝 */
} }
s_sum = sum; /* 第二遍:锁内写入影子区并交换(无提前返回,enter/exit 天然成对) */
s_sumn = ~sum; prot_write_enter();
cur_act = s_act;
shadow = s_val[cur_act ^ 1u];
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
shadow[i] = s_get32(p_buf + PROT_SET_BLOB_HDR_SZ + 4u * i);
}
s_sum = prot_sum_buf(shadow);
s_sumn = ~s_sum;
s_locked = 0u; s_locked = 0u;
s_act = (uint8_t)(cur_act ^ 1u); s_act = (uint8_t)(cur_act ^ 1u);
prot_write_exit();
return 0; return 0;
} }
+91 -8
View File
@@ -13,17 +13,28 @@
* - ⚠ 默认值/范围为**拟定值**:参考 EEPROM 出厂默认表未在本仓库, * - ⚠ 默认值/范围为**拟定值**:参考 EEPROM 出厂默认表未在本仓库,
* 待对照后逐项修订(规划 §10.3 待补项);范围先按 DTU 馈线典型量级。 * 待对照后逐项修订(规划 §10.3 待补项);范围先按 DTU 馈线典型量级。
* *
* 线程约定(B7 定):装载(init/store_parse)在 defaultTask(存储 bring-up, * 线程约定(多写者 + 写事务锁):
* STORAGE_READY 前);单项写在 iec104Task(C_SE/YK12,经 set_sealed 原子路径); * 装载(init/store_parse)在 defaultTask(存储 bring-up);落盘在 defaultTask
* 落盘在 defaultTask(配置引擎属主)。读在保护消费者任务(快照值原子)。 * (配置引擎属主);读在保护消费者任务(快照值原子,读接口一律不加锁)。
* 双缓冲交换 = 单字写,读侧永远看到一致快照;写者之间靠启动时序串行 * 运行时写者有两个——netTask(104 定值下发,走 apply_batch / set_sealed)与
* (装载先于 NET_READY,104 写在其后)。 * uiTask(本地整定,经 ui_data 注入的 set_sealed)。
* 双缓冲 + 单字交换只保证"读侧看到完整快照",**不保证写者之间不交错**:一方
* 已写封存对、尚未交换活跃区时被另一方抢占,后者再交换一次,最终值区与封存
* 对失配 → selfcheck 判"定值被非法改写" → 整台保护闭锁。所以写入口统一走
* 写事务:可选 enter/exit 钩子(prot_set_lock_install 安装,板端接 RTOS 互斥
* 量;模拟器与主机单测不装 = 单写者假设)包住"影子区改值 + 封存 + 交换",
* 同时把提交序号置奇/回偶,selfcheck 借它识别"提交进行中"而不误判失配。
* 跳过本轮是**有界**的:连撞 8 拍仍是奇数 → 判写者已死 → 闭锁(fail-safe,
* 否则一条"锁内提前返回"的 bug 就会让防篡改自检永久静默失效)。
* 本模块只持有两个函数指针,不 include 任何 RTOS/HAL 头——纯逻辑三方编译
* (固件 / 模拟器 / 主机单测)不受影响。
* *
* 创建日期:2026-10-11 * 创建日期:2026-10-11
*/ */
#ifndef PROT_SET_H #ifndef PROT_SET_H
#define PROT_SET_H #define PROT_SET_H
#include <stddef.h> /* size_t(批量接口) */
#include <stdint.h> #include <stdint.h>
/* Q10 定点:工程量 × 1024(与参考 2^10 口径一致)。 /* Q10 定点:工程量 × 1024(与参考 2^10 口径一致)。
@@ -115,8 +126,18 @@ void prot_set_init(void);
*/ */
int prot_set_load_raw(const int32_t *vals); int prot_set_load_raw(const int32_t *vals);
/* 越界位图(bit i = 第 i 项越界;load_raw 失败后有效。B8:项数 32→40, /* 越界位图(bit i = 第 i 项越界)。
* 位图随项数扩为 64 位——消费方仅主机单测,板端闭锁走 prot_set_locked()) */ *
* ⚠ 契约(调用方必读):本函数返回的位图**只反映整表装载/解析**
* (prot_set_load_raw / prot_set_store_parse)的越界结果,
* 最后一次整表操作失败后有效,直到下一次整表操作或 prot_set_init 覆写。
* **不随单项写入(prot_set_set / prot_set_set_sealed)或批量写入
* (prot_set_apply_batch)变化**:增量写入的失败一律以函数返回 -1 表达,
* 既不置位也不清位。
* 推论:一笔成功的批量提交**不会**清掉历史上整表装载留下的越界位;
* 反过来,一笔失败的批量提交也**不会**在位图上留下痕迹。拿位图反显
* "刚才那批哪几项越界"是误用——请用 apply_batch 的返回值。
* B8:项数 32→40,位图随项数扩为 64 位;板端闭锁走 prot_set_locked()。 */
uint64_t prot_set_bad_mask(void); uint64_t prot_set_bad_mask(void);
/* /*
@@ -133,7 +154,11 @@ uint8_t prot_set_get_ctl(prot_set_id_t id); /* 投退项:!=0 视为投入
/* 校验和(定值校验和):sum32 覆盖 RAM 值区;seal 封存正/反码对 */ /* 校验和(定值校验和):sum32 覆盖 RAM 值区;seal 封存正/反码对 */
uint32_t prot_set_checksum(void); uint32_t prot_set_checksum(void);
void prot_set_seal(void); void prot_set_seal(void);
/* 自检:重算并与封存值比对,失配 → 置闭锁并返回 -1(已闭锁也返回 -1) */ /* 自检:重算并与封存值比对,失配 → 置闭锁并返回 -1(已闭锁也返回 -1)。
* 提交进行中(写者正在改值区/发封存对)撞见的中间态**只跳过本轮、不判失配**;
* 但跳过是有界的:连续撞见"提交进行中"达 8 拍(约 160 ms)即视为写者已死,
* 置闭锁并返回 -1(fail-safe:宁可保护停走,不可带不可信定值判据)。
* 解锁的唯一合法路径是 prot_set_seal()(或 prot_set_init() 重装)。 */
int prot_set_selfcheck(void); int prot_set_selfcheck(void);
uint8_t prot_set_locked(void); uint8_t prot_set_locked(void);
@@ -148,6 +173,64 @@ uint8_t prot_set_locked(void);
*/ */
int prot_set_set_sealed(prot_set_id_t id, int32_t q10); int prot_set_set_sealed(prot_set_id_t id, int32_t q10);
/* ---------------- 批量读写(104 定值下发:PRE 预检 + SOL 原子提交) ----------------
* 协议一次改 1..17 项,两段式:第一段只校验(不落任何状态),第二段整批提交。
* 与单项 set_sealed 同一原子口径:任一项非法则整批一项都不改。
*/
/* 一批定值变更(Q10 工程量)。同一批内 id 不得重复。 */
typedef struct {
prot_set_id_t id;
int32_t q10;
} prot_set_change_t;
/* 单批上限 = 整表 40 项(算法侧上限)。超过上限返回 -1,不做任何改动。
* ⚠ 与协议上限的关系:40 是**本模型能接受的最大批量**(整表就 40 项);
* IEC 60870-5-104 参数区另有 **17 项**的消费者上限,那是协议/调用方的
* 约束,由调用方自己拦——本层不代拦。所以 18 项的一批在这里是合法的,
* 接线方若想守 17 项,必须在上层先判,别指望这里替它拒。 */
#define PROT_SET_BATCH_MAX ((size_t)PS_ID_COUNT)
/*
* 函数功能:读一批定值当前值(Q10 工程量)
* 入口参数:ids - 编号数组;n - 个数;out - 输出数组(out[i] 对应 ids[i])
* 返 回 值:0 成功 / -1 参数非法(空指针、n 为 0、n 超过上限、任一号越界)
* 限定条件:任意上下文安全——双缓冲保证读侧只看到完整快照,不需要持锁
*/
int prot_set_read_batch(const prot_set_id_t *ids, size_t n, int32_t *out);
/*
* 函数功能:原子写入一批定值
* 入口参数:changes - 变更数组;n - 个数;validate_only - 非 0 只校验
* 返 回 值:0 整批合法(validate_only 时仅为"预检通过")/ -1 有非法项
* 限定条件:两段式第一段(validate_only 非 0)**零副作用**——不置脏、不动值区、
* 不动闭锁位、不进写事务锁;第二段(validate_only 为 0)先整批校验,
* 任一项非法即一字未改地返回,全部合法才提交并置脏。
* 函数说明:失败条件 = changes 为空、n 为 0、n 超上限、任一号越界、任一值越出
* 该项 min/max、同批 id 重复。提交在写事务锁内完成(见下方钩子)。
* 返 回 值补充(与 prot_set_bad_mask 的关系):**任何失败都不会反映到位图上**
* ——成功也不清、失败也不置。要定位是哪一项不合法,请在调用前自己
* 对照 g_prot_set_meta[id] 的 min/max 逐项查,或改用两段式第一段
* 预检后自行分组重试;位图上看到的内容属于更早的整表装载。
*/
int prot_set_apply_batch(const prot_set_change_t *changes, size_t n, int validate_only);
/* 写事务锁钩子(可选)。未安装 = 调用方保证单写者(模拟器 / 主机单测即如此)。
* enter/exit 必须成对;enter 允许阻塞,不得用关中断实现。 */
typedef struct {
void (*enter)(void);
void (*exit)(void);
} prot_set_lock_t;
/*
* 函数功能:安装/卸载写事务锁
* 入口参数:lock - 钩子(传 NULL = 卸载,退回单写者假设)
* 返 回 值:无
* 限定条件:应在任何写者启动前安装;本函数本身不加锁、不可重入。
* 钩子只在"值区提交"这段临界区里被调用,读接口永不进入。
*/
void prot_set_lock_install(const prot_set_lock_t *lock);
/* 脏标志(存在未落盘的定值改动):set_sealed 置位;load/init 不置 */ /* 脏标志(存在未落盘的定值改动):set_sealed 置位;load/init 不置 */
uint8_t prot_set_dirty_peek(void); /* 非消费(生产者用它通知属主任务) */ uint8_t prot_set_dirty_peek(void); /* 非消费(生产者用它通知属主任务) */
uint8_t prot_set_dirty_take(void); /* 消费(属主任务落盘前取) */ uint8_t prot_set_dirty_take(void); /* 消费(属主任务落盘前取) */
+57
View File
@@ -7,11 +7,15 @@
* 原子写临时名由 cfg_store_write_atomic 按目标目录推导 * 原子写临时名由 cfg_store_write_atomic 按目标目录推导
* (固定 config.TMP),与 /config.ini 的保存同在 defaultTask * (固定 config.TMP),与 /config.ini 的保存同在 defaultTask
* 串行执行,无并发竞争。 * 串行执行,无并发竞争。
* 本文件同时是 prot_set 写事务互斥钩子的平台胶水:内核启动后由
* defaultTask 安装 osMutex,netTask 的 104 整定写与本地整定共用
* 同一把锁,保证“取影子—改—封存—切区”全程互斥。
* 创建日期:2026-10-12(B7) * 创建日期:2026-10-12(B7)
*/ */
#include "prot_set_store.h" #include "prot_set_store.h"
#include <stddef.h> #include <stddef.h>
#include "cmsis_os2.h"
#define DBG_TAG "[CFG]" #define DBG_TAG "[CFG]"
#include "dbg_log.h" #include "dbg_log.h"
@@ -25,6 +29,59 @@
* B8 定值表 32→40 项 → blob 144→176 B,随 PROT_SET_BLOB_SZ 自动适配) */ * B8 定值表 32→40 项 → blob 144→176 B,随 PROT_SET_BLOB_SZ 自动适配) */
static uint8_t s_blob[PROT_SET_BLOB_SZ]; static uint8_t s_blob[PROT_SET_BLOB_SZ];
/* prot_set 写事务钩子:未安装时 enter/exit 都是空操作,保持单任务构建可用。 */
static osMutexId_t s_prot_set_mutex;
/*
* 函数功能:进入 prot_set 写事务(拿互斥)
* 入口参数:无
* 返 回 值:无
* 函数说明:未安装互斥时为空操作,退化为单写者行为;
* 不得在中断上下文调用(osWaitForever 会阻塞)。
*/
static void s_prot_set_lock_enter(void)
{
if (s_prot_set_mutex != NULL) {
(void)osMutexAcquire(s_prot_set_mutex, osWaitForever);
}
}
/*
* 函数功能:退出 prot_set 写事务(放互斥)
* 入口参数:无
* 返 回 值:无
* 函数说明:与 s_prot_set_lock_enter 成对出现,未安装互斥时为空操作。
*/
static void s_prot_set_lock_exit(void)
{
if (s_prot_set_mutex != NULL) {
(void)osMutexRelease(s_prot_set_mutex);
}
}
/*
* 函数功能:安装 prot_set 写事务互斥(幂等)
* 入口参数:无
* 返 回 值:0 已安装或重复调用 / -1 创建失败(无锁降级)
* 函数说明:仅在内核启动后的 defaultTask 上下文调用;创建失败时不安装钩子,
* 写事务退化为无锁(单写者时代的行为),不把启动拖死。
*/
int prot_set_store_lock_init(void)
{
static const prot_set_lock_t lock = { s_prot_set_lock_enter, s_prot_set_lock_exit };
osMutexId_t mutex;
if (s_prot_set_mutex != NULL) { return 0; }
mutex = osMutexNew(NULL);
if (mutex == NULL) {
DBG_ERROR("prot set lock create failed, no-lock fallback");
return -1;
}
s_prot_set_mutex = mutex;
prot_set_lock_install(&lock);
return 0;
}
/* /*
* 函数功能:从小端缓冲读 16 位值(仅头部判别用,与 prot_set.c 内部同字节序) * 函数功能:从小端缓冲读 16 位值(仅头部判别用,与 prot_set.c 内部同字节序)
* 入口参数:p - 读位置 * 入口参数:p - 读位置
+8
View File
@@ -28,4 +28,12 @@ int prot_set_store_load(void);
*/ */
int prot_set_store_save(void); int prot_set_store_save(void);
/*
* 函数功能:安装 prot_set 写事务的跨任务互斥(幂等)
* 返回值:0 - 已安装或重复调用;-1 - 内核对象创建失败(保持无锁降级)
* 限定条件:必须在内核启动后、首个运行时写者之前调用一次
* (defaultTask 存储 bring-up);内核前调用会直接拉死启动。
*/
int prot_set_store_lock_init(void);
#endif /* PROT_SET_STORE_H */ #endif /* PROT_SET_STORE_H */
+44 -23
View File
@@ -6,6 +6,26 @@
typedef char profile_sp_count[(DTU_SIGNAL_COUNT == IEC104_DTU_SP_COUNT) ? 1 : -1]; typedef char profile_sp_count[(DTU_SIGNAL_COUNT == IEC104_DTU_SP_COUNT) ? 1 : -1];
typedef char profile_me_count[(DTU_MEASUREMENT_COUNT == IEC104_DTU_ME_COUNT) ? 1 : -1]; typedef char profile_me_count[(DTU_MEASUREMENT_COUNT == IEC104_DTU_ME_COUNT) ? 1 : -1];
typedef char profile_param_count[(DTU_PARAMETER_COUNT == IEC104_DTU_PARAMETER_COUNT) ? 1 : -1]; typedef char profile_param_count[(DTU_PARAMETER_COUNT == IEC104_DTU_PARAMETER_COUNT) ? 1 : -1];
/* Authorized consumer semantic bridge; activated by iec104_serv bindings on MCU. No mapping for alarm-enable (not overall enable),
* low-frequency blocking (not underfrequency trip), zero drift (not ADC offset),
* or remote-control permission (not protection global enable).
* Existing model IDs 0..39 are stable persistent IDs; COUNT is not a parameter.
* PT1 and phase-CT refer to the one existing feeder, secondary units A/V.
* Other phases/bays MUST NOT silently share these IDs.
* This is the entire accepted consumer set: every other profile row is refused. */
static const struct { uint16_t ioa, id; float scale; } s_consumer_map[] = {
{0x8841U, 1U, 1.0f}, {0x8842U, 2U, 1.0f}, {0x8843U, 3U, 1000.0f},
{0x8845U, 5U, 1.0f}, {0x8846U, 6U, 1.0f}, {0x8847U, 7U, 1000.0f},
{0x8849U, 9U, 1.0f}, {0x884aU, 10U, 1.0f}, {0x884bU, 11U, 1000.0f},
{0x8027U, 20U, 1.0f}, {0x8028U, 21U, 1000.0f},
{0x8029U, 17U, 1.0f}, {0x802aU, 18U, 1000.0f},
{0x8024U, 27U, 1000.0f}, {0x8025U, 28U, 1.0f},
{0x8040U, 29U, 1.0f}, {0x8041U, 30U, 1.0f}
/* 8046/8047 are load-limit alarms, not the existing overload trip
* model. Do not map those by a superficially similar threshold. */
};
typedef char consumer_map_count[
(sizeof(s_consumer_map) / sizeof(s_consumer_map[0]) == IEC104_DTU_CONSUMER_COUNT) ? 1 : -1];
/* 函数功能:按稳定索引查询标准监视点元数据。 */ /* 函数功能:按稳定索引查询标准监视点元数据。 */
bool iec104_dtu_point(size_t index, iec104_dtu_point_t *out) bool iec104_dtu_point(size_t index, iec104_dtu_point_t *out)
{ {
@@ -57,37 +77,38 @@ size_t iec104_dtu_parameter_index(uint32_t ioa)
} }
return i; return i;
} }
/* 函数功能:依据原表配置状态和区域判定参数可见性。 */ /* 函数功能:依据消费集合与区域判定参数可见性。 */
bool iec104_dtu_parameter_visible(size_t index, uint16_t area) bool iec104_dtu_parameter_visible(size_t index, uint16_t area)
{ {
iec104_dtu_parameter_t p; iec104_dtu_parameter_t p; uint16_t id; float scale;
return area < IEC104_DTU_AREA_COUNT && iec104_dtu_parameter(index, &p) && return area < IEC104_DTU_AREA_COUNT && iec104_dtu_parameter(index, &p) &&
p.configured && (area == 0U || p.area_scoped); p.configured && (area == 0U || p.area_scoped) &&
iec104_dtu_protection_mapping(p.ioa, &id, &scale);
} }
/* Candidate semantic bridge, not an activated platform binding. No mapping for alarm-enable (not overall enable), /* 函数功能:把可见消费者索引换算成密集槽位;非消费者返回无槽位。
* low-frequency blocking (not underfrequency trip), zero drift (not ADC offset), * area_zero 非 0 = SN0 全体 17 项排名;为 0 = 区域 1..4 的 9 项局部排名。 */
* or remote-control permission (not protection global enable). uint16_t iec104_dtu_parameter_rank(size_t index, uint8_t area_zero)
* Existing model IDs 0..39 are stable persistent IDs; COUNT is not a parameter. {
* PT1 and phase-CT refer to the one existing feeder, secondary units A/V. iec104_dtu_parameter_t p; uint16_t rank = 0U; size_t i;
* Other phases/bays MUST NOT silently share these IDs. */ if (!iec104_dtu_parameter_visible(index, area_zero != 0U ? 0U : 1U) ||
/* 函数功能:查询未激活的候选语义桥及单位比例。 */ !iec104_dtu_parameter(index, &p)) { return IEC104_DTU_NO_RANK; }
for (i = 0U; i < IEC104_DTU_CONSUMER_COUNT; ++i) {
uint32_t ioa = s_consumer_map[i].ioa;
if (area_zero == 0U && !(ioa >= 0x8820U && ioa <= 0x88ffU)) { continue; }
if (ioa == p.ioa) { return rank; }
++rank;
}
return IEC104_DTU_NO_RANK;
}
/* 函数功能:查询真实消费者的语义桥及单位比例。 */
bool iec104_dtu_protection_mapping(uint32_t ioa, uint16_t *id, float *source_scale) bool iec104_dtu_protection_mapping(uint32_t ioa, uint16_t *id, float *source_scale)
{ {
static const struct { uint16_t ioa, id; float scale; } map[] = {
{0x8841U, 1U, 1.0f}, {0x8842U, 2U, 1.0f}, {0x8843U, 3U, 1000.0f},
{0x8845U, 5U, 1.0f}, {0x8846U, 6U, 1.0f}, {0x8847U, 7U, 1000.0f},
{0x8849U, 9U, 1.0f}, {0x884aU, 10U, 1.0f}, {0x884bU, 11U, 1000.0f},
{0x8027U, 20U, 1.0f}, {0x8028U, 21U, 1000.0f},
{0x8029U, 17U, 1.0f}, {0x802aU, 18U, 1000.0f},
{0x8024U, 27U, 1000.0f}, {0x8025U, 28U, 1.0f},
{0x8040U, 29U, 1.0f}, {0x8041U, 30U, 1.0f}
/* 8046/8047 are load-limit alarms, not the existing overload trip
* model. Do not map those by a superficially similar threshold. */
};
size_t i; size_t i;
if (id == NULL || source_scale == NULL) { return false; } if (id == NULL || source_scale == NULL) { return false; }
for (i = 0U; i < sizeof(map) / sizeof(map[0]); ++i) { for (i = 0U; i < sizeof(s_consumer_map) / sizeof(s_consumer_map[0]); ++i) {
if (map[i].ioa == ioa) { *id = map[i].id; *source_scale = map[i].scale; return true; } if (s_consumer_map[i].ioa == ioa) {
*id = s_consumer_map[i].id; *source_scale = s_consumer_map[i].scale; return true;
}
} }
return false; return false;
} }
+6
View File
@@ -10,6 +10,9 @@
#define IEC104_DTU_ME_COUNT 30U #define IEC104_DTU_ME_COUNT 30U
#define IEC104_DTU_ENERGY_COUNT 8U #define IEC104_DTU_ENERGY_COUNT 8U
#define IEC104_DTU_PARAMETER_COUNT 430U #define IEC104_DTU_PARAMETER_COUNT 430U
#define IEC104_DTU_CONSUMER_COUNT 17U
#define IEC104_DTU_SCOPED_CONSUMER_COUNT 9U
#define IEC104_DTU_NO_RANK 0xFFFFU
#define IEC104_DTU_STANDARD_COUNT 120U #define IEC104_DTU_STANDARD_COUNT 120U
#define IEC104_DTU_COMMAND_COUNT 65U #define IEC104_DTU_COMMAND_COUNT 65U
#define IEC104_DTU_AREA_COUNT 5U #define IEC104_DTU_AREA_COUNT 5U
@@ -31,6 +34,9 @@ typedef struct {
bool iec104_dtu_point(size_t index, iec104_dtu_point_t *out); bool iec104_dtu_point(size_t index, iec104_dtu_point_t *out);
bool iec104_dtu_parameter(size_t index, iec104_dtu_parameter_t *out); bool iec104_dtu_parameter(size_t index, iec104_dtu_parameter_t *out);
size_t iec104_dtu_parameter_index(uint32_t ioa); size_t iec104_dtu_parameter_index(uint32_t ioa);
/* Returns a dense rank for a visible consumer, or IEC104_DTU_NO_RANK.
* area_zero selects the SN0 value slot; otherwise rank is within one scoped area. */
uint16_t iec104_dtu_parameter_rank(size_t index, uint8_t area_zero);
bool iec104_dtu_parameter_visible(size_t index, uint16_t area); bool iec104_dtu_parameter_visible(size_t index, uint16_t area);
/* IDs are existing prot_set_id_t values, not legacy communication addresses. /* IDs are existing prot_set_id_t values, not legacy communication addresses.
* wire_value * source_scale = source engineering value. */ * wire_value * source_scale = source engineering value. */
+24 -21
View File
@@ -14,14 +14,15 @@
* - 预置(PRE/SOL)与标准参数装载:显式拒绝并计数,不静默丢弃。 * - 预置(PRE/SOL)与标准参数装载:显式拒绝并计数,不静默丢弃。
* 全功能档(模拟器/产品默认面)不受影响。 */ * 全功能档(模拟器/产品默认面)不受影响。 */
#ifndef IEC104_SOURCE_NO_VALUE_STORE #ifndef IEC104_SOURCE_NO_VALUE_STORE
/* 槽位密集化(包 B):rank 表把"索引 -> 槽位"从循环换算改成 O(1) 查表。 /* 消费者收窄:只保留 17 个真实消费者的值/预置槽位。
* values 只保留真实可见的槽(configured 345 + area_scoped 88 x 4 区 = 697), * SN0 全体 17 个;SN1..4 各 9 个区域消费者,合计 53 个值槽;
* staged/dirty 只保留可写参数(writable 264),省 1025B RAM,代价 2580B Flash。 */ * staged/dirty 覆盖同一 17 项,对应 68B + 3B RAM。 */
#include "iec104_source_ranks.h" #define VALUE_SLOTS (IEC104_DTU_CONSUMER_COUNT + 4U * IEC104_DTU_SCOPED_CONSUMER_COUNT)
#define VALUE_SLOTS IEC104_SOURCE_VALUE_SLOTS #define STAGE_SLOTS IEC104_DTU_CONSUMER_COUNT
#define DIRTY_BYTES ((STAGE_SLOTS + 7U) / 8U)
static uint32_t values[VALUE_SLOTS]; static uint32_t values[VALUE_SLOTS];
static uint32_t staged[IEC104_SOURCE_STAGE_SLOTS]; static uint32_t staged[STAGE_SLOTS];
static uint8_t dirty[IEC104_SOURCE_DIRTY_BYTES]; static uint8_t dirty[DIRTY_BYTES];
#endif #endif
static IEC104_RemoteParameterRequest_t owner; static IEC104_RemoteParameterRequest_t owner;
static bool stage_active, stage_complete; static bool stage_active, stage_complete;
@@ -40,7 +41,7 @@ static IEC104_ParameterPoint_t standard_points[IEC104_DTU_STANDARD_COUNT];
static IEC104_ParameterValue_t standard_values[IEC104_DTU_STANDARD_COUNT]; static IEC104_ParameterValue_t standard_values[IEC104_DTU_STANDARD_COUNT];
static uint64_t clock_utc, clock_mono; static uint64_t clock_utc, clock_mono;
#ifndef IEC104_SOURCE_NO_VALUE_STORE #ifndef IEC104_SOURCE_NO_VALUE_STORE
static iec104_source_change_t changes[17]; static iec104_source_change_t changes[IEC104_DTU_CONSUMER_COUNT];
#endif #endif
static void increment(uint32_t *value) { if (*value != UINT32_MAX) { ++*value; } } static void increment(uint32_t *value) { if (*value != UINT32_MAX) { ++*value; } }
static uint32_t float_bits(float v) { uint32_t b; memcpy(&b, &v, 4U); return b; } static uint32_t float_bits(float v) { uint32_t b; memcpy(&b, &v, 4U); return b; }
@@ -51,11 +52,10 @@ static float bits_float(uint32_t b) { float v; memcpy(&v, &b, 4U); return v; }
#ifndef IEC104_SOURCE_NO_VALUE_STORE #ifndef IEC104_SOURCE_NO_VALUE_STORE
static size_t slot(size_t index, uint16_t area) static size_t slot(size_t index, uint16_t area)
{ {
uint16_t r; uint16_t r = iec104_dtu_parameter_rank(index, area == 0U ? 1U : 0U);
if (area == 0U) { return iec104_source_value_rank[index]; } if (r == IEC104_DTU_NO_RANK) { return 0U; } /* caller only passes visible consumers */
r = iec104_source_scope_rank[index]; return area == 0U ? (size_t)r :
if (r == IEC104_SOURCE_STAGE_NO_RANK) { r = 0U; } (size_t)IEC104_DTU_CONSUMER_COUNT + (size_t)(area - 1U) * (size_t)IEC104_DTU_SCOPED_CONSUMER_COUNT + (size_t)r;
return IEC104_SOURCE_CONFIGURED_TOTAL + (size_t)(area - 1U) * (size_t)IEC104_SOURCE_SCOPED_TOTAL + (size_t)r;
} }
/* 裁剪档无压缩槽位表,slot() 不参与编译。 */ /* 裁剪档无压缩槽位表,slot() 不参与编译。 */
#endif #endif
@@ -80,12 +80,16 @@ static bool same_owner(const IEC104_RemoteParameterRequest_t *r)
/* 函数功能:判定参数是否处于已预置未固化状态(按 stage_rank 映射到位)。 */ /* 函数功能:判定参数是否处于已预置未固化状态(按 stage_rank 映射到位)。 */
static bool is_dirty(size_t i) static bool is_dirty(size_t i)
{ {
uint16_t r = iec104_source_stage_rank[i]; uint16_t r = iec104_dtu_parameter_rank(i, 1U);
if (r == IEC104_SOURCE_STAGE_NO_RANK) { return false; } if (r == IEC104_DTU_NO_RANK) { return false; }
return (dirty[r >> 3] & (1U << (r & 7U))) != 0U; return (dirty[r >> 3] & (1U << (r & 7U))) != 0U;
} }
/* 函数功能:把参数索引换算成 staged/dirty 的密集槽位。 */ /* 函数功能:把参数索引换算成 staged/dirty 的密集槽位。 */
static size_t stage_slot(size_t i) { return (size_t)iec104_source_stage_rank[i]; } static size_t stage_slot(size_t i)
{
uint16_t r = iec104_dtu_parameter_rank(i, 1U);
return r == IEC104_DTU_NO_RANK ? 0U : (size_t)r;
}
#endif #endif
/* 函数功能:判定参数是否由完整的真实源回调对负责。 */ /* 函数功能:判定参数是否由完整的真实源回调对负责。 */
static bool mapped(const iec104_dtu_parameter_t *p, uint16_t area, uint16_t *id, float *scale) static bool mapped(const iec104_dtu_parameter_t *p, uint16_t area, uint16_t *id, float *scale)
@@ -123,7 +127,8 @@ static bool read_bits(size_t index, uint16_t area, uint32_t *out)
static bool valid_bits(size_t index, uint32_t raw) static bool valid_bits(size_t index, uint32_t raw)
{ {
iec104_dtu_parameter_t p; double v; iec104_dtu_parameter_t p; double v;
if (!iec104_dtu_parameter(index, &p) || !p.writable) { return false; } if (!iec104_dtu_parameter(index, &p) || !p.writable ||
iec104_dtu_parameter_rank(index, 1U) == IEC104_DTU_NO_RANK) { return false; }
v = p.tag == 38U ? (double)bits_float(raw) : (double)raw; v = p.tag == 38U ? (double)bits_float(raw) : (double)raw;
if (!(v >= 0.0)) { return false; } if (!(v >= 0.0)) { return false; }
if ((p.tag == 1U && raw > 1U) || (p.tag == 45U && raw > 65535U) || if ((p.tag == 1U && raw > 1U) || (p.tag == 45U && raw > 65535U) ||
@@ -149,9 +154,7 @@ static bool candidate(uint32_t ioa, uint16_t area, float *out)
static bool commit_stage(uint16_t area) static bool commit_stage(uint16_t area)
{ {
size_t i, n = 0U; iec104_dtu_parameter_t p; uint16_t id; float scale; size_t i, n = 0U; iec104_dtu_parameter_t p; uint16_t id; float scale;
float high, low, residual; float high, low;
if (!candidate(0x8833U, area, &high) || !candidate(0x8834U, area, &low) ||
!candidate(0x8835U, area, &residual) || high < low || low < residual) { return false; }
if (area == 0U && (!candidate(0x8027U, 0U, &low) || if (area == 0U && (!candidate(0x8027U, 0U, &low) ||
!candidate(0x8029U, 0U, &high) || low > high)) { return false; } !candidate(0x8029U, 0U, &high) || low > high)) { return false; }
for (i = 0U; i < IEC104_DTU_PARAMETER_COUNT; ++i) { for (i = 0U; i < IEC104_DTU_PARAMETER_COUNT; ++i) {
@@ -190,7 +193,7 @@ void iec104_source_init(void)
memset(values, 0, sizeof(values)); memset(values, 0, sizeof(values));
for (i = 0U; i < IEC104_DTU_PARAMETER_COUNT; ++i) { for (i = 0U; i < IEC104_DTU_PARAMETER_COUNT; ++i) {
(void)iec104_dtu_parameter(i, &p); (void)iec104_dtu_parameter(i, &p);
if (!p.configured) { continue; } if (!p.configured || !iec104_dtu_parameter_visible(i, 0U)) { continue; }
raw = initial_bits(&p); raw = initial_bits(&p);
for (a = 0U; a < IEC104_DTU_AREA_COUNT; ++a) { for (a = 0U; a < IEC104_DTU_AREA_COUNT; ++a) {
if (iec104_dtu_parameter_visible(i, (uint16_t)a)) { values[slot(i, (uint16_t)a)] = raw; } if (iec104_dtu_parameter_visible(i, (uint16_t)a)) { values[slot(i, (uint16_t)a)] = raw; }
+2 -2
View File
@@ -21,8 +21,8 @@ typedef union {
IEC60870_BitString32_t bits; IEC60870_BitString32_t bits;
IEC60870_IntegratedTotalsShort_t energy; IEC60870_IntegratedTotalsShort_t energy;
} iec104_source_object_t; } iec104_source_object_t;
/* All 345 visible profile entries have numeric tags 1/35/38/45 and width <=4. /* The 17 accepted consumer entries have numeric tags 1/38 and width <=4.
* Tag4 metadata remains unconfigured and invisible, never silently truncated. */ * Every other profile row is refused, never silently truncated. */
typedef struct { uint8_t tag, length, bytes[4]; } iec104_source_value_t; typedef struct { uint8_t tag, length, bytes[4]; } iec104_source_value_t;
typedef struct { uint16_t id; float value; } iec104_source_change_t; typedef struct { uint16_t id; float value; } iec104_source_change_t;
/* All callbacks run serially in the protocol owner. NULL means unavailable. /* All callbacks run serially in the protocol owner. NULL means unavailable.
-202
View File
@@ -1,202 +0,0 @@
/* 模块名称:参数值槽 rank 映射表(生成文件,勿手改)。 */
/* GENERATED FILE - do not edit by hand.
* Source: App/iec60870/104/iec104_dtu_profile.h (const profile table).
* Generator: ci-artifacts/iec104-cutover/gen_source_ranks.py
* Design: ci-artifacts/iec104-cutover/package-b-design.md
* Include exactly once, from App/iec60870/104/iec104_source.c only.
*
* Ranks are uint16_t because the largest rank is 344 (configured) / 263 (writable),
* both above 0xFF. A uint8_t table would alias sentinel 0xFF with rank 255 and
* silently mis-map one parameter, so uint8_t is not an option here.
*/
#ifndef IEC104_SOURCE_RANKS_H
#define IEC104_SOURCE_RANKS_H
#include <stdint.h>
#define IEC104_SOURCE_CONFIGURED_TOTAL 345U
#define IEC104_SOURCE_SCOPED_TOTAL 88U
#define IEC104_SOURCE_WRITABLE_TOTAL 264U
#define IEC104_SOURCE_STAGE_NO_RANK 0xFFFFU
/* Dense value slots: configured in area 0, area_scoped in areas 1..4. */
#define IEC104_SOURCE_VALUE_SLOTS \
(IEC104_SOURCE_CONFIGURED_TOTAL + 4U * IEC104_SOURCE_SCOPED_TOTAL)
#define IEC104_SOURCE_STAGE_SLOTS IEC104_SOURCE_WRITABLE_TOTAL
#define IEC104_SOURCE_DIRTY_BYTES ((IEC104_SOURCE_WRITABLE_TOTAL + 7U) / 8U)
/* rank among configured parameters -> area-0 value slot (0xFFFF = not visible) */
static const uint16_t iec104_source_value_rank[430] = {
0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U,
8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U,
16U, 17U, 18U, 19U, 20U, 21U, 22U, 23U,
24U, 25U, 26U, 27U, 28U, 29U, 30U, 31U,
32U, 33U, 34U, 35U, 36U, 37U, 38U, 39U,
40U, 41U, 42U, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 43U, 44U, 45U, 46U, 47U, 48U, 49U,
50U, 51U, 52U, 53U, 54U, 55U, 56U, 57U,
58U, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 59U,
60U, 61U, 62U, 63U, 64U, 65U, 66U, 67U,
68U, 69U, 70U, 71U, 72U, 73U, 74U, 75U,
76U, 77U, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 78U, 79U,
80U, 81U, 82U, 83U, 84U, 85U, 86U, 87U,
88U, 89U, 90U, 91U, 92U, 93U, 94U, 95U,
96U, 97U, 98U, 99U, 100U, 101U, 102U, 103U,
104U, 105U, 106U, 107U, 108U, 109U, 110U, 111U,
112U, 113U, 114U, 115U, 116U, 117U, 118U, 119U,
120U, 121U, 122U, 123U, 124U, 125U, 126U, 127U,
128U, 129U, 130U, 131U, 132U, 133U, 134U, 135U,
136U, 137U, 138U, 139U, 140U, 141U, 142U, 143U,
144U, 145U, 146U, 147U, 148U, 149U, 150U, 151U,
152U, 153U, 154U, 155U, 156U, 157U, 158U, 159U,
160U, 161U, 162U, 163U, 164U, 165U, 166U, 167U,
168U, 169U, 170U, 171U, 172U, 173U, 174U, 175U,
176U, 177U, 178U, 179U, 180U, 181U, 182U, 183U,
184U, 185U, 186U, 187U, 188U, 189U, 190U, 191U,
192U, 193U, 194U, 195U, 196U, 197U, 198U, 199U,
200U, 201U, 202U, 203U, 204U, 205U, 206U, 207U,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 208U, 209U, 210U,
211U, 212U, 213U, 214U, 215U, 216U, 217U, 218U,
219U, 220U, 221U, 222U, 223U, 224U, 225U, 226U,
227U, 228U, 229U, 230U, 231U, 232U, 233U, 234U,
235U, 236U, 237U, 238U, 239U, 240U, 241U, 242U,
243U, 244U, 245U, 246U, 247U, 248U, 249U, 250U,
251U, 252U, 253U, 254U, 255U, 256U, 257U, 258U,
259U, 260U, 261U, 262U, 263U, 264U, 265U, 266U,
267U, 268U, 269U, 270U, 271U, 272U, 273U, 274U,
275U, 276U, 277U, 278U, 279U, 280U, 281U, 282U,
283U, 284U, 285U, 286U, 287U, 288U, 289U, 290U,
291U, 292U, 293U, 294U, 295U, 296U, 297U, 298U,
299U, 300U, 301U, 302U, 303U, 304U, 305U, 306U,
307U, 308U, 309U, 310U, 311U, 312U, 313U, 314U,
315U, 316U, 317U, 318U, 319U, 320U, 321U, 322U,
323U, 324U, 325U, 326U, 327U, 328U, 329U, 330U,
331U, 332U, 333U, 334U, 335U, 336U, 337U, 338U,
339U, 340U, 341U, 342U, 343U, 344U,
};
/* rank among area_scoped parameters -> offset inside one area bank */
static const uint16_t iec104_source_scope_rank[430] = {
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0U, 1U,
2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U,
10U, 11U, 12U, 13U, 14U, 15U, 16U, 17U,
18U, 19U, 20U, 21U, 22U, 23U, 24U, 25U,
26U, 27U, 28U, 29U, 30U, 31U, 32U, 33U,
34U, 35U, 36U, 37U, 38U, 39U, 40U, 41U,
42U, 43U, 44U, 45U, 46U, 47U, 48U, 49U,
50U, 51U, 52U, 53U, 54U, 55U, 56U, 57U,
58U, 59U, 60U, 61U, 62U, 63U, 64U, 65U,
66U, 67U, 68U, 69U, 70U, 71U, 72U, 73U,
74U, 75U, 76U, 77U, 78U, 79U, 80U, 81U,
82U, 83U, 84U, 85U, 86U, 87U, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
};
/* rank among writable parameters -> staged[] slot and dirty bit index */
static const uint16_t iec104_source_stage_rank[430] = {
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0U, 1U,
2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U,
10U, 11U, 12U, 13U, 14U, 15U, 16U, 17U,
18U, 19U, 20U, 21U, 22U, 23U, 24U, 25U,
26U, 27U, 28U, 29U, 30U, 31U, 32U, 33U,
34U, 35U, 36U, 37U, 38U, 39U, 40U, 41U,
42U, 43U, 44U, 45U, 46U, 47U, 48U, 49U,
50U, 51U, 52U, 53U, 54U, 55U, 56U, 57U,
58U, 59U, 60U, 61U, 62U, 63U, 64U, 65U,
66U, 67U, 68U, 69U, 70U, 71U, 72U, 73U,
74U, 75U, 76U, 77U, 78U, 79U, 80U, 81U,
82U, 83U, 84U, 85U, 86U, 87U, 88U, 89U,
90U, 91U, 92U, 93U, 94U, 95U, 96U, 97U,
98U, 99U, 100U, 101U, 102U, 103U, 104U, 105U,
106U, 107U, 108U, 109U, 110U, 111U, 112U, 113U,
114U, 115U, 116U, 117U, 118U, 119U, 120U, 121U,
122U, 123U, 124U, 125U, 126U, 127U, 128U, 129U,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU,
130U, 131U, 132U, 133U, 134U, 135U, 136U, 137U,
138U, 139U, 140U, 141U, 142U, 143U, 144U, 145U,
146U, 147U, 148U, 149U, 150U, 151U, 152U, 153U,
154U, 155U, 156U, 157U, 158U, 159U, 160U, 161U,
162U, 163U, 164U, 165U, 166U, 167U, 168U, 169U,
170U, 171U, 172U, 173U, 174U, 175U, 176U, 177U,
178U, 179U, 180U, 181U, 182U, 183U, 184U, 185U,
186U, 187U, 188U, 189U, 190U, 191U, 192U, 193U,
194U, 195U, 196U, 197U, 198U, 199U, 200U, 201U,
202U, 203U, 204U, 205U, 206U, 207U, 208U, 209U,
210U, 211U, 212U, 213U, 214U, 215U, 216U, 217U,
218U, 219U, 220U, 221U, 222U, 223U, 224U, 225U,
226U, 227U, 228U, 229U, 230U, 231U, 232U, 233U,
234U, 235U, 236U, 237U, 238U, 239U, 240U, 241U,
242U, 243U, 244U, 245U, 246U, 247U, 248U, 249U,
250U, 251U, 252U, 253U, 254U, 255U, 256U, 257U,
258U, 259U, 260U, 261U, 262U, 263U,
};
#endif /* IEC104_SOURCE_RANKS_H */
+5
View File
@@ -544,6 +544,11 @@ static FRESULT storage_bring_up(FATFS *fs) {
* 操作受 STORAGE_READY 屏障门控,屏障在本函数末尾才置位,时序天然安全 */ * 操作受 STORAGE_READY 屏障门控,屏障在本函数末尾才置位,时序天然安全 */
(void)vol_lock_init(); (void)vol_lock_init();
/* prot_set 写事务跨任务锁:必须在内核启动后安装(kernel 前调用
* osMutexNew 会拉死启动),且早于 STORAGE_READY/NET_READY 的任何
* 104 远程整定或本地整定写者。创建失败保持无锁降级,不阻断存储启动。 */
(void)prot_set_store_lock_init();
fr = f_mount(fs, "", 1); fr = f_mount(fs, "", 1);
if (fr == FR_NO_FILESYSTEM) { if (fr == FR_NO_FILESYSTEM) {
+42 -5
View File
@@ -23,7 +23,7 @@
#include "adc_cal.h" /* 标定有效性:adc_cal_flags() 未标定闭锁判据 */ #include "adc_cal.h" /* 标定有效性:adc_cal_flags() 未标定闭锁判据 */
#include "ioboard_di.h" /* 开入快照读口(TODO 段预留,当前 s_signal 恒 false) */ #include "ioboard_di.h" /* 开入快照读口(TODO 段预留,当前 s_signal 恒 false) */
#include "net_socket.h" /* net_get_generation():网络代次自愈 */ #include "net_socket.h" /* net_get_generation():网络代次自愈 */
#include "prot_set.h" /* 定值脏标志 peek(B7 落盘通知) */ #include "prot_set.h" /* 定值语义读、批量写事务与脏标志 peek(B7 落盘通知) */
#include "run_par.h" /* 运行参数脏 peek(运行参数段落盘通知) */ #include "run_par.h" /* 运行参数脏 peek(运行参数段落盘通知) */
#include "sys_events.h" #include "sys_events.h"
#include "task_watchdog.h" #include "task_watchdog.h"
@@ -150,6 +150,43 @@ static bool s_signal(void *ctx, uint16_t source_addr, uint8_t *value, uint8_t *q
return false; return false;
} }
/* 函数功能:104 定值源回调,按语义 ID 从 prot_set 实时读 Q10 工程量。
* 入口参数:ctx - 未用;id - 语义编号(保护映射表保证有效);value - 输出值
* 返回值:true = 读到;false = 语义号越界或模型读失败
* 限定条件:仅 netTask(core poll 串行调用);禁止任何配置 I/O 或阻塞
* 函数说明:ID 先按 PS_ID_COUNT 复核,再走 prot_set 的无锁一致读;
* 比例换算仍由 source 层按参数表的 source_scale 完成。 */
static bool s_parameter_read(void *ctx, uint16_t id, float *value)
{
(void)ctx;
if (value == NULL || id >= (uint16_t)PS_ID_COUNT) { return false; }
*value = prot_set_get_f((prot_set_id_t)id);
return true;
}
/* 函数功能:104 定值整批 apply 回调,把语义变更翻译成 prot_set 原子事务。
* 入口参数:ctx - 未用;v/n - 变更数组;validate_only - 只校验不提交
* 返回值:true = 整批合法(校验阶段零副作用);false = 任一项越界/非法
* 限定条件:仅 netTask(core poll 串行调用);禁止逐项写和阻塞等待
* 函数说明:先拒空批与超过 17 项消费者上限的批次;栈上 17×8=136 B 的
* prot_set_change_t 在 netTask 960 words 栈预算内可控;Q10 量化后
* 交给 prot_set_apply_batch 一次提交,校验/提交两阶段由 source 层调用。 */
static bool s_parameter_apply(void *ctx, const iec104_source_change_t *v,
size_t n, bool validate_only)
{
prot_set_change_t batch[IEC104_DTU_CONSUMER_COUNT];
size_t i;
(void)ctx;
if (v == NULL || n == 0U || n > IEC104_DTU_CONSUMER_COUNT) { return false; }
for (i = 0U; i < n; ++i) {
if (v[i].id >= (uint16_t)PS_ID_COUNT) { return false; }
batch[i].id = (prot_set_id_t)v[i].id;
batch[i].q10 = PROT_SET_Q10(v[i].value);
}
return prot_set_apply_batch(batch, n, validate_only ? 1 : 0) == 0;
}
/* 函数功能:绑定板端数据源到 104 source(每次 core_start 成功后调用)。 /* 函数功能:绑定板端数据源到 104 source(每次 core_start 成功后调用)。
* 入口参数:无 * 入口参数:无
* 返回值:无 * 返回值:无
@@ -159,13 +196,13 @@ static bool s_signal(void *ctx, uint16_t source_addr, uint8_t *value, uint8_t *q
* 产品侧调用点是 iec104_core.c 的 initialize_core(),由 iec104_core_start() * 产品侧调用点是 iec104_core.c 的 initialize_core(),由 iec104_core_start()
* 每次 start 触发(网络代次变化 / poll 服务级失败都会 stop→start)。 * 每次 start 触发(网络代次变化 / poll 服务级失败都会 stop→start)。
* 若只在开机时绑一次,第一次重连后 bindings 被清零且再无人重绑, * 若只在开机时绑一次,第一次重连后 bindings 被清零且再无人重绑,
* 主站又退回"0 + IV"且无任何日志——这是下一个接手人最容易踩的坑。 * 主站又退回"0 + IV"且无任何日志。
* parameter_read/parameter_apply 两个都保持 NULL:source.h 要求成对注册, * 17 个消费者的 read/apply 在此成对注册:read 直读 prot_set 当前值,
* 而 NOSTORE 档明确禁止写,只注册 read 会破坏配对语义、掩盖参数整定不可用。 */ * apply 只构造批量事务,持久化仍由 defaultTask 的脏标志闭环负责。 */
static void s_bind_mcu_source(void) static void s_bind_mcu_source(void)
{ {
static const iec104_source_bindings_t bindings = { static const iec104_source_bindings_t bindings = {
NULL, s_measure, s_signal, NULL, NULL NULL, s_measure, s_signal, s_parameter_read, s_parameter_apply
}; };
iec104_source_bind(&bindings); iec104_source_bind(&bindings);
} }
@@ -47,10 +47,10 @@ dhara 失败类 +84;RO 另 +208,全是该失败类名表)→ `ER_IROM1`
<!-- MEM_SNAPSHOT:BEGIN generated by scripts/check_mem_numbers.py --> <!-- MEM_SNAPSHOT:BEGIN generated by scripts/check_mem_numbers.py -->
| 区域 | 用量 | 容量 | 占比 | | 区域 | 用量 | 容量 | 占比 |
|---|---|---|---| |---|---|---|---|
| ER_IROM1 | 413,392 B (403.70 KB) | 1,048,576 B (1024 KB) | 39.4% | | ER_IROM1 | 411,668 B (402.02 KB) | 1,048,576 B (1024 KB) | 39.3% |
| RW_IRAM1 | 117,304 B (114.55 KB) | 131,072 B (128 KB) | 89.5% | | RW_IRAM1 | 113,720 B (111.05 KB) | 131,072 B (128 KB) | 86.8% |
| RW_CCM | 57,376 B (56.03 KB) | 65,280 B (64 KB) | 87.9% | | RW_CCM | 57,376 B (56.03 KB) | 65,280 B (64 KB) | 87.9% |
| **Flash (ROM 合计)** | **416,128 B (406.4 KB)** | 1,048,576 B (1024 KB) | **39.7%** | | **Flash (ROM 合计)** | **414,420 B (404.7 KB)** | 1,048,576 B (1024 KB) | **39.5%** |
<!-- MEM_SNAPSHOT:END --> <!-- MEM_SNAPSHOT:END -->
各区的容量与常量来源: 各区的容量与常量来源:
+3 -3
View File
@@ -15,10 +15,10 @@
<!-- MEM_BUDGET:BEGIN generated by scripts/ram_baseline.py --> <!-- MEM_BUDGET:BEGIN generated by scripts/ram_baseline.py -->
| 区域 | 用量 | 容量 | 占比 | 门禁(≤92%) | | 区域 | 用量 | 容量 | 占比 | 门禁(≤92%) |
|---|---|---|---|---| |---|---|---|---|---|
| ER_IROM1 (Flash) | 413,392 B | 1,048,576 B | 39.4% | 参考 | | ER_IROM1 (Flash) | 411,668 B | 1,048,576 B | 39.3% | 参考 |
| RW_CCM | 57,376 B | 65,280 B | 87.9% | PASS | | RW_CCM | 57,376 B | 65,280 B | 87.9% | PASS |
| UNINIT_CCM | 48 B | 256 B | 18.8% | 参考 | | UNINIT_CCM | 48 B | 256 B | 18.8% | 参考 |
| RW_IRAM1 | 117,304 B | 131,072 B | 89.5% | PASS | | RW_IRAM1 | 113,720 B | 131,072 B | 86.8% | PASS |
| 子系统(静态 RW+ZI;除 RTOS 堆在 CCM 外均在 SRAM1) | 现值 | 配额 | 状态 | | 子系统(静态 RW+ZI;除 RTOS 堆在 CCM 外均在 SRAM1) | 现值 | 配额 | 状态 |
|---|---|---|---| |---|---|---|---|
@@ -26,7 +26,7 @@
| 存储 | 9,144 B | 12 KB | OK | | 存储 | 9,144 B | 12 KB | OK |
| UI | 36,791 B | 16 KB | ⚠ 超 19.9 KB | | UI | 36,791 B | 16 KB | ⚠ 超 19.9 KB |
| RTOS 堆 | 57,376 B | 56 KB | 堆=配额 | | RTOS 堆 | 57,376 B | 56 KB | 堆=配额 |
| 应用 | 46,587 B | 8 KB | ⚠ 超 37.5 KB | | 应用 | 42,999 B | 8 KB | ⚠ 超 34.0 KB |
| 其它 | 10,797 B | — | 参考 | | 其它 | 10,797 B | — | 参考 |
<!-- MEM_BUDGET:END --> <!-- MEM_BUDGET:END -->
+16 -9
View File
@@ -22,7 +22,7 @@ static bool parameter_apply(void *ctx, const iec104_source_change_t *v, size_t n
{ {
(void)ctx; (void)v; (void)n; (void)validate; ++apply_count; return true; (void)ctx; (void)v; (void)n; (void)validate; ++apply_count; return true;
} }
static void exchange(const uint8_t *frame, size_t length, uint8_t expected_cot) static void exchange(const uint8_t *frame, size_t length, uint8_t expected_type, uint8_t expected_cot)
{ {
size_t start = fake.sent_bytes, at; size_t start = fake.sent_bytes, at;
unsigned i; bool found = false; unsigned i; bool found = false;
@@ -30,7 +30,7 @@ static void exchange(const uint8_t *frame, size_t length, uint8_t expected_cot)
for (i = 0U; i < 20U; ++i) { turn(); } for (i = 0U; i < 20U; ++i) { turn(); }
for (at = start; at + 6U <= fake.sent_bytes; at += (size_t)fake.output[at + 1U] + 2U) { for (at = start; at + 6U <= fake.sent_bytes; at += (size_t)fake.output[at + 1U] + 2U) {
CHECK(fake.output[at] == 0x68U); CHECK(fake.output[at] == 0x68U);
if (at + 12U <= fake.sent_bytes && !(fake.output[at + 2U] & 1U) && fake.output[at + 6U] == 203U) { if (at + 12U <= fake.sent_bytes && !(fake.output[at + 2U] & 1U) && fake.output[at + 6U] == expected_type) {
CHECK(fake.output[at + 8U] == expected_cot); found = true; CHECK(fake.output[at + 8U] == expected_cot); found = true;
} }
} }
@@ -39,16 +39,23 @@ static void exchange(const uint8_t *frame, size_t length, uint8_t expected_cot)
static void borrowed_failure(void) static void borrowed_failure(void)
{ {
iec104_source_bindings_t bind = {0}; iec104_source_bindings_t bind = {0};
iec104_source_value_t before, after; size_t i; uint16_t area0 = 0U, area1 = 0U;
static const uint8_t preset[] = {0x68,19,0,0,0,0,203,1,6,17,1,0,0,0,128,0x20,0x88,0,1,1,0}; /* While real bindings are installed, the area-0 low<=high cross-check reads
* semantic id 17 (PS_OV_VOL) through parameter_read. The fake fails id 17,
* so a staged 0x8027 preset must be refused at solidify with no apply. */
static const uint8_t preset[] = {0x68,22,0,0,0,0,203,1,6,17,1,0,0,0,128,0x27,0x80,0,38,4,0,0,200,0x42};
static const uint8_t solidify[] = {0x68,13,2,0,0,0,203,0,6,17,1,0,0,0,0}; static const uint8_t solidify[] = {0x68,13,2,0,0,0,203,0,6,17,1,0,0,0,0};
bind.parameter_read = parameter_read; bind.parameter_apply = parameter_apply; bind.parameter_read = parameter_read; bind.parameter_apply = parameter_apply;
iec104_source_bind(&bind); iec104_source_bind(&bind);
CHECK(iec104_source_remote_read(0U, 0x8820U, &before)); exchange(preset, sizeof(preset), 203U, 7U);
exchange(preset, sizeof(preset), 7U); exchange(solidify, sizeof(solidify), 203U, 0x47U);
exchange(solidify, sizeof(solidify), 0x47U); CHECK(apply_count == 0U);
CHECK(iec104_source_remote_read(0U, 0x8820U, &after)); for (i = 0U; i < IEC104_DTU_PARAMETER_COUNT; ++i) {
CHECK(before.bytes[0] == after.bytes[0] && apply_count == 0U); if (iec104_dtu_parameter_visible(i, 0U)) { ++area0; }
if (iec104_dtu_parameter_visible(i, 1U)) { ++area1; }
}
CHECK(area0 == IEC104_DTU_CONSUMER_COUNT);
CHECK(area1 == IEC104_DTU_SCOPED_CONSUMER_COUNT);
} }
int main(void) int main(void)
{ {
+9
View File
@@ -20,6 +20,15 @@ def reference():
parameters[int(ioa, 16)] = (int(tag), value.strip('"')) parameters[int(ioa, 16)] = (int(tag), value.strip('"'))
assert [len(tables[x]) for x in tables] == [59, 30, 4, 19, 430] assert [len(tables[x]) for x in tables] == [59, 30, 4, 19, 430]
assert len(parameters) == 345 assert len(parameters) == 345
# Accepted consumer subset. This list is the acceptance specification and
# must match the semantic bridge map in iec104_dtu_table.c item for item.
# Every other configured profile row must be refused by the protocol layer.
consumer_ioas = frozenset((
0x8841, 0x8842, 0x8843, 0x8845, 0x8846, 0x8847, 0x8849, 0x884A, 0x884B,
0x8027, 0x8028, 0x8029, 0x802A, 0x8024, 0x8025, 0x8040, 0x8041,
))
parameters = {ioa: row for ioa, row in parameters.items() if ioa in consumer_ioas}
assert len(parameters) == 17
assert set(tables["signals"]) == set(range(1, 0x42)) - set(range(0x2C, 0x32)) assert set(tables["signals"]) == set(range(1, 0x42)) - set(range(0x2C, 0x32))
assert set(tables["measurements"]) == set(range(0x4001, 0x401F)) assert set(tables["measurements"]) == set(range(0x4001, 0x401F))
gi = {ioa: 1 for ioa in tables["signals"]} gi = {ioa: 1 for ioa in tables["signals"]}
+5 -4
View File
@@ -186,9 +186,9 @@ class Acceptance:
assert self.client.response(201, 7)[9:11] == b"\x00\x00" assert self.client.response(201, 7)[9:11] == b"\x00\x00"
def test_typed_preset_commit_cancel_readback(self): def test_typed_preset_commit_cancel_readback(self):
addresses = (0x8820, 0x8823, 0x882D, 0x802E) addresses = (0x8841, 0x8842, 0x8843, 0x8027)
before = self.remote_read(addresses) before = self.remote_read(addresses)
change = [(0x8820, 1, 0), (0x8823, 38, 8.25), (0x882D, 45, 2), (0x802E, 35, 16777217)] change = [(0x8841, 1, 1), (0x8842, 38, 2.5), (0x8843, 38, 0.75), (0x8027, 38, 90.0)]
original = [(ioa, before[ioa]["tag"], before[ioa]["value"]) for ioa in addresses] original = [(ioa, before[ioa]["tag"], before[ioa]["value"]) for ioa in addresses]
try: try:
self.preset(change) self.preset(change)
@@ -200,6 +200,7 @@ class Acceptance:
assert self.remote_read(addresses) == after, "TCP reconnect lost committed RAM values" assert self.remote_read(addresses) == after, "TCP reconnect lost committed RAM values"
self.preset(original) self.preset(original)
self.connect() self.connect()
self.remote_read(addresses)
self.finish(pn=True) self.finish(pn=True)
assert self.remote_read(addresses) == after, "disconnected stage became active" assert self.remote_read(addresses) == after, "disconnected stage became active"
self.preset(original) self.preset(original)
@@ -214,10 +215,10 @@ class Acceptance:
def test_unknown_and_bad_typed_requests(self): def test_unknown_and_bad_typed_requests(self):
self.client.request(asdu(102, u24(0xFFFFFF), cot=5)) self.client.request(asdu(102, u24(0xFFFFFF), cot=5))
self.client.response(102, 47, True) self.client.response(102, 47, True)
for ioa in (0xFFFFFF, 0x9601): for ioa in (0xFFFFFF, 0x9601, 0x8820, 0x8823):
self.client.request(asdu(202, b"\x00\x00" + u24(ioa))) self.client.request(asdu(202, b"\x00\x00" + u24(ioa)))
self.client.response(202, 47, True) self.client.response(202, 47, True)
for value in ([(0x8820, 1, 2)], [(0x8823, 45, 8)], [(0x8823, 38, float("nan"))]): for value in ([(0x8841, 1, 2)], [(0x8842, 45, 8)], [(0x8842, 38, float("nan"))]):
self.preset(value, pn=True) self.preset(value, pn=True)
self.finish(cancel=True) self.finish(cancel=True)
+3 -2
View File
@@ -21,10 +21,11 @@ class WireOracleTests(unittest.TestCase):
self.assertEqual(len(ref["gi"]), 225) self.assertEqual(len(ref["gi"]), 225)
self.assertEqual(len(ref["read"]), 121) self.assertEqual(len(ref["read"]), 121)
self.assertEqual(len(ref["counters"]), 8) self.assertEqual(len(ref["counters"]), 8)
self.assertEqual(len(ref["remote"]), 345) self.assertEqual(len(ref["remote"]), 17)
self.assertEqual(len(ref["diagnostic_aliases_pending_scope"]), 150) self.assertEqual(len(ref["diagnostic_aliases_pending_scope"]), 150)
self.assertNotIn(0x9601, ref["remote"]) self.assertNotIn(0x9601, ref["remote"])
self.assertEqual(ref["remote"][0x8858], (38, "25")) self.assertNotIn(0x8858, ref["remote"])
self.assertEqual(ref["remote"][0x8842], (38, "1.2"))
def test_pn_zero_positive_and_one_negative(self): def test_pn_zero_positive_and_one_negative(self):
self.assertFalse(header(bytes.fromhex("64010711010000000014"))["pn"]) self.assertFalse(header(bytes.fromhex("64010711010000000014"))["pn"])
+57
View File
@@ -116,6 +116,26 @@ static uint8_t g_prot_dirty, g_run_dirty;
uint8_t prot_set_dirty_peek(void) { return g_prot_dirty; } uint8_t prot_set_dirty_peek(void) { return g_prot_dirty; }
uint8_t run_par_dirty_peek(void) { return g_run_dirty; } uint8_t run_par_dirty_peek(void) { return g_run_dirty; }
static float g_prot_value;
static prot_set_change_t g_last_batch[PROT_SET_BATCH_MAX];
static size_t g_last_batch_n;
static int g_last_validate_only, g_apply_batch_calls;
float prot_set_get_f(prot_set_id_t id)
{
(void)id;
return g_prot_value;
}
int prot_set_apply_batch(const prot_set_change_t *changes, size_t n, int validate_only)
{
size_t i;
g_apply_batch_calls++;
g_last_batch_n = n;
g_last_validate_only = validate_only;
for (i = 0U; i < n && i < PROT_SET_BATCH_MAX; ++i) { g_last_batch[i] = changes[i]; }
return 0;
}
static int g_wd_beats; static int g_wd_beats;
static task_wd_id_t g_last_wd; static task_wd_id_t g_last_wd;
void task_wd_beat(task_wd_id_t id) { g_wd_beats++; g_last_wd = id; } void task_wd_beat(task_wd_id_t id) { g_wd_beats++; g_last_wd = id; }
@@ -139,6 +159,11 @@ static void reset_all(void)
g_meas_result = 0; g_meas_result = 0;
memset(g_cal_flags, 0, sizeof(g_cal_flags)); memset(g_cal_flags, 0, sizeof(g_cal_flags));
g_prot_dirty = g_run_dirty = 0u; g_prot_dirty = g_run_dirty = 0u;
g_prot_value = 0u;
g_apply_batch_calls = 0;
g_last_batch_n = 0u;
g_last_validate_only = 0;
memset(g_last_batch, 0, sizeof(g_last_batch));
g_wd_beats = 0; g_wd_beats = 0;
g_i104_info_count = g_i104_error_count = 0; g_i104_info_count = g_i104_error_count = 0;
g_cfg_register_calls = g_cfg_save_calls = 0; g_cfg_register_calls = g_cfg_save_calls = 0;
@@ -161,6 +186,37 @@ static void reset_all(void)
g_i104_info_count = g_i104_error_count = 0; g_i104_info_count = g_i104_error_count = 0;
} }
static void tc_parameter_binding(void)
{
iec104_source_change_t changes[2];
float value = 0.0f;
reset_all();
CHECK(g_bound.parameter_read != NULL && g_bound.parameter_apply != NULL,
"parameter callbacks installed as a pair");
g_prot_value = 12.5f;
CHECK(g_bound.parameter_read(NULL, (uint16_t)PS_ID_COUNT, &value) == false,
"out-of-range semantic id refused");
CHECK(g_bound.parameter_read(NULL, 2u, &value) == true && value == 12.5f,
"valid semantic id reads live prot_set value");
CHECK(g_bound.parameter_read(NULL, 2u, NULL) == false,
"null output refused");
changes[0].id = 2u; changes[0].value = 1.25f;
changes[1].id = 3u; changes[1].value = 500.0f;
CHECK(g_bound.parameter_apply(NULL, changes, 2u, true) == true,
"validate-only batch accepted");
CHECK(g_apply_batch_calls == 1 && g_last_batch_n == 2u && g_last_validate_only == 1,
"validate-only forwarded once without commit");
CHECK(g_last_batch[0].id == 2u && g_last_batch[0].q10 == PROT_SET_Q10(1.25f) &&
g_last_batch[1].id == 3u && g_last_batch[1].q10 == PROT_SET_Q10(500.0f),
"semantic values quantized into prot_set batch");
CHECK(g_bound.parameter_apply(NULL, changes, 0u, false) == false,
"empty batch refused");
CHECK(g_bound.parameter_apply(NULL, changes, 2u + IEC104_DTU_CONSUMER_COUNT, false) == false,
"over-capacity batch refused");
CHECK(g_apply_batch_calls == 1, "rejected batches never reach prot_set");
}
static void tc_monotonic(void) static void tc_monotonic(void)
{ {
uint32_t last = 100u, carry = 7u; uint32_t last = 100u, carry = 7u;
@@ -381,6 +437,7 @@ int main(void)
printf("=== IEC104 Service Host Unit Tests ===\n"); printf("=== IEC104 Service Host Unit Tests ===\n");
tc_monotonic(); tc_monotonic();
tc_measure(); tc_measure();
tc_parameter_binding();
tc_stats_and_link(); tc_stats_and_link();
tc_tick_control(); tc_tick_control();
printf("=== IEC104 Serv Tests: %d/%d PASSED (failed=%d) ===\n", printf("=== IEC104 Serv Tests: %d/%d PASSED (failed=%d) ===\n",
+507
View File
@@ -23,6 +23,21 @@
* TC-PROTSET-011 OF/UF 定值行(B8):40 项 / blob 版本 2 / 本地项地址 0 / * TC-PROTSET-011 OF/UF 定值行(B8):40 项 / blob 版本 2 / 本地项地址 0 /
* 默认值与范围 / 返回系数独立性 / 64 位 bad_mask(bit 39)/ * 默认值与范围 / 返回系数独立性 / 64 位 bad_mask(bit 39)/
* B7 旧档(32 项)换代拒绝 * B7 旧档(32 项)换代拒绝
* 批量原子写与写事务锁(104 定值下发接线):
* tc_batch_write_and_seal 整批写 3 项 → 读回 / 自检通过 / 未闭锁 / 置脏
* tc_batch_reject_is_all_or_nothing 一项越界 → 整批拒且值区一字未改
* tc_batch_reject_duplicate_id 同批重复 id → 拒
* tc_batch_reject_over_limit 项数超上限 → 拒
* tc_validate_only_has_no_side_effect 预检全合法 → 值区/脏位/锁位/钩子全不动
* tc_validate_only_reports_bad_item 预检有越界 → 拒且全不动
* tc_read_batch_guards 正常读回;越界 id / n 为 0 / 空指针 → 拒
* tc_write_lock_pairs 成功写 enter/exit 各一次;预检与失败分支不进钩子
* tc_selfcheck_tolerates_commit_window 提交窗口内自检只跳过、不误锁
* tc_lock_uninstall 卸载钩子后仍能正常写
* tc_selfcheck_odd_streak_failsafe 写者永久停在提交窗口内 → 8 拍宽限后闭锁
* (fail-safe;用故意漏 exit 的缺陷写者样本驱动)
* tc_bad_mask_tracks_whole_table_only 位图只跟整表装载/解析走,增量写入
* 既不置也不清(契约钉死)
* *
* 通过:全部 TC PASS(main 返回 0)。 * 通过:全部 TC PASS(main 返回 0)。
* 创建日期:2026-10-11;2026-10-12 扩 OF/UF(B8) * 创建日期:2026-10-11;2026-10-12 扩 OF/UF(B8)
@@ -321,6 +336,486 @@ static void tc_of_uf_meta(void) {
CHECK(prot_set_selfcheck() == 0, "TC-PROTSET-011 active table intact after legacy reject"); CHECK(prot_set_selfcheck() == 0, "TC-PROTSET-011 active table intact after legacy reject");
} }
/* 整表快照:值区 + 脏位 + 闭锁位("一字未改"与"零副作用"的比对基准) */
typedef struct {
int32_t vals[PS_ID_COUNT];
uint8_t dirty;
uint8_t locked;
} tc_snapshot_t;
/*
* 函数功能:把当前定值状态拍成快照
* 入口参数:s - 输出快照
* 返 回 值:无
*/
static void tc_snapshot(tc_snapshot_t *s) {
uint32_t i;
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
s->vals[i] = prot_set_get((prot_set_id_t)i);
}
s->dirty = prot_set_dirty_peek();
s->locked = prot_set_locked();
}
/*
* 函数功能:比对两份快照是否逐字相同
* 入口参数:a/b - 待比快照
* 返 回 值:1 完全相同 / 0 有差异
*/
static int tc_snapshot_same(const tc_snapshot_t *a, const tc_snapshot_t *b) {
uint32_t i;
if ((a->dirty != b->dirty) || (a->locked != b->locked)) {
return 0;
}
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
if (a->vals[i] != b->vals[i]) {
return 0;
}
}
return 1;
}
/* 计数版写事务钩子:证明"哪条分支真的进了临界区" */
static int s_hook_enter = 0;
static int s_hook_exit = 0;
/*
* 函数功能:计数钩子——进入写事务
* 入口参数:无
* 返 回 值:无
*/
static void tc_hook_enter(void) {
s_hook_enter++;
}
/*
* 函数功能:计数钩子——退出写事务
* 入口参数:无
* 返 回 值:无
*/
static void tc_hook_exit(void) {
s_hook_exit++;
}
static const prot_set_lock_t s_test_lock = { tc_hook_enter, tc_hook_exit };
/*
* 函数功能:装钩子并清零计数
* 入口参数:无
* 返 回 值:无
*/
static void tc_lock_on(void) {
s_hook_enter = 0;
s_hook_exit = 0;
prot_set_lock_install(&s_test_lock);
}
/* 批量写:正常整批提交的闭环(值/自检/闭锁/脏位) */
static void tc_batch_write_and_seal(void) {
prot_set_change_t chg[3];
prot_set_id_t ids[3];
int32_t got[3];
prot_set_init();
prot_set_lock_install(0);
CHECK(prot_set_dirty_peek() == 0u, "batch write: clean table before commit");
chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(7.5);
chg[1].id = PS_OC2_DLY; chg[1].q10 = PROT_SET_Q10(250.0);
chg[2].id = PS_GLOBAL_EN; chg[2].q10 = 0;
CHECK(prot_set_apply_batch(chg, 3u, 0) == 0, "batch write: three items committed");
CHECK(prot_set_get(PS_OC1_CUR) == PROT_SET_Q10(7.5), "batch write: OC1 current updated");
CHECK(prot_set_get(PS_OC2_DLY) == PROT_SET_Q10(250.0), "batch write: OC2 delay updated");
CHECK(prot_set_get_ctl(PS_GLOBAL_EN) == 0u, "batch write: global plate switched out");
CHECK(prot_set_selfcheck() == 0, "batch write: selfcheck passes right after commit");
CHECK(prot_set_locked() == 0u, "batch write: no lock after commit");
CHECK(prot_set_dirty_peek() == 1u, "batch write: commit marks dirty for persistence");
ids[0] = PS_OC1_CUR;
ids[1] = PS_OC2_DLY;
ids[2] = PS_GLOBAL_EN;
CHECK(prot_set_read_batch(ids, 3u, got) == 0, "batch write: read back same three items");
CHECK((got[0] == PROT_SET_Q10(7.5)) && (got[1] == PROT_SET_Q10(250.0)) && (got[2] == 0),
"batch write: read-back values match what was written");
}
/* 批量写:一项越界 → 整批拒绝且值区一字未改(all-or-nothing) */
static void tc_batch_reject_is_all_or_nothing(void) {
prot_set_change_t chg[3];
tc_snapshot_t before;
tc_snapshot_t after;
prot_set_init();
prot_set_lock_install(0);
(void)prot_set_set_sealed(PS_OC1_CUR, PROT_SET_Q10(9.0)); /* 先建立一个非默认现状 */
(void)prot_set_dirty_take();
tc_snapshot(&before);
chg[0].id = PS_OC2_CUR; chg[0].q10 = PROT_SET_Q10(6.0); /* 合法 */
chg[1].id = PS_OC3_DLY; chg[1].q10 = PROT_SET_Q10(60001.0); /* 越上限 */
chg[2].id = PS_OL_CUR; chg[2].q10 = PROT_SET_Q10(2.0); /* 合法 */
CHECK(prot_set_apply_batch(chg, 3u, 0) == -1, "batch reject: one bad item rejects the batch");
tc_snapshot(&after);
CHECK(tc_snapshot_same(&before, &after),
"batch reject: every item, dirty flag and lock state untouched");
CHECK(prot_set_get(PS_OC1_CUR) == PROT_SET_Q10(9.0),
"batch reject: pre-existing value survives the rejected batch");
CHECK(prot_set_selfcheck() == 0, "batch reject: table still self-consistent");
}
/* 批量写:同批重复编号 → 拒(语义不确定) */
static void tc_batch_reject_duplicate_id(void) {
prot_set_change_t chg[2];
tc_snapshot_t before;
tc_snapshot_t after;
prot_set_init();
prot_set_lock_install(0);
tc_snapshot(&before);
chg[0].id = PS_OC2_CUR; chg[0].q10 = PROT_SET_Q10(6.0);
chg[1].id = PS_OC2_CUR; chg[1].q10 = PROT_SET_Q10(7.0);
CHECK(prot_set_apply_batch(chg, 2u, 0) == -1, "batch reject: duplicate id rejected");
tc_snapshot(&after);
CHECK(tc_snapshot_same(&before, &after), "batch reject duplicate: table untouched");
}
/* 批量写:项数超上限 → 拒(整表只有 40 项,批量接口不接受更多) */
static void tc_batch_reject_over_limit(void) {
prot_set_change_t chg[PROT_SET_BATCH_MAX + 1u];
tc_snapshot_t before;
tc_snapshot_t after;
size_t i;
prot_set_init();
prot_set_lock_install(0);
tc_snapshot(&before);
for (i = 0u; i < (PROT_SET_BATCH_MAX + 1u); i++) {
chg[i].id = (prot_set_id_t)(i % (size_t)PS_ID_COUNT);
chg[i].q10 = prot_set_get(chg[i].id); /* 值全合法,只考项数 */
}
CHECK(prot_set_apply_batch(chg, PROT_SET_BATCH_MAX + 1u, 0) == -1,
"batch reject: item count above limit rejected");
CHECK(prot_set_apply_batch(chg, 0u, 0) == -1, "batch reject: empty batch rejected");
CHECK(prot_set_apply_batch(0, 1u, 0) == -1, "batch reject: NULL change list rejected");
tc_snapshot(&after);
CHECK(tc_snapshot_same(&before, &after), "batch reject over limit: table untouched");
}
/* 预检(validate_only):全合法时零副作用——值区、脏位、闭锁位、钩子全不动 */
static void tc_validate_only_has_no_side_effect(void) {
prot_set_change_t chg[2];
tc_snapshot_t before;
tc_snapshot_t after;
prot_set_init();
(void)prot_set_set_sealed(PS_OC1_CUR, PROT_SET_Q10(8.0));
(void)prot_set_dirty_take();
tc_lock_on();
tc_snapshot(&before);
chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(9.0);
chg[1].id = PS_UF_HZ; chg[1].q10 = PROT_SET_Q10(47.0);
CHECK(prot_set_apply_batch(chg, 2u, 1) == 0, "validate only: valid batch reported OK");
tc_snapshot(&after);
CHECK(tc_snapshot_same(&before, &after),
"validate only: values, dirty flag and lock state all unchanged");
CHECK(prot_set_get(PS_OC1_CUR) == PROT_SET_Q10(8.0),
"validate only: proposed value NOT applied");
CHECK(prot_set_get(PS_UF_HZ) == PROT_SET_Q10(49.0),
"validate only: untouched item keeps its old value");
CHECK((s_hook_enter == 0) && (s_hook_exit == 0),
"validate only: write lock hook never entered");
prot_set_lock_install(0);
}
/* 预检(validate_only):有越界项 → 拒,同样全不动 */
static void tc_validate_only_reports_bad_item(void) {
prot_set_change_t chg[2];
tc_snapshot_t before;
tc_snapshot_t after;
prot_set_init();
tc_lock_on();
tc_snapshot(&before);
chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(9.0);
chg[1].id = PS_UF_HZ; chg[1].q10 = PROT_SET_Q10(44.0); /* 低于下限 45 */
CHECK(prot_set_apply_batch(chg, 2u, 1) == -1, "validate only: out-of-range item reported");
tc_snapshot(&after);
CHECK(tc_snapshot_same(&before, &after), "validate only reject: nothing changed");
CHECK((s_hook_enter == 0) && (s_hook_exit == 0),
"validate only reject: write lock hook never entered");
prot_set_lock_install(0);
}
/* 批量读:正常读回;越界编号 / 零项 / 空指针 → 拒 */
static void tc_read_batch_guards(void) {
prot_set_id_t ids[2];
prot_set_id_t bad[1];
int32_t got[2];
prot_set_init();
(void)prot_set_set_sealed(PS_OC2_CUR, PROT_SET_Q10(6.5));
ids[0] = PS_OC2_CUR;
ids[1] = PS_RET_UF;
got[0] = 0;
got[1] = 0;
CHECK(prot_set_read_batch(ids, 2u, got) == 0, "read batch: two items read");
CHECK(got[0] == PROT_SET_Q10(6.5), "read batch: first value matches");
CHECK(got[1] == PROT_SET_Q10(1.01), "read batch: second value matches");
bad[0] = PS_ID_COUNT;
CHECK(prot_set_read_batch(bad, 1u, got) == -1, "read batch: out-of-range id rejected");
CHECK(prot_set_read_batch(ids, 0u, got) == -1, "read batch: zero count rejected");
CHECK(prot_set_read_batch(0, 2u, got) == -1, "read batch: NULL id list rejected");
CHECK(prot_set_read_batch(ids, 2u, 0) == -1, "read batch: NULL output rejected");
}
/* 写事务锁:成功写 enter/exit 各一次;预检与失败分支不进钩子 */
static void tc_write_lock_pairs(void) {
prot_set_change_t chg[2];
int32_t tbl[PS_ID_COUNT];
uint32_t i;
prot_set_init();
tc_lock_on();
chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(7.0);
chg[1].id = PS_OL_CUR; chg[1].q10 = PROT_SET_Q10(1.2);
CHECK(prot_set_apply_batch(chg, 2u, 0) == 0, "lock pairs: batch commit succeeds");
CHECK((s_hook_enter == 1) && (s_hook_exit == 1),
"lock pairs: batch commit enters and exits the write lock exactly once");
s_hook_enter = 0;
s_hook_exit = 0;
chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(999.0); /* 越界 */
CHECK(prot_set_apply_batch(chg, 1u, 0) == -1, "lock pairs: out-of-range batch rejected");
CHECK((s_hook_enter == 0) && (s_hook_exit == 0),
"lock pairs: rejected batch never enters the write lock");
s_hook_enter = 0;
s_hook_exit = 0;
CHECK(prot_set_set_sealed(PS_OC2_CUR, PROT_SET_Q10(4.0)) == 0,
"lock pairs: single item write succeeds");
CHECK((s_hook_enter == 1) && (s_hook_exit == 1),
"lock pairs: single item write enters and exits exactly once");
s_hook_enter = 0;
s_hook_exit = 0;
CHECK(prot_set_set_sealed(PS_ID_COUNT, 0) == -1, "lock pairs: bad id rejected");
CHECK((s_hook_enter == 0) && (s_hook_exit == 0),
"lock pairs: rejected single write never enters the write lock");
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
tbl[i] = prot_set_get((prot_set_id_t)i);
}
tbl[PS_OC3_CUR] = PROT_SET_Q10(3.0);
s_hook_enter = 0;
s_hook_exit = 0;
CHECK(prot_set_load_raw(tbl) == 0, "lock pairs: whole table load succeeds");
CHECK((s_hook_enter == 1) && (s_hook_exit == 1),
"lock pairs: whole table load enters and exits exactly once");
s_hook_enter = 0;
s_hook_exit = 0;
tbl[PS_OC3_CUR] = PROT_SET_Q10(999.0);
CHECK(prot_set_load_raw(tbl) == -1, "lock pairs: bad table rejected");
CHECK((s_hook_enter == 0) && (s_hook_exit == 0),
"lock pairs: rejected table load never enters the write lock");
prot_set_lock_install(0);
}
/* 提交窗口内自检不得误判失配(多写者引入的安全级风险) */
static void tc_selfcheck_tolerates_commit_window(void) {
uint32_t keep_sum;
uint32_t keep_sumn;
prot_set_init();
/* 模拟"封存对已改、活跃区未交换"的窗口:这是另一写者抢占时的真实中间态,
* 巡检撞上它绝不能闭锁整台保护 */
keep_sum = s_sum;
keep_sumn = s_sumn;
prot_write_enter();
s_sum = prot_sum_buf(s_val[s_act]) + 1u;
s_sumn = ~s_sum;
CHECK(prot_set_selfcheck() == 0, "commit window: selfcheck skips instead of latching");
CHECK(prot_set_locked() == 0u, "commit window: no lock latched during commit");
s_sum = keep_sum;
s_sumn = keep_sumn;
prot_write_exit();
CHECK(prot_set_selfcheck() == 0, "commit window: selfcheck passes once commit settles");
/* 无提交在飞时的真失配仍必须闭锁(防篡改语义不许被上述跳过放宽) */
s_val[s_act][(uint32_t)PS_OC1_CUR] ^= 1u;
CHECK(prot_set_selfcheck() == -1, "tamper: real mismatch still caught when idle");
CHECK(prot_set_locked() == 1u, "tamper: real mismatch still latches the lock");
prot_set_init();
CHECK(prot_set_selfcheck() == 0, "tamper: re-init clears the lock");
}
/* 卸载钩子后仍能正常写(模拟器 / 主机单测的单写者假设) */
static void tc_lock_uninstall(void) {
prot_set_change_t chg[1];
prot_set_init();
tc_lock_on();
prot_set_lock_install(0);
s_hook_enter = 0;
s_hook_exit = 0;
chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(6.25);
CHECK(prot_set_apply_batch(chg, 1u, 0) == 0, "lock uninstall: batch commit works without hook");
CHECK(prot_set_get(PS_OC1_CUR) == PROT_SET_Q10(6.25), "lock uninstall: value applied");
CHECK(prot_set_selfcheck() == 0, "lock uninstall: table self-consistent");
CHECK((s_hook_enter == 0) && (s_hook_exit == 0), "lock uninstall: hook not called anymore");
}
/*
* 缺陷写者样本:**故意**在 prot_write_enter() 之后提前 return、忘了 exit。
* 这是 prot_set.c 里明令禁止的形态(四条真实路径都把校验放在 enter 之前),
* 但"以后有人加路径时忘了这条纪律"是真实可能——本用例用它把自检的 fail-safe
* 兜底钉死:序号一旦永久停在奇数,防篡改自检必须自己发现写者已死、置闭锁,
* 而不是永远"本轮跳过"。
*/
static int tc_buggy_writer_early_return(const prot_set_change_t *changes, size_t n) {
uint32_t cur_act;
prot_write_enter();
if ((n == 0u) || (changes == 0)) {
return -1; /* 缺陷:锁内提前返回,没有 prot_write_exit() */
}
if ((changes[0].q10 < g_prot_set_meta[changes[0].id].min)
|| (changes[0].q10 > g_prot_set_meta[changes[0].id].max)) {
return -1; /* 缺陷同上 */
}
cur_act = s_act;
prot_copy_buf(s_val[cur_act ^ 1u], s_val[cur_act]);
s_val[cur_act ^ 1u][(uint32_t)changes[0].id] = (uint32_t)changes[0].q10;
s_sum = prot_sum_buf(s_val[cur_act ^ 1u]);
s_sumn = ~s_sum;
s_locked = 0u;
s_act = (uint8_t)(cur_act ^ 1u);
s_dirty = 1u;
prot_write_exit();
return 0;
}
/* 自检 fail-safe:写者永久停在提交窗口内 → 有界宽限后必须闭锁 */
static void tc_selfcheck_odd_streak_failsafe(void) {
prot_set_change_t chg[1];
uint32_t i;
int early_ok = 1;
int all_clear = 1;
prot_set_init();
CHECK(prot_set_selfcheck() == 0, "odd streak: healthy table selfchecks clean");
/* 真实缺陷路径:enter 之后越界提前 return → 序号永久停在奇数 */
chg[0].id = PS_OC1_CUR;
chg[0].q10 = g_prot_set_meta[PS_OC1_CUR].max + 1;
CHECK(tc_buggy_writer_early_return(chg, 1u) == -1, "odd streak: buggy writer returns -1");
CHECK((s_seq & 1u) == 1u, "odd streak: sequence number left permanently odd");
/* ① 宽限期内的前 7 拍:跳过但不误锁 */
for (i = 0u; i < (uint32_t)(PROT_SET_ODD_STREAK_MAX - 1u); i++) {
if ((prot_set_selfcheck() != 0) || (prot_set_locked() != 0u)) {
early_ok = 0;
}
}
CHECK(early_ok, "odd streak: first seven ticks skip WITHOUT latching the lock");
/* ② 第 8 拍起:判写者已死 → 闭锁并返回 -1 */
CHECK(prot_set_selfcheck() == -1, "odd streak: eighth tick trips the fail-safe lock");
CHECK(prot_set_locked() == 1u, "odd streak: fail-safe latches the protection lock");
CHECK(prot_set_selfcheck() == -1, "odd streak: lock stays latched on later ticks");
/* ③ 恢复偶数(写者"复活")→ 宽限计数归零,但闭锁仍按既有语义保持到 seal/init */
prot_write_exit();
CHECK((s_seq & 1u) == 0u, "odd streak: sequence number back to even after recovery");
CHECK(prot_set_selfcheck() == -1, "odd streak: lock latched until an explicit seal");
CHECK(s_odd_streak == 0u, "odd streak: grace counter cleared once sequence settles even");
/* ④ fail-safe 的闭锁必须是**可恢复**的:写者恢复后走合法封存路径能解锁,
* 否则一次写者崩溃就等于设备永久报废,现场只能整机返修 */
prot_set_seal();
CHECK(prot_set_locked() == 0u, "odd streak: seal is the documented unlock path after a fail-safe lock");
CHECK(prot_set_selfcheck() == 0, "odd streak: selfcheck clean after re-seal");
prot_set_init();
CHECK(s_odd_streak == 0u, "odd streak: init also zeroes the grace counter");
CHECK(prot_set_locked() == 0u, "odd streak: init clears the fail-safe lock");
CHECK(prot_set_selfcheck() == 0, "odd streak: selfcheck healthy again after init");
/* 反复"撞一下立刻恢复"的健康抖动不该累积:每拍都能看到偶数就每次归零 */
for (i = 0u; i < (uint32_t)(PROT_SET_ODD_STREAK_MAX * 3u); i++) {
prot_write_enter();
prot_write_exit();
if ((prot_set_selfcheck() != 0) || (prot_set_locked() != 0u)) {
all_clear = 0;
}
}
CHECK(all_clear, "odd streak: short commit windows never accumulate into a false lock");
}
/* 契约:bad_mask 只跟整表装载/解析走,增量写入既不置也不清 */
static void tc_bad_mask_tracks_whole_table_only(void) {
int32_t tbl[PS_ID_COUNT];
prot_set_change_t chg[2];
uint64_t bad_before;
uint32_t i;
prot_set_init();
CHECK(prot_set_bad_mask() == 0u, "bad mask: clean after init");
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
tbl[i] = prot_set_get((prot_set_id_t)i);
}
tbl[PS_OC3_DLY] = PROT_SET_Q10(60001.0); /* 越上限 */
CHECK(prot_set_load_raw(tbl) == -1, "bad mask: whole-table load with a bad item rejected");
CHECK(prot_set_bad_mask() == (1uLL << PS_OC3_DLY),
"bad mask: whole-table load reports the offending item");
bad_before = prot_set_bad_mask();
/* 一笔成功的批量提交不碰位图——这是刻意契约(不是漏刷) */
chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(7.0);
chg[1].id = PS_OL_CUR; chg[1].q10 = PROT_SET_Q10(1.5);
CHECK(prot_set_apply_batch(chg, 2u, 0) == 0, "bad mask: successful batch committed");
CHECK(prot_set_bad_mask() == bad_before,
"bad mask: successful batch leaves the stale bitmap untouched (by contract)");
/* 一笔失败的批量提交同样不碰位图 */
chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(999.0);
CHECK(prot_set_apply_batch(chg, 1u, 0) == -1, "bad mask: bad batch rejected");
CHECK(prot_set_bad_mask() == bad_before,
"bad mask: failed batch does not record anything in the bitmap");
/* 单项写入同理 */
CHECK(prot_set_set_sealed(PS_OC2_CUR, PROT_SET_Q10(3.0)) == 0, "bad mask: single write ok");
CHECK(prot_set_bad_mask() == bad_before, "bad mask: single write leaves the bitmap untouched");
/* 只有整表操作与 init 会覆写它(用各项出厂默认值组一张必然合法的表) */
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
tbl[i] = g_prot_set_meta[i].def;
}
CHECK(prot_set_load_raw(tbl) == 0, "bad mask: all-legal table load accepted");
CHECK(prot_set_bad_mask() == 0u, "bad mask: successful whole-table load rewrites it to clean");
prot_set_init();
CHECK(prot_set_bad_mask() == 0u, "bad mask: init clears it");
}
int main(void) { int main(void) {
printf("=== Prot Set Tests ===\n"); printf("=== Prot Set Tests ===\n");
tc_init(); tc_init();
@@ -334,6 +829,18 @@ int main(void) {
tc_store_roundtrip(); tc_store_roundtrip();
tc_store_corrupt(); tc_store_corrupt();
tc_of_uf_meta(); tc_of_uf_meta();
tc_batch_write_and_seal();
tc_batch_reject_is_all_or_nothing();
tc_batch_reject_duplicate_id();
tc_batch_reject_over_limit();
tc_validate_only_has_no_side_effect();
tc_validate_only_reports_bad_item();
tc_read_batch_guards();
tc_write_lock_pairs();
tc_selfcheck_tolerates_commit_window();
tc_lock_uninstall();
tc_selfcheck_odd_streak_failsafe();
tc_bad_mask_tracks_whole_table_only();
printf("\n=== Prot Set Tests: %d/%d PASSED (failed=%d) ===\n", printf("\n=== Prot Set Tests: %d/%d PASSED (failed=%d) ===\n",
s_passed, s_total, s_failed); s_passed, s_total, s_failed);
@@ -63,6 +63,7 @@
/* 真实定值层(blob 编解码与脏标志在这里)+ 被测胶水层,均原样纳入 */ /* 真实定值层(blob 编解码与脏标志在这里)+ 被测胶水层,均原样纳入 */
#include "prot_set.c" #include "prot_set.c"
#include "stub/cmsis_stub.c"
#include "prot_set_store.c" #include "prot_set_store.c"
/* ===================== 断言框架 ===================== */ /* ===================== 断言框架 ===================== */
+23
View File
@@ -0,0 +1,23 @@
/* Host-only stub: CMSIS-RTOS v2 mutex surface used by prot_set_store.c.
* The host build has no kernel; lock init is exercised as no-lock fallback. */
#ifndef CMSIS_OS2_H
#define CMSIS_OS2_H
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef void *osMutexId_t;
#define osWaitForever 0xFFFFFFFFU
osMutexId_t osMutexNew(const void *attr);
uint32_t osMutexAcquire(osMutexId_t mutex_id, uint32_t timeout);
uint32_t osMutexRelease(osMutexId_t mutex_id);
#ifdef __cplusplus
}
#endif
#endif /* CMSIS_OS2_H */
@@ -0,0 +1,21 @@
/* Host-only CMSIS mutex stub: never creates a lock, so the production
* no-lock fallback remains the exercised path in the pure host test. */
#include "cmsis_os2.h"
osMutexId_t osMutexNew(const void *attr)
{
(void)attr;
return NULL;
}
uint32_t osMutexAcquire(osMutexId_t mutex_id, uint32_t timeout)
{
(void)mutex_id; (void)timeout;
return 0U;
}
uint32_t osMutexRelease(osMutexId_t mutex_id)
{
(void)mutex_id;
return 0U;
}