Files
STM32F4-Base/App/algo/prot_set.c
T
wandering1 7d1db02164 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 项的出厂默认
值与点表字面量不同,主站读到的是真实模型的值;绑定真实源后定值区
切换一律拒绝(单套活跃值无原子整区事务)。
2026-11-19 15:48:21 +08:00

720 lines
30 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.
/*
* 模块名称:保护定值模型(P1,定值校验和 载体)——实现
*(保护功能清单见 docs/算法/继电保护功能复现规划.md)
* 模块功能:见 prot_set.h。纯逻辑,零平台依赖(仅 stdint.h + size_t + 自身头);
* 写事务保护只持有**两个函数指针**(prot_set_lock_t),由平台侧在安装时注入,
* 本文件不认识任何 RTOS/HAL 符号——固件、模拟器、主机单测三方共用同一份源码。
*
* ⚠ 默认值/范围为拟定值(参考 EEPROM 出厂默认表不在本仓库,规划 §10.3 待补);
* 通讯地址逐项对照参考 Comm/Pub/Const_CommSetPara.c g_tCommSetParaTab。
*
* 量纲口径(「数据可信」下游常数按工程量重定一项复核,2026-10-25):A/V 项 = **二次值**工程量,
* 标称基准 100 V / 1 A(UA/UB/UC 相电压、3U0、OV/UV 同域——OV 120 = 1.2×Un、
* UV 20 = 0.2×Un、3U0 15 = 0.15×Un;OC1/2/3 = 10/5/2 ×Ir、OL = 1.0×Ir,
* 三段递升与过负荷低于速断均自洽)。ADC 帧仅在 adc_cal VALID 置位后才处
* 于此域(未标定 = 引脚电压域,由未标定即闭锁停走判据,见 protect_task.c);
* min/max 范围覆盖 0~4×标称,无需随这一项改动数值——换算依据与三处下游
* 常数同源,见 docs/算法/采集与算法层设计说明.md §13.7。
*
* 创建日期:2026-10-11
*/
#include "prot_set.h"
/* 元数据表:顺序必须与 prot_set_id_t 严格一致(逐行带地址注释,同 phasor
* k_inst 的朴素行式风格) */
const prot_set_meta_t g_prot_set_meta[PS_ID_COUNT] = {
/* addr ctl default min max 说明 */
{ 0x8856, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, /* OC1 投退 */
{ 0x8857, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, /* OC1 跳闸投退 */
{ 0x8858, 0u, PROT_SET_Q10(10.0), 0, PROT_SET_Q10(100.0) }, /* OC1 电流 A */
{ 0x8859, 0u, PROT_SET_Q10(0.0), 0, PROT_SET_Q10(60000) }, /* OC1 延时 ms */
{ 0x885A, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) },
{ 0x885B, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) },
{ 0x885C, 0u, PROT_SET_Q10(5.0), 0, PROT_SET_Q10(100.0) },
{ 0x885D, 0u, PROT_SET_Q10(500.0), 0, PROT_SET_Q10(60000) },
{ 0x885E, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) },
{ 0x885F, 1u, PROT_SET_Q10(0), 0, PROT_SET_Q10(1) }, /* OC3 默认告警 */
{ 0x8860, 0u, PROT_SET_Q10(2.0), 0, PROT_SET_Q10(100.0) },
{ 0x8861, 0u, PROT_SET_Q10(3000.0), 0, PROT_SET_Q10(60000) },
{ 0x8871, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, /* 过负荷投退 */
{ 0x8872, 1u, PROT_SET_Q10(0), 0, PROT_SET_Q10(1) }, /* 默认告警 */
{ 0x8873, 0u, PROT_SET_Q10(1.0), 0, PROT_SET_Q10(100.0) },
{ 0x8874, 0u, PROT_SET_Q10(10000.0),0, PROT_SET_Q10(60000) },
{ 0x0000, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, /* OV 投退(本地) */
{ 0x8029, 0u, PROT_SET_Q10(120.0), 0, PROT_SET_Q10(200.0) }, /* 过压 V */
{ 0x802A, 0u, PROT_SET_Q10(10000.0),0, PROT_SET_Q10(60000) },
{ 0x0000, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, /* UV 投退(本地) */
{ 0x8027, 0u, PROT_SET_Q10(20.0), 0, PROT_SET_Q10(200.0) }, /* 欠压 V */
{ 0x8028, 0u, PROT_SET_Q10(10000.0),0, PROT_SET_Q10(60000) },
{ 0x888E, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, /* 3U0 投退 */
{ 0x888F, 0u, PROT_SET_Q10(15.0), 0, PROT_SET_Q10(200.0) }, /* 3U0 V */
{ 0x8890, 0u, PROT_SET_Q10(5000.0), 0, PROT_SET_Q10(60000) },
{ 0x0000, 0u, PROT_SET_Q10(0.95), PROT_SET_Q10(0.5), PROT_SET_Q10(1.0) }, /* 过量返回系数 */
{ 0x0000, 0u, PROT_SET_Q10(1.05), PROT_SET_Q10(1.0), PROT_SET_Q10(1.5) }, /* 欠量返回系数 */
{ 0x8820, 0u, PROT_SET_Q10(10000.0),PROT_SET_Q10(100.0), PROT_SET_Q10(500000.0) },
{ 0x8821, 0u, PROT_SET_Q10(100.0), PROT_SET_Q10(1.0), PROT_SET_Q10(200.0) },
{ 0x8825, 0u, PROT_SET_Q10(100.0), PROT_SET_Q10(1.0), PROT_SET_Q10(10000.0) },
{ 0x8826, 0u, PROT_SET_Q10(5.0), PROT_SET_Q10(1.0), PROT_SET_Q10(10.0) },
{ 0x0000, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, /* 全局软压板投退(YK12,B7) */
/* --- 过频 / 低频(B8):地址全 0 = 本地项(参考逐项地址不在
* 本仓库,规划 §5.1 仅示"8820~8882 含低压/低频"类目);
* 默认值/范围**拟定**(DTU 馈线典型量级),待对照参考出厂表修订 --- */
{ 0x0000, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, /* OF 投退(本地) */
{ 0x0000, 0u, PROT_SET_Q10(51.0), PROT_SET_Q10(50.0), PROT_SET_Q10(55.0) }, /* OF 动作频率 Hz */
{ 0x0000, 0u, PROT_SET_Q10(1000.0), 0, PROT_SET_Q10(60000) }, /* OF 延时 ms */
{ 0x0000, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, /* UF 投退(本地) */
{ 0x0000, 0u, PROT_SET_Q10(49.0), PROT_SET_Q10(45.0), PROT_SET_Q10(50.0) }, /* UF 动作频率 Hz */
{ 0x0000, 0u, PROT_SET_Q10(1000.0), 0, PROT_SET_Q10(60000) }, /* UF 延时 ms */
{ 0x0000, 0u, PROT_SET_Q10(0.99), PROT_SET_Q10(0.9), PROT_SET_Q10(1.0) }, /* 过频返回系数 */
{ 0x0000, 0u, PROT_SET_Q10(1.01), PROT_SET_Q10(1.0), PROT_SET_Q10(1.1) }, /* 低频返回系数 */
};
static volatile uint32_t s_val[2][PS_ID_COUNT];
/* 双缓冲值区(uint32 承载 int32,校验和按字覆盖)
* B7:写者改影子区后单字交换 s_act,
* 读侧(protectTask selfcheck/get)永远看到一致快照
* 带 volatile:提交顺序(影子区写完 → 发布封存对 →
* 交换活跃区)必须真的按这个顺序落到内存,编译器
* 不得把值区读写挪到提交序号前后 */
static volatile uint8_t s_act; /* 活跃区下标(0/1);交换 = 单字存储 */
static volatile uint32_t s_sum; /* 封存的正码(提交窗口内与 s_seq 配对发布) */
static volatile uint32_t s_sumn; /* 封存的反码 */
static volatile uint32_t s_seq; /* 提交序号:奇数 = 提交进行中;见 prot_write_enter */
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 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 位字累加自然回绕)
* 入口参数:vals - PS_ID_COUNT 个字的值区
* 返 回 值:校验和正码
* 函数说明:形参带 volatile——读侧拿提交序号做 seqlock,求和若被编译器整体
* 提到序号读之前,序号校验就形同虚设(非 volatile 的数组访问没有
* 与 volatile 访问之间的顺序约束)
*/
static uint32_t prot_sum_buf(const volatile uint32_t *vals) {
uint32_t sum = 0u;
uint32_t i;
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
sum += vals[i];
}
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 值区
* 入口参数:无
* 返 回 值:无
*/
static void prot_load_defaults(void) {
uint32_t i;
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
s_val[s_act][i] = (uint32_t)g_prot_set_meta[i].def;
}
}
/*
* 函数功能:装载出厂默认值并封存校验和(幂等)
* 入口参数:无
* 返 回 值:无
*/
void prot_set_init(void) {
prot_load_defaults();
s_bad_mask = 0u;
s_locked = 0u;
s_dirty = 0u;
s_seq = 0u; /* 装载期不属于"提交",序号回静止态(偶数) */
s_odd_streak = 0u; /* 宽限计数同步归零:init 是唯一的重来一次入口 */
prot_set_seal();
}
/*
* 函数功能:取最近一次**整表装载/解析**的越界位图
* 入口参数:无
* 返 回 值:bit i = 第 i 项越界
* 函数说明:只由 prot_set_load_raw / prot_set_store_parse 写(头文件把这条
* 契约写死了)。单项/批量增量写入既不写也不清它——增量写入失败一律
* 以返回值表达,看位图会读到上一次整表装载的旧结果。
*/
uint64_t prot_set_bad_mask(void) {
return s_bad_mask;
}
/*
* 函数功能:整表装载外部值(P4 起由 cfg_file 定值段调用),逐项范围校验
* 入口参数:vals - PS_ID_COUNT 个 Q10 值
* 返 回 值:0 全部合法(已装载并封存)/ -1 存在越界项或空指针(整表不装载)
* 函数说明:all-or-nothing——宁可全旧不可半新(定值一致性优先);
* 越界项经 prot_set_bad_mask() 指认。
*/
int prot_set_load_raw(const int32_t *vals) {
uint64_t mask = 0u;
uint32_t cur_act;
volatile uint32_t *shadow;
uint32_t i;
if (vals == 0) {
return -1;
}
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
if ((vals[i] < g_prot_set_meta[i].min) || (vals[i] > g_prot_set_meta[i].max)) {
mask |= (1uLL << i);
}
}
s_bad_mask = mask;
if (mask != 0u) {
return -1;
}
/* 原子装载(B7):写影子区 → 封存 → 单字交换;读侧无中间态。
* 写事务(多写者):校验全在锁外,锁内只做提交,出锁即完成 */
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] = (uint32_t)vals[i];
}
s_sum = prot_sum_buf(shadow);
s_sumn = ~s_sum;
s_locked = 0u;
s_act = (uint8_t)(cur_act ^ 1u);
prot_write_exit();
return 0;
}
/*
* 函数功能:单项写入(范围校验)
* 入口参数:id - 定值项编号;q10 - Q10 定点值
* 返 回 值:0 / -1 越界或非法编号拒写(原值不动)
* 函数说明:**不自动重封校验和**——批量改完必须显式 prot_set_seal(),
* 否则 selfcheck 判"定值被非法改写"(参考系统改定值走重写整表)。
*/
int prot_set_set(prot_set_id_t id, int32_t q10) {
if (id >= PS_ID_COUNT) {
return -1;
}
if ((q10 < g_prot_set_meta[id].min) || (q10 > g_prot_set_meta[id].max)) {
return -1;
}
s_val[s_act][(uint32_t)id] = (uint32_t)q10;
return 0;
}
/*
* 函数功能:单项**原子**写入+封存(B7,收口 B5 竞态窗口)
* 入口参数:id - 定值项编号;q10 - Q10 定点值
* 返 回 值:0 / -1 越界或非法编号拒写(原值不动)
* 函数说明:影子区拷贝 → 改影子 → 按影子重封校验和 → 单字交换活跃区。
* selfcheck 任何时刻看到的都是"值区与封存一致"的完整快照
* (区别于 prot_set_set+seal 批处理路径;两路径勿在一次批处理中交错)。
* 置脏标志 → 104 任务通知 defaultTask(配置引擎属主)落盘。
*/
int prot_set_set_sealed(prot_set_id_t id, int32_t q10) {
uint32_t cur_act;
volatile uint32_t *shadow;
if (!prot_id_valid(id)) {
return -1;
}
if ((q10 < g_prot_set_meta[id].min) || (q10 > g_prot_set_meta[id].max)) {
return -1;
}
/* 校验在锁外(失败不进锁);锁内只有提交,无提前返回 */
prot_write_enter();
cur_act = s_act;
shadow = s_val[cur_act ^ 1u];
prot_copy_buf(shadow, s_val[cur_act]);
shadow[(uint32_t)id] = (uint32_t)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;
}
/*
* 函数功能:读一批定值当前值(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;
}
/*
* 函数功能:脏标志三件套(B7 持久化握手)
* 入口参数:无
* 返 回 值:peek/take = 1 存在未落盘改动 / 0 干净;mark 无返回
* 函数说明:peek 非消费(iec104Task 每轮通知,直到落盘成功);
* take 消费(defaultTask 落盘前);mark 写盘失败回置(等下轮重试)。
* 单字节标志,多读者安全;写者只有 set_sealed/apply_batch(置)与
* 属主任务(清/置)。
*/
uint8_t prot_set_dirty_peek(void) {
return s_dirty;
}
uint8_t prot_set_dirty_take(void) {
uint8_t d = s_dirty;
s_dirty = 0u;
return d;
}
void prot_set_dirty_mark(void) {
s_dirty = 1u;
}
/*
* 函数功能:读定值 Q10 原值
* 入口参数:id - 定值项编号
* 返 回 值:Q10 值;非法编号返回 0
*/
int32_t prot_set_get(prot_set_id_t id) {
if (id >= PS_ID_COUNT) {
return 0;
}
return (int32_t)s_val[s_act][(uint32_t)id];
}
/*
* 函数功能:读定值工程量浮点值
* 入口参数:id - 定值项编号
* 返 回 值:Q10 → float;非法编号返回 0.0
*/
float prot_set_get_f(prot_set_id_t id) {
return PROT_SET_FROM_Q10(prot_set_get(id));
}
/*
* 函数功能:读投退/枚举项
* 入口参数:id - 定值项编号
* 返 回 值:!=0 视为投入(1/0)
*/
uint8_t prot_set_get_ctl(prot_set_id_t id) {
return (prot_set_get(id) != 0) ? 1u : 0u;
}
/*
* 函数功能:实时计算校验和(不读封存值)
* 入口参数:无
* 返 回 值:sum32 正码
*/
uint32_t prot_set_checksum(void) {
return prot_sum_buf(s_val[s_act]);
}
/*
* 函数功能:封存当前值区的正/反码对(合法改定值闭环的最后一步)
* 入口参数:无
* 返 回 值:无
* 函数说明:封存同时解除闭锁——selfcheck 失配后的唯一合法解锁路径。
* ⚠ 批处理路径(prot_set_set 多次 + 本函数收尾)在 set 与 seal
* 之间存在"已改值未封存"窗口,selfcheck 会如实判失配(防篡改语义);
* 板端单项写一律走 prot_set_set_sealed(原子,无此窗口)。
*/
void prot_set_seal(void) {
s_sum = prot_sum_buf(s_val[s_act]);
s_sumn = ~s_sum;
s_locked = 0u;
}
/*
* 函数功能:定值自检(定值校验和)——重算 sum32 并与封存值比对
* 入口参数:无
* 返 回 值:0 通过 / -1 失配(已置闭锁)
* 函数说明:失配 → s_locked 置位并保持,直到下一次 seal;
* 元件层每拍读 prot_set_locked() 决定整体复位(联动闭锁)。
* 读侧无锁,靠两重旁证识别"提交进行中":
* ① 提交序号 s_seq 为奇 = 有写者在提交窗口内 → 本轮不作数;
* ② 起止各读一次序号与封存和,任一变化 = 期间发生过提交 → 本轮不作数。
* 两者只**跳过本轮**,绝不据此判失配——提交途中被巡检撞见就闭锁整台
* 保护,正是多写者引入的安全级风险。真正的失配(值区与封存对不符且
* 没有提交在飞)仍照常闭锁。
* ⚠ fail-safe:跳过必须**有界**。若写者在 prot_write_enter 之后走进
* 永不返回的路径(锁内提前 return 忘了 exit、钩子死锁、被永久抢占),
* s_seq 会永远停在奇数,而"跳过本轮"会让防篡改自检永久失效且无人察觉
* ——保护静默失去整台闭锁能力。故连撞 PROT_SET_ODD_STREAK_MAX 拍即判
* 闭锁:那时已不是"正在提交",而是写者已死,值区不可信。
*/
int prot_set_selfcheck(void) {
uint32_t seq_a = s_seq;
uint32_t sum_a;
uint32_t sum_b;
uint32_t seq_b;
uint8_t act_a;
uint8_t act_b;
uint32_t calc;
if ((seq_a & 1u) != 0u) {
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;
}
if ((calc != sum_a) || (sum_a != ~s_sumn)) {
s_locked = 1u; /* 值区与封存不符:定值被非法改写 → 闭锁 */
}
return (s_locked != 0u) ? -1 : 0;
}
/*
* 函数功能:读闭锁状态
* 入口参数:无
* 返 回 值:1 = 定值非法(保护应整体闭锁)/ 0 = 正常
*/
uint8_t prot_set_locked(void) {
return s_locked;
}
/* ==================== 持久化 blob(B7,纯逻辑) ========================= */
/* 小端编解码(blob 跨端一致;主机单测与 MCU 同一份字节口径) */
/*
* 函数功能:16 位值按小端写入缓冲
* 入口参数:p - 写位置(≥2 字节余量);v - 值
* 返 回 值:无
*/
static void s_put16(uint8_t *p, uint16_t v) {
p[0] = (uint8_t)(v & 0xFFu);
p[1] = (uint8_t)(v >> 8);
}
/*
* 函数功能:32 位值按小端写入缓冲
* 入口参数:p - 写位置(≥4 字节余量);v - 值
* 返 回 值:无
*/
static void s_put32(uint8_t *p, uint32_t v) {
p[0] = (uint8_t)(v & 0xFFu);
p[1] = (uint8_t)((v >> 8) & 0xFFu);
p[2] = (uint8_t)((v >> 16) & 0xFFu);
p[3] = (uint8_t)(v >> 24);
}
/*
* 函数功能:从小端缓冲读 16 位值
* 入口参数:p - 读位置
* 返 回 值:值 uint16_t
*/
static uint16_t s_get16(const uint8_t *p) {
return (uint16_t)((uint32_t)p[0] | ((uint32_t)p[1] << 8));
}
/*
* 函数功能:从小端缓冲读 32 位值
* 入口参数:p - 读位置
* 返 回 值:值 uint32_t
*/
static uint32_t s_get32(const uint8_t *p) {
return (uint32_t)p[0] | ((uint32_t)p[1] << 8) | ((uint32_t)p[2] << 16)
| ((uint32_t)p[3] << 24);
}
/*
* 函数功能:把当前值区序列化为 blob(校验和按值区现算,不依赖封存值)
* 入口参数:p_buf - 输出缓冲;cap - 容量;p_len - 实际长度输出
* 返 回 值:0 / -1 参数非法或容量不足
* 函数说明:落盘是整表字节流,混进两次提交的值就会被原样写进文件、下次开机
* 当合法档案装载回来(校验对是按同一份混合值算的,自洽)。故与
* prot_set_read_batch 同用提交序号做有限次重取:期间有提交即重来。
*/
int prot_set_store_serialize(uint8_t *p_buf, uint32_t cap, uint32_t *p_len) {
uint32_t seq_a = 0u;
uint32_t seq_b;
const volatile uint32_t *vals;
uint32_t sum = 0u;
uint32_t tries = 0u;
uint32_t i;
if ((p_buf == 0) || (p_len == 0) || (cap < PROT_SET_BLOB_SZ)) {
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_put16(p_buf + 4u, (uint16_t)PROT_SET_BLOB_VER);
s_put16(p_buf + 6u, (uint16_t)PS_ID_COUNT);
s_put32(p_buf + PROT_SET_BLOB_SZ - 8u, sum);
s_put32(p_buf + PROT_SET_BLOB_SZ - 4u, ~sum);
*p_len = PROT_SET_BLOB_SZ;
return 0;
}
/*
* 函数功能:解析 blob 并**整表原子**装载(all-or-nothing)
* 入口参数:p_buf/len - blob 字节流
* 返 回 值:0 已装载并封存 / -1 拒绝(magic/版本/长度/校验对不符或任一项
* 越界 → 活跃值区一字不动;越界项经 prot_set_bad_mask() 指认)
* 函数说明:校验在写事务之外完成(只读入参字节流,不碰任何 RAM 状态),
* 全部通过才进锁把值写进影子区并交换——损坏 blob 不可能污染在用的
* 定值(掉电/写坏/版本换代同一路径),也不可能在锁内做无用功。
* ⚠ 校验必须**不写影子区**:影子区是与其他写者共享的暂存面,
* 锁外往里写就等于绕过写事务(另一写者的提交会被覆盖)。
*/
int prot_set_store_parse(const uint8_t *p_buf, uint32_t len) {
uint32_t cur_act;
volatile uint32_t *shadow;
uint32_t sum = 0u;
uint64_t mask = 0u;
uint32_t i;
if ((p_buf == 0) || (len != PROT_SET_BLOB_SZ)) {
return -1;
}
if (s_get32(p_buf) != PROT_SET_BLOB_MAGIC) {
return -1;
}
if (s_get16(p_buf + 4u) != (uint16_t)PROT_SET_BLOB_VER) {
return -1;
}
if (s_get16(p_buf + 6u) != (uint16_t)PS_ID_COUNT) {
return -1;
}
/* 第一遍:只算和 + 查范围,不落任何 RAM */
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
uint32_t v = s_get32(p_buf + PROT_SET_BLOB_HDR_SZ + 4u * i);
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)) {
return -1; /* 校验和正码不符 */
}
if (~sum != s_get32(p_buf + PROT_SET_BLOB_SZ - 4u)) {
return -1; /* 反码对不符 */
}
s_bad_mask = mask;
if (mask != 0u) {
return -1; /* 校验对一致但含越界项:同样整表拒绝 */
}
/* 第二遍:锁内写入影子区并交换(无提前返回,enter/exit 天然成对) */
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_act = (uint8_t)(cur_act ^ 1u);
prot_write_exit();
return 0;
}