Files
STM32F4-Base/App/iec60870/104/iec104_source.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

564 lines
32 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.
/* 模块名称:DTU数据源与模拟事务;作者:DTU项目组。 */
#include "iec104_source.h"
#include <string.h>
#include <stdlib.h>
#include <float.h>
/* Raw binary32/uint32/uint16/Boolean bits are preserved, never stored as float. */
#define ACTION_COUNT 88U
#define SIM_QUALITY 0x20U
#define NO_SOURCE_QUALITY 0x80U
/* 骨架档裁剪开关(默认未定义 = 全功能,行为逐字节不变)。
* 定义 IEC104_SOURCE_NO_VALUE_STORE 后不分配 values/staged/dirty 三张表,
* 参数区退化为"结构完整、恒出厂默认、只读不可固化":
* - 读:回落到 typed 表的 initial 字面量,与 init() 写入的值完全一致;
* - 预置(PRE/SOL)与标准参数装载:显式拒绝并计数,不静默丢弃。
* 全功能档(模拟器/产品默认面)不受影响。 */
#ifndef IEC104_SOURCE_NO_VALUE_STORE
/* 消费者收窄:只保留 17 个真实消费者的值/预置槽位。
* SN0 全体 17 个;SN1..4 各 9 个区域消费者,合计 53 个值槽;
* staged/dirty 覆盖同一 17 项,对应 68B + 3B RAM。 */
#define VALUE_SLOTS (IEC104_DTU_CONSUMER_COUNT + 4U * IEC104_DTU_SCOPED_CONSUMER_COUNT)
#define STAGE_SLOTS IEC104_DTU_CONSUMER_COUNT
#define DIRTY_BYTES ((STAGE_SLOTS + 7U) / 8U)
static uint32_t values[VALUE_SLOTS];
static uint32_t staged[STAGE_SLOTS];
static uint8_t dirty[DIRTY_BYTES];
#endif
static IEC104_RemoteParameterRequest_t owner;
static bool stage_active, stage_complete;
static iec104_source_bindings_t bindings;
static iec104_source_stats_t stats;
/* 模拟注入通道已删除:单点/双点/测量值三张置位表与值表既无写者也无导出写 API,
* 读出恒为“零值 + 无效品质”,直接由常量取代,不再占 RAM。
* 仅保留仍被 iec104_source_find() 读取的 steps/bits(IOA 0x1201..0x1208 与
* 0x1301..0x1308 的返回信息),删掉会把“返回 0 + 品质”变成“未知地址”。 */
static int8_t steps[8];
static uint32_t bits[8];
/* 标准参数点表按 (CA,IOA) 升序借用给 IEC104_Parameter 模块。
* 只有 common_address 是运行期值(同实例同一CA),故只在这里保留20行实测可知:
* 整表仍是 RAM,但用 4 字节索引函数代替 120 行逐字段赋值,代码与 Flash 均更省。 */
static IEC104_ParameterPoint_t standard_points[IEC104_DTU_STANDARD_COUNT];
static IEC104_ParameterValue_t standard_values[IEC104_DTU_STANDARD_COUNT];
static uint64_t clock_utc, clock_mono;
#ifndef IEC104_SOURCE_NO_VALUE_STORE
static iec104_source_change_t changes[IEC104_DTU_CONSUMER_COUNT];
#endif
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; }
#ifndef IEC104_SOURCE_NO_VALUE_STORE
static float bits_float(uint32_t b) { float v; memcpy(&v, &b, 4U); return v; }
#endif
/* 函数功能:将区域参数索引换算为压缩RAM槽位。 */
#ifndef IEC104_SOURCE_NO_VALUE_STORE
static size_t slot(size_t index, uint16_t area)
{
uint16_t r = iec104_dtu_parameter_rank(index, area == 0U ? 1U : 0U);
if (r == IEC104_DTU_NO_RANK) { return 0U; } /* caller only passes visible consumers */
return area == 0U ? (size_t)r :
(size_t)IEC104_DTU_CONSUMER_COUNT + (size_t)(area - 1U) * (size_t)IEC104_DTU_SCOPED_CONSUMER_COUNT + (size_t)r;
}
/* 裁剪档无压缩槽位表,slot() 不参与编译。 */
#endif
/* 函数功能:丢弃预置和事务身份,不改变已固化值。 */
static void clear_stage(void)
{
stage_active = false; stage_complete = false;
#ifndef IEC104_SOURCE_NO_VALUE_STORE
memset(dirty, 0, sizeof(dirty));
#endif
memset(&owner, 0, sizeof(owner));
}
/* 函数功能:校验预置事务所属服务、连接和站点身份。 */
static bool same_owner(const IEC104_RemoteParameterRequest_t *r)
{
return stage_active && owner.identity.slave == r->identity.slave &&
owner.identity.instance_id == r->identity.instance_id && owner.identity.generation == r->identity.generation &&
owner.instance_id == r->instance_id && owner.generation == r->generation &&
owner.station_id == r->station_id && owner.common_address == r->common_address && owner.test == r->test;
}
#ifndef IEC104_SOURCE_NO_VALUE_STORE
/* 函数功能:判定参数是否处于已预置未固化状态(按 stage_rank 映射到位)。 */
static bool is_dirty(size_t i)
{
uint16_t r = iec104_dtu_parameter_rank(i, 1U);
if (r == IEC104_DTU_NO_RANK) { return false; }
return (dirty[r >> 3] & (1U << (r & 7U))) != 0U;
}
/* 函数功能:把参数索引换算成 staged/dirty 的密集槽位。 */
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
/* 函数功能:判定参数是否由完整的真实源回调对负责。 */
static bool mapped(const iec104_dtu_parameter_t *p, uint16_t area, uint16_t *id, float *scale)
{
return bindings.parameter_read != NULL && bindings.parameter_apply != NULL &&
(!p->area_scoped || area == stats.current_area) && iec104_dtu_protection_mapping(p->ioa, id, scale);
}
/* 函数功能:从 typed 表字面量还原原始位模式(裁剪档的读回落)。 */
static uint32_t initial_bits(const iec104_dtu_parameter_t *p)
{
return p->tag == 38U ? float_bits((float)strtod(p->initial, NULL)) :
(uint32_t)strtoul(p->initial, NULL, 10);
}
/* 函数功能:读原始TLV位模式;真实源失败不降级为模拟值。 */
static bool read_bits(size_t index, uint16_t area, uint32_t *out)
{
iec104_dtu_parameter_t p; uint16_t id; float scale, v;
if (!iec104_dtu_parameter_visible(index, area) || !iec104_dtu_parameter(index, &p)) { return false; }
if (mapped(&p, area, &id, &scale)) {
if (!bindings.parameter_read(bindings.context, id, &v)) { return false; }
v /= scale;
if (!(v >= 0.0f && v <= 1000000.0f)) { return false; }
if ((p.tag == 1U && v != 0.0f && v != 1.0f) ||
(p.tag == 45U && (v > 65535.0f || (float)(uint32_t)v != v))) { return false; }
*out = p.tag == 38U ? float_bits(v) : (uint32_t)v;
#ifdef IEC104_SOURCE_NO_VALUE_STORE
} else { *out = initial_bits(&p); }
#else
} else { *out = values[slot(index, area)]; }
#endif
return true;
}
/* 函数功能:按原始类型校验预置值和值域。 */
#ifndef IEC104_SOURCE_NO_VALUE_STORE
static bool valid_bits(size_t index, uint32_t raw)
{
iec104_dtu_parameter_t p; double v;
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;
if (!(v >= 0.0)) { return false; }
if ((p.tag == 1U && raw > 1U) || (p.tag == 45U && raw > 65535U) ||
(p.tag == 38U && v > 1000000.0)) { return false; }
if (p.ioa >= 0x9e01U && p.ioa <= 0x9e5dU && raw > 1U) { return false; }
if (p.ioa >= 0xa2c1U && p.ioa <= 0xa2ecU && v <= 0.0) { return false; }
if ((p.ioa == 0x8864U && v > 3.0) || (p.ioa == 0x802fU && v > 23.0)) { return false; }
if (((p.ioa >= 0x8024U && p.ioa <= 0x8026U) || p.ioa == 0x802cU || p.ioa == 0x802dU ||
(p.ioa >= 0x8040U && p.ioa <= 0x8045U) || p.ioa == 0x8054U || p.ioa == 0x8055U ||
p.ioa == 0x8842U || p.ioa == 0x8846U || p.ioa == 0x884aU || p.ioa == 0x884eU ||
p.ioa == 0x8852U) && v <= 0.0) { return false; }
return p.tag == 1U || p.tag == 45U || p.tag == 35U || p.tag == 38U;
}
/* 函数功能:读预置候选或当前值供整批交叉校验。 */
static bool candidate(uint32_t ioa, uint16_t area, float *out)
{
size_t i = iec104_dtu_parameter_index(ioa); uint32_t raw;
if (i >= IEC104_DTU_PARAMETER_COUNT) { return false; }
if (is_dirty(i)) { raw = staged[stage_slot(i)]; } else if (!read_bits(i, area, &raw)) { return false; }
*out = bits_float(raw); return *out >= 0.0f && *out <= 1000000.0f;
}
/* 函数功能:完整校验后原子提交真实源,再发布RAM候选。 */
static bool commit_stage(uint16_t area)
{
size_t i, n = 0U; iec104_dtu_parameter_t p; uint16_t id; float scale;
float high, low;
if (area == 0U && (!candidate(0x8027U, 0U, &low) ||
!candidate(0x8029U, 0U, &high) || low > high)) { return false; }
for (i = 0U; i < IEC104_DTU_PARAMETER_COUNT; ++i) {
if (!is_dirty(i)) { continue; }
if (!valid_bits(i, staged[stage_slot(i)])) { return false; }
(void)iec104_dtu_parameter(i, &p);
if (mapped(&p, area, &id, &scale)) {
if (n >= sizeof(changes) / sizeof(changes[0])) { return false; }
changes[n].id = id;
changes[n++].value = (p.tag == 38U ? bits_float(staged[stage_slot(i)]) : (float)staged[stage_slot(i)]) * scale;
}
}
if (n != 0U && (!bindings.parameter_apply(bindings.context, changes, n, true) ||
!bindings.parameter_apply(bindings.context, changes, n, false))) { return false; }
for (i = 0U; i < IEC104_DTU_PARAMETER_COUNT; ++i) {
if (is_dirty(i)) { values[slot(i, area)] = staged[stage_slot(i)]; }
}
increment(&stats.parameter_commits); return true;
}
#else
/* 函数功能:裁剪档固化入口;无值与预置表,一律按未启用拒绝并计数。 */
static bool commit_stage(uint16_t area)
{
(void)area; ++stats.parameter_rejected;
return false;
}
#endif
/* 函数功能:服务启动恢复typed表默认,观测归零且无源置IV。 */
void iec104_source_init(void)
{
size_t i, a, g, m; iec104_dtu_parameter_t p; uint32_t raw;
memset(&bindings, 0, sizeof(bindings)); memset(&stats, 0, sizeof(stats));
memset(steps, 0, sizeof(steps)); memset(bits, 0, sizeof(bits));
clear_stage(); clock_utc = UINT64_C(946684800000); clock_mono = 0U;
#ifndef IEC104_SOURCE_NO_VALUE_STORE
memset(values, 0, sizeof(values));
for (i = 0U; i < IEC104_DTU_PARAMETER_COUNT; ++i) {
(void)iec104_dtu_parameter(i, &p);
if (!p.configured || !iec104_dtu_parameter_visible(i, 0U)) { continue; }
raw = initial_bits(&p);
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; }
}
}
#else
(void)i; (void)a; (void)p; (void)raw; /* 裁剪档:参数值恒为 typed 表字面量,无需填充 */
#endif
memset(standard_values, 0, sizeof(standard_values));
for (i = 0U; i < IEC104_DTU_STANDARD_COUNT; ++i) {
g = i / 30U; m = i % 30U;
if (g == 0U) { standard_values[i].scaled = m >= 4U ? 655 : 200; }
if (g == 1U) { standard_values[i].scaled = -10000; }
if (g == 2U) { standard_values[i].scaled = 10000; }
}
}
/* 函数功能:启动后、首轮poll前复制平台数据源回调表。 */
void iec104_source_bind(const iec104_source_bindings_t *b)
{
if (b == NULL) { memset(&bindings, 0, sizeof(bindings)); } else { bindings = *b; }
}
size_t iec104_source_count(void) { return IEC104_DTU_GI_COUNT; }
/* 函数功能:构造GI对象,保留真实品质并明确模拟身份。 */
bool iec104_source_point(size_t index, iec104_source_object_t *out)
{
iec104_dtu_point_t p; uint8_t v = 0U, q = NO_SOURCE_QUALITY; float f = 0.0f; size_t n;
if (out == NULL || index >= IEC104_DTU_GI_COUNT) { return false; }
memset(out, 0, sizeof(*out));
if (index < 105U) {
if (!iec104_dtu_point(index, &p)) { return false; }
if (p.type == 1U) {
if (bindings.signal != NULL && !bindings.signal(bindings.context, p.source_addr, &v, &q)) {
v = 0U; q = NO_SOURCE_QUALITY;
}
return IEC60870_SinglePointInformation_Create(&out->single, p.ioa, v, q) == IEC60870_ASDU_OK;
}
if (p.type == 3U) {
v = 0U; q = NO_SOURCE_QUALITY;
return IEC60870_DoublePointInformation_Create(&out->double_point, p.ioa, v, q) == IEC60870_ASDU_OK;
}
if (bindings.measurement != NULL && !bindings.measurement(bindings.context, p.source_addr, &f, &q)) {
f = 0.0f; q = NO_SOURCE_QUALITY;
}
return IEC60870_MeasuredValueShort_Create(&out->measurement, p.ioa, f, q) == IEC60870_ASDU_OK;
}
n = index - 105U;
if (standard_points[n].type_id == 110U) {
return IEC60870_ParameterNormalizedValue_Create(&out->normalized, standard_points[n].ioa,
standard_values[n].normalized, standard_points[n].kind) == IEC60870_ASDU_OK;
}
if (standard_points[n].type_id == 111U) {
return IEC60870_ParameterScaledValue_Create(&out->scaled, standard_points[n].ioa,
standard_values[n].scaled, standard_points[n].kind) == IEC60870_ASDU_OK;
}
return IEC60870_ParameterFloatValue_Create(&out->parameter, standard_points[n].ioa,
standard_values[n].short_float, standard_points[n].kind) == IEC60870_ASDU_OK;
}
/* 函数功能:构造无源电度点的零值和无效品质。 */
bool iec104_source_counter(size_t index, iec104_source_object_t *out)
{
if (index >= 8U || out == NULL) { return false; }
return IEC60870_IntegratedTotalsShort_Create(&out->energy, (uint32_t)(0x6401U + index),
0.0f, NO_SOURCE_QUALITY) == IEC60870_ASDU_OK;
}
/* 函数功能:查运行可见IOA,诊断别名和未知地址不伪造零值成功。 */
bool iec104_source_find(uint32_t ioa, iec104_source_object_t *out)
{
size_t i; iec104_dtu_point_t p;
if (out == NULL) { return false; }
for (i = 0U; i < 105U; ++i) {
if (iec104_dtu_point(i, &p) && p.ioa == ioa) { return iec104_source_point(i, out); }
}
for (i = 0U; i < 120U; ++i) {
if (standard_points[i].ioa == ioa) { return iec104_source_point(i + 105U, out); }
}
if (ioa >= 0x1201U && ioa <= 0x1208U) {
return IEC60870_StepPositionInformation_Create(&out->step, ioa, steps[ioa - 0x1201U], 0U,
SIM_QUALITY) == IEC60870_ASDU_OK;
}
if (ioa >= 0x1301U && ioa <= 0x1308U) {
return IEC60870_BitString32_Create(&out->bits, ioa, bits[ioa - 0x1301U], SIM_QUALITY) == IEC60870_ASDU_OK;
}
return ioa >= 0x6401U && ioa <= 0x6408U && iec104_source_counter(ioa - 0x6401U, out);
}
/* 函数功能:命令点表模板;65点按IOA严格升序,常量常驻Flash不占RAM。 */
/* 点位由型号固定,生成规则见下方注记;类型位为45..51与58..64两族对照。 */
static const IEC104_CommandPoint_t command_points[IEC104_DTU_COMMAND_COUNT] = {
/* 19点:0x6001..0x6013,45单点/46双点交替 */
{ UINT32_C(0x6001), UINT16_C(0x0081), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6002), UINT16_C(0x0102), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6003), UINT16_C(0x0102), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6004), UINT16_C(0x0102), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6005), UINT16_C(0x0102), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6006), UINT16_C(0x0102), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6007), UINT16_C(0x0102), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6008), UINT16_C(0x0102), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6009), UINT16_C(0x0102), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x600A), UINT16_C(0x0102), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x600B), UINT16_C(0x0102), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x600C), UINT16_C(0x0102), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x600D), UINT16_C(0x0102), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x600E), UINT16_C(0x0102), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x600F), UINT16_C(0x0102), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6010), UINT16_C(0x0102), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6011), UINT16_C(0x0102), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6012), UINT16_C(0x0081), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6013), UINT16_C(0x0081), IEC104_COMMAND_MODE_SELECT_EXECUTE },
/* 8点:0x6101..0x6108,47升降 */
{ UINT32_C(0x6101), UINT16_C(0x0204), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6102), UINT16_C(0x0204), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6103), UINT16_C(0x0204), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6104), UINT16_C(0x0204), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6105), UINT16_C(0x0204), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6106), UINT16_C(0x0204), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6107), UINT16_C(0x0204), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6108), UINT16_C(0x0204), IEC104_COMMAND_MODE_SELECT_EXECUTE },
/* 30点:0x6201..0x621E,49标度 */
{ UINT32_C(0x6201), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6202), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6203), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6204), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6205), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6206), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6207), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6208), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6209), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x620A), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x620B), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x620C), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x620D), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x620E), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x620F), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6210), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6211), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6212), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6213), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6214), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6215), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6216), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6217), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6218), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x6219), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x621A), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x621B), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x621C), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x621D), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
{ UINT32_C(0x621E), UINT16_C(0x0810), IEC104_COMMAND_MODE_SELECT_EXECUTE },
/* 8点:0x6301..0x6308,51位串,仅直接执行 */
{ UINT32_C(0x6301), UINT16_C(0x2040), IEC104_COMMAND_MODE_DIRECT },
{ UINT32_C(0x6302), UINT16_C(0x2040), IEC104_COMMAND_MODE_DIRECT },
{ UINT32_C(0x6303), UINT16_C(0x2040), IEC104_COMMAND_MODE_DIRECT },
{ UINT32_C(0x6304), UINT16_C(0x2040), IEC104_COMMAND_MODE_DIRECT },
{ UINT32_C(0x6305), UINT16_C(0x2040), IEC104_COMMAND_MODE_DIRECT },
{ UINT32_C(0x6306), UINT16_C(0x2040), IEC104_COMMAND_MODE_DIRECT },
{ UINT32_C(0x6307), UINT16_C(0x2040), IEC104_COMMAND_MODE_DIRECT },
{ UINT32_C(0x6308), UINT16_C(0x2040), IEC104_COMMAND_MODE_DIRECT },
};
/* 函数功能:返回只读命令点表;点位模板常量常驻Flash,不再占RAM。
* 点表不再逐点存公共地址,CA由命令模块按实例站点校验,故本表可跨CA共用。 */
const IEC104_CommandPoint_t *iec104_source_commands(uint16_t ca, size_t *count)
{
(void)ca;
if (count != NULL) { *count = IEC104_DTU_COMMAND_COUNT; }
return command_points;
}
/* 函数功能:骨架档拒绝一切遥控命令,绝无副作用。
* 设计(2026-11-18 裁定的方案 B):骨架阶段没有任何物理输出接缝——数据源绑定
* 只覆盖遥信/遥测/定值,不含遥控——此时若把命令当"已启动"回肯定确认,vendor 会
* 依次回 COT 7 肯定确认、COT 11 返回信息、COT 10 肯定终止,主站由此认定开关真的
* 被操作过,而设备侧只改了一个 RAM 变量。因此对全部命令点、选择与执行两段一律返
* 回 IEC104_COMMAND_ACTION_NOT_STARTED:vendor 据此回否定确认(COT 7 + P/N=1)
* 并结束事务,既不产生返回信息也不排 ACT_TERM,与割接前"除 YK11/YK12 外一律否定
* 确认"的对外行为对齐。
* 恢复真实出口时:把有出口的分支改成调用对应驱动并返回 STARTED 即可;模拟注入通道
* 已随"无写者"核实删除(iec104_source.o 的 ZI 5912 -> 5624,省 288B;比数组
* 名义总和 284B 多 4B,因为两处 2 字节对齐空隙一并消失:doubles 之后到 bits、
* measurement_set 之后到 standard_points 各 2B),故恢复出口须重新引入所需状态表。
* 仅保留仍被 iec104_source_find() 读取的 steps/bits(IOA 0x1201..0x1208 与
* 0x1301..0x1308 的返回信息),其余注入通道已删除;当前无人置位,
* steps/bits 的读出恒为"零值 + IV/SB"。 */
IEC104_CommandActionResult_t iec104_source_command(void *context, const IEC104_CommandRequest_t *r)
{
(void)context; (void)r;
return IEC104_COMMAND_ACTION_NOT_STARTED;
}
/* 函数功能:列举动作反馈IOA;容量不足不写,WAIT不重执行动作。 */
size_t iec104_source_command_feedback(uint32_t ioa, uint32_t *out, size_t capacity)
{
uint32_t first; size_t n = 1U;
if (out == NULL || capacity == 0U) { return 0U; }
if (ioa >= 0x6002U && ioa <= 0x6011U) { first = 0x1001U + ioa - 0x6002U; if (ioa == 0x6002U) { n = 3U; } }
else if (ioa == 0x6001U) { first = 9U; }
else if (ioa == 0x6012U) { first = 0x16U; }
else if (ioa == 0x6013U) { first = 0x26U; }
else if (ioa >= 0x6101U && ioa <= 0x6108U) { first = 0x1201U + ioa - 0x6101U; }
else if (ioa >= 0x6201U && ioa <= 0x621eU) { first = 0x4001U + ioa - 0x6201U; }
else if (ioa >= 0x6301U && ioa <= 0x6308U) { first = 0x1301U + ioa - 0x6301U; }
else { return 0U; }
if (capacity < n) { return 0U; }
out[0] = first; if (n == 3U) { out[1] = 0x11U; out[2] = 0x28U; } return n;
}
/* 函数功能:按原始TLV类型和小端顺序读取已固化参数。 */
bool iec104_source_remote_read(uint16_t area, uint32_t ioa, iec104_source_value_t *out)
{
size_t i = iec104_dtu_parameter_index(ioa), b; uint32_t raw;
iec104_dtu_parameter_t p;
if (out == NULL || !iec104_dtu_parameter(i, &p) || !read_bits(i, area, &raw)) { return false; }
out->tag = p.tag; out->length = p.tag == 1U ? 1U : (p.tag == 45U ? 2U : 4U);
for (b = 0U; b < 4U; ++b) { out->bytes[b] = (uint8_t)(raw >> (8U * b)); }
return true;
}
static IEC104_RemoteParameterLookupResult_t remote_lookup(void *context,
const IEC104_RemoteParameterRequest_t *r, size_t ordinal, uint32_t ioa,
IEC104_RemoteParameterFrame_t *frame)
{
size_t i, n = 0U; iec104_dtu_parameter_t p; iec104_source_value_t value;
IEC104_RemoteParameterAddResult_t result;
(void)context;
if (r->sn >= IEC104_DTU_AREA_COUNT) { return IEC104_REMOTE_PARAMETER_LOOKUP_ERROR; }
if (r->count == 0U) {
for (i = 0U; i < IEC104_DTU_PARAMETER_COUNT; ++i) {
if (iec104_dtu_parameter_visible(i, r->sn) && n++ == ordinal) { break; }
}
if (i == IEC104_DTU_PARAMETER_COUNT) { return IEC104_REMOTE_PARAMETER_LOOKUP_END; }
(void)iec104_dtu_parameter(i, &p); ioa = p.ioa;
}
if (!iec104_source_remote_read(r->sn, ioa, &value)) { return IEC104_REMOTE_PARAMETER_LOOKUP_UNKNOWN; }
result = IEC104_RemoteParameter_Add_Element(frame, ioa, value.tag, value.bytes, value.length);
if (result == IEC104_REMOTE_PARAMETER_ADD_FULL) { return IEC104_REMOTE_PARAMETER_LOOKUP_FULL; }
return result == IEC104_REMOTE_PARAMETER_ADD_OK ? IEC104_REMOTE_PARAMETER_LOOKUP_ADDED : IEC104_REMOTE_PARAMETER_LOOKUP_ERROR;
}
static IEC104_RemoteParameterActionResult_t remote_action(void *context,
const IEC104_RemoteParameterRequest_t *r, IEC104_RemoteParameterArea_t *area)
{
size_t e, i, b; uint32_t raw; iec104_dtu_parameter_t p;
IEC104_RemoteParameterElement_t element;
bool ok;
(void)context;
#ifdef IEC104_SOURCE_NO_VALUE_STORE
(void)e; (void)i; (void)b; (void)raw; (void)p; (void)element;
#endif
if (r == NULL) { return IEC104_REMOTE_PARAMETER_ACTION_REJECTED; }
if (r->operation == IEC104_REMOTE_PARAMETER_OP_CANCEL || r->operation == IEC104_REMOTE_PARAMETER_OP_DISCARD) {
clear_stage(); return IEC104_REMOTE_PARAMETER_ACTION_APPLIED;
}
if (r->operation == IEC104_REMOTE_PARAMETER_OP_READ_AREA && area != NULL) {
area->current = stats.current_area; area->minimum = 0U; area->maximum = 4U;
return IEC104_REMOTE_PARAMETER_ACTION_APPLIED;
}
if (r->sn >= 5U || r->test) { return IEC104_REMOTE_PARAMETER_ACTION_REJECTED; }
if (r->operation == IEC104_REMOTE_PARAMETER_OP_SWITCH_AREA) {
/* A bound real model has a single bank; switching without an atomic
* whole-bank platform transaction would change the meaning of live data. */
if (stage_active || bindings.parameter_read != NULL) { return IEC104_REMOTE_PARAMETER_ACTION_REJECTED; }
stats.current_area = r->sn; return IEC104_REMOTE_PARAMETER_ACTION_APPLIED;
}
if (r->operation == IEC104_REMOTE_PARAMETER_OP_SOLIDIFY) {
ok = same_owner(r) && owner.sn == r->sn && stage_complete && commit_stage(r->sn);
clear_stage(); return ok ? IEC104_REMOTE_PARAMETER_ACTION_APPLIED : IEC104_REMOTE_PARAMETER_ACTION_REJECTED;
}
if (r->operation != IEC104_REMOTE_PARAMETER_OP_PRESET) { return IEC104_REMOTE_PARAMETER_ACTION_REJECTED; }
#ifdef IEC104_SOURCE_NO_VALUE_STORE
/* 裁剪档:无预置表,预置一律显式拒绝并计数(不静默丢弃)。 */
++stats.parameter_rejected; clear_stage();
return IEC104_REMOTE_PARAMETER_ACTION_REJECTED;
#else
if (r->first_frame) { clear_stage(); owner = *r; owner._data = NULL; owner._length = 0U; stage_active = true; }
if (!same_owner(r) || owner.sn != r->sn || stage_complete) { clear_stage(); return IEC104_REMOTE_PARAMETER_ACTION_REJECTED; }
for (e = 0U; e < r->count; ++e) {
if (!IEC104_RemoteParameter_Get_Element(r, e, &element)) { clear_stage(); return IEC104_REMOTE_PARAMETER_ACTION_REJECTED; }
i = iec104_dtu_parameter_index(element.ioa);
if (!iec104_dtu_parameter_visible(i, r->sn)) { clear_stage(); return IEC104_REMOTE_PARAMETER_ACTION_UNKNOWN_IOA; }
(void)iec104_dtu_parameter(i, &p);
if (!p.writable || element.tag != p.tag || element.length != (p.tag == 1U ? 1U : (p.tag == 45U ? 2U : 4U)) || is_dirty(i)) {
clear_stage(); return IEC104_REMOTE_PARAMETER_ACTION_REJECTED;
}
raw = 0U;
for (b = 0U; b < element.length; ++b) { raw |= (uint32_t)element.value[b] << (8U * b); }
if (!valid_bits(i, raw)) { clear_stage(); return IEC104_REMOTE_PARAMETER_ACTION_REJECTED; }
{ size_t s = stage_slot(i); staged[s] = raw; dirty[s / 8U] |= (uint8_t)(1U << (s % 8U)); }
}
stage_complete = !r->more_follows;
return IEC104_REMOTE_PARAMETER_ACTION_APPLIED;
#endif
}
const IEC104_RemoteParameterHandlers_t iec104_source_remote_handlers = {remote_action, remote_lookup};
/* 函数功能:装配标准参数模块借用的稳定点表和值存储。
* 说明:120 行同 CA,点表按 (CA,IOA) 升序;LOAD 校验和总召编码都用 standard_points。 */
void iec104_source_parameter_config(uint16_t ca, IEC104_ParameterConfig_t *config)
{
size_t i, g, m;
if (config == NULL) { return; }
IEC104_Parameter_Config_Default(config);
for (i = 0U; i < IEC104_DTU_STANDARD_COUNT; ++i) {
g = i / 30U; m = i % 30U;
standard_points[i].common_address = ca;
standard_points[i].ioa = (uint32_t)(0x8601U + g * 0x20U + m);
standard_points[i].kind = g == 0U ? IEC60870_ASDU_KPA_THRESHOLD :
(g == 1U ? IEC60870_ASDU_KPA_LOW_LIMIT :
(g == 2U ? IEC60870_ASDU_KPA_HIGH_LIMIT : IEC60870_ASDU_KPA_SMOOTHING));
standard_points[i].type_id = g == 3U ? 112U : (g == 0U && m >= 4U ? 110U : 111U);
}
config->points = standard_points; config->values = standard_values; config->point_count = 120U;
}
/* 函数功能:校验标准参数装载;TEST不改值,周期许可由核心执行。 */
IEC104_ParameterActionResult_t iec104_source_parameter_action(void *context, const IEC104_ParameterRequest_t *r)
{
size_t i, m, g; bool valid = false;
(void)context;
#ifdef IEC104_SOURCE_NO_VALUE_STORE
(void)i; (void)m; (void)g; (void)valid;
#endif
if (r == NULL || r->phase != IEC104_PARAMETER_PHASE_EXECUTE) { return IEC104_PARAMETER_ACTION_REJECTED; }
if (r->operation != IEC104_PARAMETER_OP_LOAD) {
/* QPA=3 selects periodic transmission; no value mutation is needed.
* Core owns scheduling and must apply its scan enable after acceptance. */
return r->qpa == 3U && r->ioa == 0U ? IEC104_PARAMETER_ACTION_APPLIED : IEC104_PARAMETER_ACTION_REJECTED;
}
#ifdef IEC104_SOURCE_NO_VALUE_STORE
/* 裁剪档:标准参数只读,装载一律显式拒绝并计数(不静默丢弃)。 */
++stats.parameter_rejected;
return IEC104_PARAMETER_ACTION_REJECTED;
#else
i = r->point_index;
if (i >= 120U || standard_points[i].ioa != r->ioa || standard_points[i].type_id != r->type_id) { return IEC104_PARAMETER_ACTION_UNKNOWN_IOA; }
m = i % 30U; g = i / 30U;
if (g == 0U) { valid = (r->type_id == 110U ? r->value.normalized : r->value.scaled) >= 0; }
if (g == 1U) { valid = r->value.scaled >= -10000 && r->value.scaled <= standard_values[60U + m].scaled; }
if (g == 2U) { valid = r->value.scaled <= 10000 && r->value.scaled >= standard_values[30U + m].scaled; }
if (g == 3U) { valid = r->value.short_float >= 0.0f && r->value.short_float <= 60.0f; }
if (!valid) { return IEC104_PARAMETER_ACTION_REJECTED; }
if (!r->test) { standard_values[i] = r->value; increment(&stats.parameter_commits); }
return IEC104_PARAMETER_ACTION_APPLIED;
#endif
}
/* 函数功能:设置仅设备虚拟墙钟的UTC纪元及单调基点。 */
void iec104_source_clock_seed(uint64_t utc_ms, uint64_t mono_ms)
{
clock_utc = utc_ms; clock_mono = mono_ms;
}
/* 函数功能:按同一单调时基推进设备虚拟UTC毫秒。 */
uint64_t iec104_source_clock_ms(uint64_t mono_ms)
{
return clock_utc + (mono_ms >= clock_mono ? mono_ms - clock_mono : 0U);
}
/* 函数功能:应用成熟校时模块换算结果;不调用操作系统设时。 */
bool iec104_source_clock_set(void *context, const IEC104_ClockSynchronizationRequest_t *r)
{
(void)context;
if (r == NULL) { return false; }
iec104_source_clock_seed(r->utc_ms, r->base_ms); stats.synchronized = true; increment(&stats.clock_sets);
return true;
}
/* 函数功能:以固定UTC+8日历读设备墙钟,未校时保留IV。 */
bool iec104_source_clock_read(void *context, const IEC104_ClockSynchronizationReadRequest_t *r, IEC60870_CP56Time2a_t *out)
{
uint64_t ms, seconds;
(void)context;
if (r == NULL || out == NULL) { return false; }
ms = iec104_source_clock_ms(r->base_ms);
seconds = ms / 1000U;
if (seconds > IEC60870_TIME_MAX_SECONDS) { return false; }
memset(out, 0, sizeof(*out));
if (!IEC60870_Time_Seconds_To_Local((uint32_t)(ms / 1000U), (uint16_t)(ms % 1000U), &out->time)) { return false; }
out->has_weekday = 1U; out->is_invalid = stats.synchronized ? 0U : 1U; return true;
}
void iec104_source_stats(iec104_source_stats_t *out) { if (out != NULL) { *out = stats; } }