Files
STM32F4-Base/App/protocol/iec104/iec104_source.c
T
wandering1 90cc9a7d99 feat(iec104): 把 104 骨架完整迁到 MCU 板端并在台架跑通总召
把 IEC104 从模拟器端整体搬到板端:协议栈原先由独立 iec104Task 驱动,
现在改为 netTask 单 owner 的 threadless 驱动,退役独立任务。

驱动与后端:
- 新增 iec104_net_mcu.c/.h,实现 IEC104_Net.h 的 11 个 ABI 函数,
  用槽表加单调句柄映射 net_socket 的单 fd 模型;CLIENT 拆除只走
  net_drop_conn_locked,绝不 net_close 监听 fd。
- net_socket 增 5 个 owner-only 接口(net_accept_locked、
  net_drop_conn_locked、net_pending_bytes、net_send_try、
  net_mono_now_ms)。
- iec104_serv.c 重写为 iec104_serv_net_tick(),在 netTask 1ms 主循环
  里驱动 core;无 osDelay/阻塞调用,喂狗是第一句。
- Src/freertos.c 删除 iec104Task 三件套,对应栈水位探针表项同步删除。

内存:目标板 192KB SRAM 装不下 vendor 默认容量档,按实测裁剪到
skeleton 档(TCP 缓冲、业务池、SOE 256->128、值槽密集化),
RW_IRAM1 118,408 B / 90.3%,留 2,178 B 余量。

台架修复(只在真硬件暴露):
- SNTP s_ctx.fd 零初始化后为 0,而 net fd 0 是合法槽位下标,
  首次代次变化时误 net_close(0) 关掉 ftpTask 的监听槽,导致 104
  连接被 FTP 的 220 banner 抢走;改为显式 .fd = -1。
- Accept 幂等:单 fd 模型下 vendor 每轮重试 Accept 会拿到同一 fd,
  后端改为会话在役时返 WOULD_BLOCK,Close 不再清槽。

验证:
- Keil 全量重建 0 error 0 warning,uvprojx 零抖动。
- 模拟器真实 TCP 13/13、transport 10/10。
- netmcu 后端单测 13/13(新增 N12)。
- 台架 serial-boot-test required 全中;板端 2404 总召 129 帧收到
  59 遥信(53 有源、全 IV)+ 16 双点 + 30 遥测(PT1 三相非零、
  UN/频率/温度按未标定置 IV)、遥控选择执行全否定、校时 COT 7。
- 期间顺带修正 UI 漂移自检文案、.serialtest required 陈旧项、
  coding-standard 对 vendor 与外部 ABI 名字的排除口径。
2026-11-18 10:29:18 +08:00

563 lines
31 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
/* 槽位密集化(包 B):rank 表把"索引 -> 槽位"从循环换算改成 O(1) 查表。
* values 只保留真实可见的槽(configured 345 + area_scoped 88 x 4 区 = 697),
* staged/dirty 只保留可写参数(writable 264),省 1025B RAM,代价 2580B Flash。 */
#include "iec104_source_ranks.h"
#define VALUE_SLOTS IEC104_SOURCE_VALUE_SLOTS
static uint32_t values[VALUE_SLOTS];
static uint32_t staged[IEC104_SOURCE_STAGE_SLOTS];
static uint8_t dirty[IEC104_SOURCE_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;
static uint8_t singles[IEC104_DTU_SP_COUNT], single_set[IEC104_DTU_SP_COUNT];
static uint8_t doubles[IEC104_DTU_DP_COUNT];
static int8_t steps[8];
static uint32_t bits[8];
static float measurements[IEC104_DTU_ME_COUNT];
static uint8_t measurement_set[IEC104_DTU_ME_COUNT];
/* 标准参数点表按 (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[17];
#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;
if (area == 0U) { return iec104_source_value_rank[index]; }
r = iec104_source_scope_rank[index];
if (r == IEC104_SOURCE_STAGE_NO_RANK) { r = 0U; }
return IEC104_SOURCE_CONFIGURED_TOTAL + (size_t)(area - 1U) * (size_t)IEC104_SOURCE_SCOPED_TOTAL + (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_source_stage_rank[i];
if (r == IEC104_SOURCE_STAGE_NO_RANK) { return false; }
return (dirty[r >> 3] & (1U << (r & 7U))) != 0U;
}
/* 函数功能:把参数索引换算成 staged/dirty 的密集槽位。 */
static size_t stage_slot(size_t i) { return (size_t)iec104_source_stage_rank[i]; }
#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) { 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, residual;
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) ||
!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(singles, 0, sizeof(singles));
memset(single_set, 0, sizeof(single_set)); memset(doubles, 0, sizeof(doubles));
memset(steps, 0, sizeof(steps)); memset(bits, 0, sizeof(bits));
memset(measurements, 0, sizeof(measurements)); memset(measurement_set, 0, sizeof(measurement_set));
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) { 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;
}
if (single_set[index]) { v = singles[index]; q = SIM_QUALITY; }
return IEC60870_SinglePointInformation_Create(&out->single, p.ioa, v, q) == IEC60870_ASDU_OK;
}
if (p.type == 3U) {
n = index - 59U; v = doubles[n]; q = v == 0U ? NO_SOURCE_QUALITY : SIM_QUALITY;
return IEC60870_DoublePointInformation_Create(&out->double_point, p.ioa, v, q) == IEC60870_ASDU_OK;
}
n = index - 75U;
if (bindings.measurement != NULL && !bindings.measurement(bindings.context, p.source_addr, &f, &q)) {
f = 0.0f; q = NO_SOURCE_QUALITY;
}
if (measurement_set[n]) { f = measurements[n]; q = SIM_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 即可,模拟状态数组
* (singles/doubles/steps/measurements/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; } }