7d1db02164
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 项的出厂默认 值与点表字面量不同,主站读到的是真实模型的值;绑定真实源后定值区 切换一律拒绝(单套活跃值无原子整区事务)。
720 lines
30 KiB
C
720 lines
30 KiB
C
/*
|
||
* 模块名称:保护定值模型(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;
|
||
}
|