2e9272cc8a
引入成熟 IEC 60870-5-104 子站的只读子集(App/protocol/iec60870,28 个源文件 按原字节复制,UPSTREAM.sha256 记录来源,兼容补丁保留全部断言与容量),在其上 装配单属主共享核心(Start/Poll/Stop/Get_Status),并把标准 DTU 演示点表全量 接入为唯一真源。 - iec104_core:threadless 推进,poll 零等待,通知/交互/COV 扫描全部有界; 生命周期区分失败启动待重试、重复启动拒绝、断线保固化 RAM。 - iec104_dtu_table / iec104_source:标准 DTU 全点表注册,无数据源的点读 0, 遥控只做模拟状态可读回,不触碰实际出口。 - iec104_sim:仅窗口与独立服务模式起真实 TCP,无头黄金模式保持确定性假统计。 - test/host/iec104_dtu:独立真实 TCP 11 项、传输层 10 项、生命周期与借用负例。 验证:lvgl_sim 真实 TCP 11/11、传输 10/10,UI 像素回归未回退;AC5 单 TU 编译 0 错误 0 诊断。板端尚未切换:完整库闭包 RAM 超 92% 门禁净增预算 25730B, 结论为停止转实施,记录在 IEC104_MCU最小可行性验证.md。旧实现与 board 服务 保持原样,未提交 MDK 工程改动,未烧板。
1392 lines
71 KiB
C
1392 lines
71 KiB
C
/*
|
||
* 系统命令业务:固定槽FIFO保存104/105/107;独立Type70轮次;固定池保存逐站ACK后动作授权。
|
||
* FIFO只规定确认提交顺序:QRP1等待ACK不再阻塞后续回复,实际复位由应用执行。
|
||
* 站点引用只属于一个所有者;QRP1 ACCEPT把引用从任务转到复位槽,确认仍留FIFO。
|
||
* 两个发送来源各自保存WAIT;所有期限与身份检查均使用Net单调时间和原会话。
|
||
* 首次STOP/断开前按时ACK即确定QRP1授权;自动会话清理保留它,显式Cancel仍可主动放弃。
|
||
* 专用QRP128..255须显式启用,复用QRP1的ACK后授权流程;库不解释专用动作,不清NORMAL。
|
||
* 下文有关QRP1的授权/ACK/取消注释也适用于专用QRP;QRP2仍独立同步清除。
|
||
* TEST=1的105只模拟协议服务:校验成功后普通肯定回显,不调用action、不清事件、不创建真实授权。
|
||
*/
|
||
/*
|
||
* 文件内导航(搜索方括号标记):
|
||
* [COMMON/STORAGE] 编译容量、测试边界、私有状态与引用归属
|
||
* [COMMON/LIFETIME] 固定槽FIFO、引用释放、复位取消及初始化轮次收尾
|
||
* [COMMON/GUARDS] 会话、决定期限、ACK期限及正常STOP让出判定
|
||
* [INIT/STEP] Type70逐站提交与最后凭证交接
|
||
* [FIFO/SUBMIT] Type104/105/107及错误回复按受理顺序提交
|
||
* [REQUEST/VALIDATION] 请求校验、规范化回显副本及满槽丢新
|
||
* [PUBLIC/LIFECYCLE] 配置、静态实例、COI登记及生命周期通知分派
|
||
* [PUBLIC/PROCESS] 有界推进两个发送来源和完成事实,不调用应用
|
||
* [RESET/ACTION] 队首105同步动作及ACK后授权交出
|
||
* [STATUS/SNAPSHOT] 只读查询、最早期限及立即续跑条件
|
||
*/
|
||
#include "IEC104_SystemCommand.h"
|
||
#include "IEC104_BusinessConfig_Internal.h"
|
||
#include "IEC104_TcpServer_Config.h"
|
||
#include "IEC104_Net.h"
|
||
#include "IEC60870_Codec.h"
|
||
#include <string.h>
|
||
|
||
/* [COMMON/STORAGE] 实例与任务均为固定槽;任务数组不移动,只移动order中的槽下标。 */
|
||
#ifndef IEC104_SYSTEM_COMMAND_CAPACITY
|
||
#define IEC104_SYSTEM_COMMAND_CAPACITY IEC104_TCP_SERVER_CAPACITY
|
||
#endif
|
||
#ifndef IEC104_SYSTEM_COMMAND_TASK_CAPACITY
|
||
#define IEC104_SYSTEM_COMMAND_TASK_CAPACITY 4U
|
||
#endif
|
||
/* 广播复位授权独立于FIFO容量;一个广播只占一个任务,却可有多个待ACK的站。
|
||
* 槽满时在调用该站action前否定,不分配堆、不隐式扩大为整机授权。 */
|
||
#ifndef IEC104_SYSTEM_COMMAND_RESET_CAPACITY
|
||
#define IEC104_SYSTEM_COMMAND_RESET_CAPACITY 4U
|
||
#endif
|
||
_Static_assert(IEC104_SYSTEM_COMMAND_CAPACITY > 0U, "SystemCommand needs instances");
|
||
_Static_assert(IEC104_SYSTEM_COMMAND_RESET_CAPACITY > 0U, "SystemCommand needs reset slots");
|
||
_Static_assert(IEC104_SYSTEM_COMMAND_TASK_CAPACITY > 0U &&
|
||
IEC104_SYSTEM_COMMAND_TASK_CAPACITY <= UINT32_MAX / 2U, "SystemCommand needs bounded tasks");
|
||
|
||
/**
|
||
* 功能:专项仅替换外部结果边界;生产构建没有函数指针、测试符号或运行期分支。
|
||
* 输入参数:self/identity——从站服务及请求身份;asdu——待提交应答。
|
||
* 输出参数:ticket——可为NULL,仅最终OK时写入。
|
||
* 返回值:OK已接手;WAIT未接手;ERROR非法;FATAL为连接故障。
|
||
* 说明:票据用于Get_Response_State;HANDED仅表示交接,不是对端ACK。
|
||
*/
|
||
#ifdef IEC104_SYSTEM_COMMAND_TEST_HOOKS
|
||
extern IEC104_TcpSubmitResult_t IEC104_SystemCommand_Test_Send_Response_Tracked(IEC104_Slave_t *,
|
||
const IEC104_SlaveEventIdentity_t *, const IEC60870_Asdu_t *, uint64_t *);
|
||
/**
|
||
* 功能:使用默认业务等级提交应答,同时申请可查询对端ACK的回执。
|
||
* 输入参数:self/identity——从站服务及请求身份;asdu——待提交应答。
|
||
* 输出参数:receipt——必填,仅最终OK时写入服务身份、连接代次和票据。
|
||
* 返回值:OK已接手并建立观察;WAIT未接手,含观察槽耗尽;ERROR非法;FATAL为连接故障。
|
||
* 说明:OK不表示已收到ACK;调用方使用完回执后须调用Release_Ack归还观察资源。
|
||
*/
|
||
extern IEC104_TcpSubmitResult_t IEC104_SystemCommand_Test_Send_Response_Acked(IEC104_Slave_t *,
|
||
const IEC104_SlaveEventIdentity_t *, const IEC60870_Asdu_t *, IEC104_SlaveAckReceipt_t *);
|
||
/**
|
||
* 功能:查询应答票据的待交接、已交接或取消状态。
|
||
* 输入参数:self——从站服务;ticket——提交应答时取得的交接票据。
|
||
* 输出参数:无。
|
||
* 返回值:底层票据状态;实例无效时返回ERROR。
|
||
* 说明:只查询交接历史;HANDED不等于TCP写完或对端确认,需ACK结果时使用回执接口。
|
||
*/
|
||
extern IEC104_ResponseState_t IEC104_SystemCommand_Test_Get_Response_State(const IEC104_Slave_t *, uint64_t);
|
||
/**
|
||
* 功能:查询是历史通信事实,不要求Check_Request为READY;
|
||
* 输入参数:self——本模块实例。
|
||
* receipt——ACK回执。
|
||
* acked_at_ms——ACK确认毫秒时刻。
|
||
* 输出参数:acked_at_ms——ACK确认毫秒时刻的更新结果。
|
||
* 返回值:按处理分支返回IEC104_SLAVE_ACK_ERROR、(IEC104_SlaveAckState_t)IEC104_TcpServer_Get_Ack_State(self->server, receipt->identity.generation, receipt->ticket, acked_at_ms)。
|
||
* 说明:动作提交条件由业务选择相应ACK契约。
|
||
*/
|
||
extern IEC104_SlaveAckState_t IEC104_SystemCommand_Test_Get_Ack_State(const IEC104_Slave_t *,
|
||
const IEC104_SlaveAckReceipt_t *, uint64_t *);
|
||
/**
|
||
* 功能:按公共地址和事件类别统计尚未提交为I帧的NORMAL事件。
|
||
* 输入参数:self——从站服务;common_address——目标站点公共地址;kind——支持的事件类别。
|
||
* 输出参数:count——成功时的匹配数量;error——可选诊断。
|
||
* 返回值:OK统计成功;INVALID_HANDLE/INVALID_ARGUMENT为本层校验失败,其余错误由底层返回。
|
||
* 说明:当前类别筛选为带时标事件;已编号或等待ACK的帧不计入,也不校验当前站点注册关系。
|
||
*/
|
||
extern IEC104_TcpResult_t IEC104_SystemCommand_Test_Count_Pending_Events(const IEC104_Slave_t *,
|
||
uint16_t, IEC104_SlaveEventClass_t, uint32_t *, IEC104_TcpError_t *);
|
||
/**
|
||
* 功能:按公共地址和事件类别丢弃尚未提交为I帧的NORMAL事件。
|
||
* 输入参数:self——从站服务;common_address——目标站点公共地址;kind——支持的事件类别。
|
||
* 输出参数:removed——成功时的删除数量;error——可选诊断。
|
||
* 返回值:OK删除完成;INVALID_HANDLE/INVALID_ARGUMENT为本层校验失败,其余错误由底层返回。
|
||
* 说明:只删除未编号候选,不撤销在途或等待ACK的帧;站点归属由调用业务自行核对。
|
||
*/
|
||
extern IEC104_TcpResult_t IEC104_SystemCommand_Test_Discard_Pending_Events(IEC104_Slave_t *,
|
||
uint16_t, IEC104_SlaveEventClass_t, uint32_t *, IEC104_TcpError_t *);
|
||
#define SYSTEM_SEND(s, i, a, t, p) IEC104_SystemCommand_Test_Send_Response_Tracked(s, i, a, t)
|
||
#define SYSTEM_SEND_ACK(s, i, a, r, p) IEC104_SystemCommand_Test_Send_Response_Acked(s, i, a, r)
|
||
#define SYSTEM_HANDOFF IEC104_SystemCommand_Test_Get_Response_State
|
||
#define SYSTEM_ACK IEC104_SystemCommand_Test_Get_Ack_State
|
||
#define SYSTEM_COUNT IEC104_SystemCommand_Test_Count_Pending_Events
|
||
#define SYSTEM_DISCARD IEC104_SystemCommand_Test_Discard_Pending_Events
|
||
#else
|
||
#define SYSTEM_SEND IEC104_Slave_Send_Response_Tracked_Priority
|
||
#define SYSTEM_SEND_ACK IEC104_Slave_Send_Response_Acked_Priority
|
||
#define SYSTEM_HANDOFF IEC104_Slave_Get_Response_State
|
||
#define SYSTEM_ACK IEC104_Slave_Get_Active_Ack_State
|
||
#define SYSTEM_COUNT IEC104_Slave_Count_Pending_Events
|
||
#define SYSTEM_DISCARD IEC104_Slave_Discard_Pending_Events
|
||
#endif
|
||
|
||
/* DECIDE仅用于合法105;决定完毕原位转REPLY,104/107和校验错误直接进入REPLY。 */
|
||
enum { SYSTEM_DECIDE = 1, SYSTEM_REPLY = 2 };
|
||
/* ARMED还需start_allowed;SENDING持有快照,HANDOFF已归还快照但仍跟踪最后票据。 */
|
||
enum { INIT_IDLE, INIT_ARMED, INIT_SENDING, INIT_HANDOFF, INIT_DONE };
|
||
/* CONFIRM_PENDING同时在FIFO保留确认;WAIT_ACK之后仅复位槽持有请求与站点引用。
|
||
* READY是已确定的复位决定,不再依赖原会话存活;Take交出或显式Cancel才释放。 */
|
||
enum { RESET_EMPTY, RESET_CONFIRM_PENDING, RESET_WAIT_ACK, RESET_READY };
|
||
|
||
typedef struct {
|
||
IEC104_SlaveEventIdentity_t identity; /* 只用受理时身份提交,绝不迁移到新TCP会话。 */
|
||
IEC104_StationSnapshot_t stations; /* 广播固定注册上界;任务地址不变,快照不可复制。 */
|
||
IEC104_Station_t *station; /* 当前目标的一份引用;单播错误为NULL,QRP1 ACCEPT时转交复位槽。 */
|
||
uint64_t receive_serial, accepted_ms; /* 诊断流水号及决定期限起点,等待回复不会刷新。 */
|
||
uint8_t bytes[18], length, phase, cause; /* 104/105/107各11/10/18字节自有副本,不借用事件存储。 */
|
||
unsigned reset_index; /* reset_confirm为true时有效,关联本目标的复位槽。 */
|
||
uint8_t broadcast_cause; /* 受理校验错误COT;0表示校验成功,不能被某站的决定覆盖。 */
|
||
bool occupied, negative, send_waiting, reset_confirm, broadcast, broadcast_decide;
|
||
} SystemTask;
|
||
|
||
typedef struct {
|
||
IEC104_SystemCommandResetRequest_t request; /* Take_Reset最终交出的纯值授权。 */
|
||
IEC104_SlaveAckReceipt_t receipt; /* 仅提交OK后有效;取消和交出时显式Release。 */
|
||
IEC104_Station_t *station; /* 从原任务转来的同一份引用,不重复Acquire。 */
|
||
uint64_t accept_ms; /* ACCEPT回调开始前base_ms,包含回调耗时及待提交时间。 */
|
||
uint8_t phase;
|
||
bool broadcast; /* Take须等待同一广播全部回复及ACK结果确定。 */
|
||
} SystemReset;
|
||
|
||
typedef struct {
|
||
IEC104_StationSnapshot_t stations; /* 含自引用,不允许移动实例或本结构。 */
|
||
IEC104_Station_t *station; /* 当前待提交站,生命周期由stations快照维持,不另持引用。 */
|
||
IEC104_SlaveEventIdentity_t identity; /* 本轮开始时固定;不能改用随后连接的身份重试。 */
|
||
uint64_t round_id, last_ticket; /* 每开始一轮递增;只保存当前轮最后一次成功提交的票据。 */
|
||
uint64_t activation_id; /* 实际ACTIVATED轮次,同TCP STOP/START也变化;先结清旧轮再接纳新编号。 */
|
||
unsigned sent; /* 本轮提交OK的帧数;0用于区分空轮和中断后重试。 */
|
||
uint8_t state, coi, pending_coi; /* 活动轮的coi冻结,重复登记覆盖唯一pending_coi。 */
|
||
bool pending_valid, start_allowed, send_waiting; /* 启动许可避免空站表反复创建快照。 */
|
||
} SystemInitialization;
|
||
|
||
struct IEC104_SystemCommand {
|
||
IEC104_Slave_t *slave;
|
||
IEC104_SlaveEventIdentity_t session;
|
||
IEC104_SystemCommandConfig_t config;
|
||
IEC104_SystemCommandStatus_t status; /* 保存累计计数与已分派状态;调度字段在Get_Status中派生。 */
|
||
SystemTask tasks[IEC104_SYSTEM_COMMAND_TASK_CAPACITY];
|
||
unsigned order[IEC104_SYSTEM_COMMAND_TASK_CAPACITY], count; /* order[0]始终为FIFO队首槽号。 */
|
||
SystemReset resets[IEC104_SYSTEM_COMMAND_RESET_CAPACITY];
|
||
SystemInitialization init;
|
||
bool in_use, in_action; /* in_action只阻止本模块修改入口重入,不保护任意Slave操作。 */
|
||
};
|
||
static IEC104_SystemCommand_t system_command_pool[IEC104_SYSTEM_COMMAND_CAPACITY];
|
||
|
||
/**
|
||
* 功能:[COMMON/LIFETIME] 只归还本模块持有的引用,不撤回发送层已接手的ASDU。
|
||
* 输入参数:self——本模块实例。
|
||
* 输出参数:无。
|
||
* 返回值:true表示句柄属于当前占用的静态实例槽;NULL、池外地址或未占用槽返回false。
|
||
* 说明:直接处理传入的self,不经过其他函数调用。
|
||
*/
|
||
static bool Owned(const IEC104_SystemCommand_t *self)
|
||
{
|
||
unsigned i;
|
||
for (i = 0U; i < IEC104_SYSTEM_COMMAND_CAPACITY; ++i) {
|
||
if (self == &system_command_pool[i]) { return self->in_use; }
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 功能:归还仍由本模块持有的站点引用并清空指针;
|
||
* 输入参数:self——本模块实例。
|
||
* station——逻辑站点。
|
||
* 输出参数:station——逻辑站点的更新结果。
|
||
* 返回值:无。
|
||
* 说明:重复清理不重复归还,不撤销已交接报文。
|
||
*/
|
||
static void Release_Station(IEC104_SystemCommand_t *self, IEC104_Station_t **station)
|
||
{
|
||
if (*station != NULL) {
|
||
(void)IEC104_Slave_Release_Station(self->slave, *station);
|
||
*station = NULL;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:删除任务只移动索引;
|
||
* 输入参数:self——本模块实例。
|
||
* task——业务任务。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* task——业务任务的更新结果。
|
||
* 返回值:无。
|
||
* 说明:其余任务地址不变。新队首须有独立发送机会,不能继承旧队首的WAIT。
|
||
*/
|
||
static void Remove_Task(IEC104_SystemCommand_t *self, SystemTask *task)
|
||
{
|
||
unsigned i, slot = (unsigned)(task - self->tasks);
|
||
bool head = self->count != 0U && self->order[0] == slot;
|
||
Release_Station(self, &task->station);
|
||
if (task->stations._owner != NULL) { (void)IEC104_Slave_StationSnapshot_End(&task->stations); }
|
||
for (i = 0U; i < self->count; ++i) {
|
||
if (self->order[i] == slot) {
|
||
memmove(self->order + i, self->order + i + 1U,
|
||
(self->count - i - 1U) * sizeof(self->order[0]));
|
||
--self->count;
|
||
break;
|
||
}
|
||
}
|
||
memset(task, 0, sizeof(*task));
|
||
if (head && self->count != 0U) { self->tasks[self->order[0]].send_waiting = false; }
|
||
}
|
||
|
||
/**
|
||
* 功能:满槽丢新由Request计数;
|
||
* 输入参数:self——本模块实例。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:按处理分支返回NULL、task。
|
||
* 说明:此处不回收旧任务,也不改变其他任务的受理次序。
|
||
*/
|
||
static SystemTask *Allocate_Task(IEC104_SystemCommand_t *self)
|
||
{
|
||
unsigned i;
|
||
if (self->count == IEC104_SYSTEM_COMMAND_TASK_CAPACITY) { return NULL; }
|
||
for (i = 0U; i < IEC104_SYSTEM_COMMAND_TASK_CAPACITY; ++i) {
|
||
if (!self->tasks[i].occupied) {
|
||
SystemTask *task = &self->tasks[i];
|
||
memset(task, 0, sizeof(*task));
|
||
task->occupied = true;
|
||
self->order[self->count++] = i;
|
||
return task;
|
||
}
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
/**
|
||
* 功能:QRP1取消包括尚未提交的FIFO确认;释放观察槽后迟到ACK不能恢复授权。
|
||
* 输入参数:self——本模块实例。
|
||
* index——索引。
|
||
* timeout——超时状态。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:无。
|
||
* 说明:reset_cancelled_handed只描述发送层接手的可能性,不能证明对端收到。
|
||
*/
|
||
static void Cancel_Reset(IEC104_SystemCommand_t *self, unsigned index, bool timeout)
|
||
{
|
||
SystemReset *reset = &self->resets[index];
|
||
unsigned i;
|
||
if (reset->phase == RESET_EMPTY) { return; }
|
||
++self->status.reset_cancelled;
|
||
if (timeout) { ++self->status.ack_timeouts; }
|
||
if (reset->phase == RESET_WAIT_ACK || reset->phase == RESET_READY) {
|
||
++self->status.reset_cancelled_handed;
|
||
}
|
||
for (i = 0U; i < self->count; ++i) {
|
||
SystemTask *task = &self->tasks[self->order[i]];
|
||
if (task->reset_confirm && task->reset_index == index) { Remove_Task(self, task); break; }
|
||
}
|
||
if (reset->receipt.ticket != 0U) {
|
||
IEC104_Slave_Release_Ack(self->slave, &reset->receipt);
|
||
}
|
||
Release_Station(self, &reset->station);
|
||
memset(reset, 0, sizeof(*reset));
|
||
}
|
||
|
||
/**
|
||
* 功能:一轮结束统一收口:complete冻结已交接事实;empty不计重试且等待新触发。
|
||
* 输入参数:self——本模块实例。
|
||
* complete——bool值。
|
||
* empty——bool值。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:无。
|
||
* 说明:空轮也采用pending,不能把旧值留在ARMED、在下一轮完成后复活旧pending。
|
||
* complete只由非空轮的末帧HANDED产生;逐站提交数增加不代表此处已完成,不等待末帧ACK。
|
||
* 未完成、空轮和取消不改历史完成编号;应用须比较当前激活轮次,不能把旧成功用于新连接放行。
|
||
*/
|
||
static void End_Initialization(IEC104_SystemCommand_t *self, bool complete, bool empty)
|
||
{
|
||
SystemInitialization *init = &self->init;
|
||
bool pending = init->pending_valid;
|
||
if (init->stations._owner != NULL) { (void)IEC104_Slave_StationSnapshot_End(&init->stations); }
|
||
init->station = NULL;
|
||
init->send_waiting = false;
|
||
init->last_ticket = 0U;
|
||
init->sent = 0U;
|
||
if (pending) { init->coi = init->pending_coi; init->pending_valid = false; }
|
||
init->state = complete && !pending ? INIT_DONE : INIT_ARMED;
|
||
init->start_allowed = complete && pending;
|
||
if (complete) {
|
||
++self->status.init_rounds;
|
||
self->status.init_completed_activation_id = init->activation_id;
|
||
}
|
||
else if (empty) { ++self->status.init_empty_rounds; }
|
||
else { ++self->status.init_retries; }
|
||
}
|
||
|
||
/**
|
||
* 功能:STOP/断线通知可能晚于最后一帧的交接;先查询事实,避免把已完整交接的ONCE轮误作重试。
|
||
* 输入参数:self——本模块实例。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:无。
|
||
* 说明:仅非空轮才能到HANDOFF,因此这里的0凭证是有效的直接交接,不是“尚未发送”的初始零值。
|
||
* Cancel时仍PENDING则结束跟踪,但不撤回HIGH原文;晚分派通知冻结的是旧轮完成事实,不是新轮许可。
|
||
*/
|
||
static void Freeze_Initialization(IEC104_SystemCommand_t *self)
|
||
{
|
||
if (self->init.state == INIT_HANDOFF) {
|
||
IEC104_ResponseState_t state = SYSTEM_HANDOFF(self->slave, self->init.last_ticket);
|
||
End_Initialization(self, state == IEC104_RESPONSE_HANDED, false);
|
||
} else if (self->init.state == INIT_SENDING) { End_Initialization(self, false, false); }
|
||
}
|
||
|
||
/**
|
||
* 功能:先处理有专属计数/引用的复位槽,再清普通FIFO,避免QRP1确认被重复计数或重复释放。
|
||
* 输入参数:self——本模块实例。
|
||
* keep_ready——bool值。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:无。
|
||
* 说明:自动清理保留已确定的READY;显式Cancel传false,可用于应用主动放弃及销毁收尾。
|
||
*/
|
||
static void Cancel(IEC104_SystemCommand_t *self, bool keep_ready)
|
||
{
|
||
unsigned i;
|
||
Freeze_Initialization(self);
|
||
for (i = 0U; i < IEC104_SYSTEM_COMMAND_RESET_CAPACITY; ++i) {
|
||
if (!keep_ready || self->resets[i].phase != RESET_READY) { Cancel_Reset(self, i, false); }
|
||
}
|
||
while (self->count != 0U) {
|
||
++self->status.cancelled;
|
||
Remove_Task(self, &self->tasks[self->order[0]]);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:普通STOP/断开及换代先冻结历史ACK事实,再清理未确定的工作。
|
||
* 输入参数:self——本模块实例。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:返回advanced的结果。
|
||
* 说明:同次Poll内ACK与STOP按传输层的实际处理顺序判断,不能用相同毫秒值推断先后。
|
||
* 查询故障仍清理未确定授权并报告失败;已经READY的决定不再查询ACK,也不自动撤销。
|
||
*/
|
||
static bool End_Session(IEC104_SystemCommand_t *self);
|
||
|
||
/**
|
||
* 功能:[COMMON/GUARDS] WAIT_EVENTS先于最终会话状态,避免同代次STOP/START掩盖中间的停用。
|
||
* 输入参数:self——本模块实例。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:按处理分支返回state == IEC104_SLAVE_REQUEST_ERROR || !ended ? IEC104_SLAVE_REQUEST_ERROR : IEC104_SLAVE_REQUEST_STALE、state。
|
||
* 说明:让应用按FIFO分派DEACTIVATED;没有未读通知时才按失效事实清理本模块。
|
||
*/
|
||
static IEC104_SlaveRequestState_t Check_Session(IEC104_SystemCommand_t *self)
|
||
{
|
||
IEC104_SlaveRequestState_t state = IEC104_Slave_Check_Request(self->slave, &self->session);
|
||
self->status.events_pending = state == IEC104_SLAVE_REQUEST_WAIT_EVENTS;
|
||
if (state == IEC104_SLAVE_REQUEST_ERROR ||
|
||
(state != IEC104_SLAVE_REQUEST_WAIT_EVENTS && (!self->status.active || state != IEC104_SLAVE_REQUEST_READY))) {
|
||
bool ended = End_Session(self);
|
||
self->status.active = false;
|
||
return state == IEC104_SLAVE_REQUEST_ERROR || !ended ? IEC104_SLAVE_REQUEST_ERROR : IEC104_SLAVE_REQUEST_STALE;
|
||
}
|
||
return state;
|
||
}
|
||
|
||
/**
|
||
* 功能:调用者先排除禁用的0期限;
|
||
* 输入参数:limit——uint32_t值。
|
||
* accepted——uint64_t值。
|
||
* now——当前时刻。
|
||
* 输出参数:无。
|
||
* 返回值:按处理分支返回0U、limit - (uint32_t)(now - accepted)。
|
||
* 说明:相等即到期,倒退按到期处理,差值确认小于limit后才窄化。
|
||
*/
|
||
static uint32_t Remaining(uint32_t limit, uint64_t accepted, uint64_t now)
|
||
{
|
||
if (now < accepted || now - accepted >= limit) { return 0U; }
|
||
return limit - (uint32_t)(now - accepted);
|
||
}
|
||
|
||
/**
|
||
* 功能:105决定拒绝或QRP1提交前到期均原位留在FIFO;
|
||
* 输入参数:self——本模块实例。
|
||
* task——业务任务。
|
||
* 输出参数:task——业务任务的更新结果。
|
||
* 返回值:无。
|
||
* 说明:不重开期限,不在此发送或释放引用。
|
||
*/
|
||
static void Negative_Reply(IEC104_SystemCommand_t *self, SystemTask *task)
|
||
{
|
||
task->phase = SYSTEM_REPLY;
|
||
task->cause = IEC60870_ASDU_COT_ACTIVATION_CON;
|
||
task->negative = true;
|
||
task->send_waiting = false;
|
||
++self->status.reset_refused;
|
||
}
|
||
|
||
/**
|
||
* 功能:QRP1尚未交接肯定确认:撤销许可,但保留原槽、原文和FIFO位置回复否定。
|
||
* 输入参数:self——本模块实例。
|
||
* index——索引。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:找到待交接确认并改为否定回复返回true;对应FIFO任务缺失时归还资源并返回false。
|
||
* 说明:先解除reset_confirm关联,Cancel_Reset才不会删掉这条回复;站点引用仍由复位槽释放。
|
||
* 转换后使用普通回复入口,不再申请ACK观察槽,也不受旧ACK期限反复取消。
|
||
*/
|
||
static bool Reject_Reset_Confirmation(IEC104_SystemCommand_t *self, unsigned index)
|
||
{
|
||
unsigned i;
|
||
for (i = 0U; i < self->count; ++i) {
|
||
SystemTask *task = &self->tasks[self->order[i]];
|
||
if (task->reset_confirm && task->reset_index == index) {
|
||
task->reset_confirm = false;
|
||
Negative_Reply(self, task);
|
||
Cancel_Reset(self, index, true);
|
||
return true;
|
||
}
|
||
}
|
||
/* CONFIRM_PENDING必须有对应FIFO任务;内部不一致时归还资源并报告失败。 */
|
||
Cancel_Reset(self, index, true);
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 功能:扫描整个FIFO,后位DECIDE到期也原位转为否定;回复不再计决定期限。
|
||
* 输入参数:self——本模块实例。
|
||
* now——当前时刻。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:否则队首回复WAIT、后位DECIDE到期会让need_process不断唤醒却无法消除期限。
|
||
*/
|
||
static void Expire_Decisions(IEC104_SystemCommand_t *self, uint64_t now)
|
||
{
|
||
unsigned i;
|
||
if (self->config.decision_timeout_ms == 0U) { return; }
|
||
for (i = 0U; i < self->count; ++i) {
|
||
SystemTask *task = &self->tasks[self->order[i]];
|
||
if (task->phase == SYSTEM_DECIDE &&
|
||
Remaining(self->config.decision_timeout_ms, task->accepted_ms, now) == 0U) {
|
||
Negative_Reply(self, task);
|
||
++self->status.timeouts;
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:先查ACK事实,再比较时刻;业务晚处理不会把已经按时接受的ACK误判为超时。
|
||
* 输入参数:self——本模块实例。
|
||
* index——索引。
|
||
* now——当前时刻。
|
||
* reply_on_timeout——bool值。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:查询错误取消授权并返回false,不把故障伪装成未ACK。
|
||
* 说明:查询限定提交后首次STOP/断开前的ACK事实,因此会话收尾时也可调用;不依赖通知分派快慢。
|
||
* ACKED分支使用首次ACK时刻,未ACK才使用本轮now;STOP后的迟到ACK只能得到LOST。
|
||
* READY不再受ACK期限约束;查询错误取消授权并返回false,不把故障伪装成未ACK。
|
||
* Cancel_Reset释放观察槽后,即使发送层保留的确认随后获ACK,也没有恢复授权的入口。
|
||
* reply_on_timeout仅用于正常推进:未提交确认到期转否定;会话收尾只清理、不另造回复。
|
||
*/
|
||
static bool Advance_One_Reset(IEC104_SystemCommand_t *self, unsigned index, uint64_t now, bool reply_on_timeout)
|
||
{
|
||
SystemReset *reset = &self->resets[index];
|
||
uint32_t limit = self->config.reset_ack_timeout_ms;
|
||
if (reset->phase == RESET_WAIT_ACK) {
|
||
uint64_t acked = 0U;
|
||
IEC104_SlaveAckState_t state = SYSTEM_ACK(self->slave, &reset->receipt, &acked);
|
||
if (state == IEC104_SLAVE_ACK_ERROR) { Cancel_Reset(self, index, false); return false; }
|
||
if (state == IEC104_SLAVE_ACK_LOST) { Cancel_Reset(self, index, false); return true; }
|
||
if (state == IEC104_SLAVE_ACK_ACKED) {
|
||
if (limit != 0U && Remaining(limit, reset->accept_ms, acked) == 0U) {
|
||
Cancel_Reset(self, index, true);
|
||
} else {
|
||
reset->phase = RESET_READY;
|
||
if (reset->broadcast) {
|
||
/* 已冻结ACK事实即可归还广播观察槽;即使授权容量大于传输观察容量,
|
||
* 后站也能继续提交。原站引用和纯值授权保留到Take/显式Cancel。 */
|
||
IEC104_Slave_Release_Ack(self->slave, &reset->receipt);
|
||
memset(&reset->receipt, 0, sizeof(reset->receipt));
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
}
|
||
if ((reset->phase == RESET_CONFIRM_PENDING || reset->phase == RESET_WAIT_ACK) &&
|
||
limit != 0U && Remaining(limit, reset->accept_ms, now) == 0U) {
|
||
if (reset->phase == RESET_CONFIRM_PENDING && reply_on_timeout) {
|
||
return Reject_Reset_Confirmation(self, index);
|
||
}
|
||
/* 已提交的肯定确认不可撤回;只取消授权,不能再补相反的确认。 */
|
||
Cancel_Reset(self, index, true);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:即使某槽查询失败,也须冻结其余站已确定的ACK,避免一个错误抹掉别站授权。
|
||
* 输入参数:self——本模块实例。
|
||
* now——当前时刻。
|
||
* reply_on_timeout——bool值。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:返回valid的结果。
|
||
* 说明:内部调用:Advance_One_Reset。
|
||
*/
|
||
static bool Advance_Reset(IEC104_SystemCommand_t *self, uint64_t now, bool reply_on_timeout)
|
||
{
|
||
unsigned i;
|
||
bool valid = true;
|
||
for (i = 0U; i < IEC104_SYSTEM_COMMAND_RESET_CAPACITY; ++i) {
|
||
if (!Advance_One_Reset(self, i, now, reply_on_timeout)) { valid = false; }
|
||
}
|
||
return valid;
|
||
}
|
||
|
||
/**
|
||
* 功能:普通STOP/断开及换代先冻结历史ACK事实,再清理未确定的工作。
|
||
* 输入参数:self——本模块实例。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:返回advanced的结果。
|
||
* 说明:同次Poll内ACK与STOP按传输层的实际处理顺序判断,不能用相同毫秒值推断先后。
|
||
* 查询故障仍清理未确定授权并报告失败;已经READY的决定不再查询ACK,也不自动撤销。
|
||
*/
|
||
static bool End_Session(IEC104_SystemCommand_t *self)
|
||
{
|
||
bool advanced = Advance_Reset(self, IEC104_Net_Now_Ms(), false);
|
||
Cancel(self, true);
|
||
return advanced;
|
||
}
|
||
|
||
/**
|
||
* 功能:仅正常STOP造成的提交ERROR允许等待通知;
|
||
* 输入参数:self——本模块实例。
|
||
* identity——原会话身份。
|
||
* submitted——IEC104_TcpSubmitResult_t值。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:仅原会话仍健康、传输已停止且存在待消费通知时返回true;其他情况返回false。
|
||
* 说明:FATAL及其他ERROR不能当WAIT重试。
|
||
*/
|
||
static bool Defer_For_Stop(IEC104_SystemCommand_t *self, const IEC104_SlaveEventIdentity_t *identity,
|
||
IEC104_TcpSubmitResult_t submitted)
|
||
{
|
||
IEC104_TcpServerStatus_t status;
|
||
if (submitted != IEC104_TCP_SUBMIT_ERROR || identity->slave != self->slave ||
|
||
identity->instance_id != self->session.instance_id || identity->generation != self->session.generation ||
|
||
IEC104_Slave_Get_Status(self->slave, &status, NULL) != IEC104_TCP_OK ||
|
||
status.generation != identity->generation || !status.connected || !status.connection_status_valid ||
|
||
!status.asdu_queue_status_valid || status.connection.phase != IEC104_TCP_SESSION_ACTIVE ||
|
||
status.connection.fault != IEC104_TCP_FAULT_NONE || status.connection.data_transfer_started ||
|
||
status.pending_event_count == 0U) { return false; }
|
||
self->status.events_pending = true;
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:[INIT/STEP] 每步最多提交一站;WAIT只阻塞Type70,不阻止较短的FIFO回复尝试。
|
||
* 输入参数:self——本模块实例。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值: 返回1表示状态已推进,0表示本轮停止这个来源,-1表示快照/组包等内部准备失败。
|
||
* 说明:返回1表示状态已推进,0表示本轮停止这个来源,-1表示快照/组包等内部准备失败。
|
||
* 所有站共享本轮COI和会话身份;HIGH按FIFO交接,因此只需观察最后一次成功提交。
|
||
* 末帧PENDING时保留HANDOFF,只有HANDED才登记本轮完成;空轮走sent==0分支,不能把初始0票据当成功。
|
||
*/
|
||
static int Initialization_Step(IEC104_SystemCommand_t *self)
|
||
{
|
||
SystemInitialization *init = &self->init;
|
||
IEC60870_Asdu_t asdu;
|
||
IEC104_TcpSubmitResult_t submitted;
|
||
uint16_t ca;
|
||
uint8_t bytes[10] = {70U, 1U, 4U, 0U, 0U, 0U, 0U, 0U, 0U, 0U};
|
||
if (init->state == INIT_HANDOFF) {
|
||
IEC104_ResponseState_t state = SYSTEM_HANDOFF(self->slave, init->last_ticket);
|
||
if (state == IEC104_RESPONSE_PENDING) { return 0; }
|
||
End_Initialization(self, state == IEC104_RESPONSE_HANDED, false);
|
||
return 1;
|
||
}
|
||
if (init->state == INIT_ARMED && init->start_allowed) {
|
||
if (init->round_id == UINT64_MAX ||
|
||
IEC104_Slave_StationSnapshot_Begin(self->slave, &init->stations) != IEC104_STATION_OK) { return -1; }
|
||
++init->round_id;
|
||
init->identity = self->session;
|
||
init->start_allowed = false;
|
||
init->send_waiting = false;
|
||
init->sent = 0U;
|
||
init->last_ticket = 0U;
|
||
init->state = INIT_SENDING;
|
||
}
|
||
if (init->state != INIT_SENDING) { return 0; }
|
||
/* WAIT期间站点可被移除,快照仍维持节点生命周期;跳过已删除站而不是按CA取替换站。 */
|
||
if (init->station != NULL && !IEC104_Station_Is_Registered(init->station)) { init->station = NULL; }
|
||
if (init->station == NULL) { init->station = IEC104_Slave_StationSnapshot_Next(&init->stations); }
|
||
if (init->station == NULL) {
|
||
if (init->sent == 0U) { End_Initialization(self, false, true); }
|
||
else {
|
||
(void)IEC104_Slave_StationSnapshot_End(&init->stations);
|
||
init->state = INIT_HANDOFF;
|
||
init->send_waiting = false;
|
||
}
|
||
return 1;
|
||
}
|
||
ca = IEC104_Station_Get_Common_Address(init->station);
|
||
bytes[4] = (uint8_t)ca; bytes[5] = (uint8_t)(ca >> 8); bytes[9] = init->coi;
|
||
if (IEC60870_Asdu_Create_From_Buffer(&asdu, IEC104_Slave_Get_Application_Layer_Parameters(self->slave),
|
||
bytes, sizeof(bytes)) != IEC60870_ASDU_OK) { return -1; }
|
||
submitted = SYSTEM_SEND(self->slave, &init->identity, &asdu, &init->last_ticket,
|
||
IEC104_BUSINESS_PRIORITY_INITIALIZATION);
|
||
if (submitted == IEC104_TCP_SUBMIT_OK) {
|
||
++self->status.submitted; ++self->status.init_frames; ++init->sent;
|
||
/* 在最后一次成功提交内完成遍历,不能把已全部提交的一轮留到下次Process
|
||
* 才改HANDOFF,否则紧随其后的STOP会把完整轮次误判为SENDING中断。 */
|
||
init->station = IEC104_Slave_StationSnapshot_Next(&init->stations);
|
||
if (init->station == NULL) {
|
||
(void)IEC104_Slave_StationSnapshot_End(&init->stations);
|
||
init->state = INIT_HANDOFF;
|
||
}
|
||
init->send_waiting = false;
|
||
return 1;
|
||
}
|
||
if (submitted == IEC104_TCP_SUBMIT_WAIT) {
|
||
++self->status.waits;
|
||
init->send_waiting = true;
|
||
return 0;
|
||
}
|
||
if (Defer_For_Stop(self, &init->identity, submitted)) { return 0; }
|
||
if (submitted == IEC104_TCP_SUBMIT_FATAL) { (void)End_Session(self); self->status.active = false; }
|
||
else { End_Initialization(self, false, false); }
|
||
return 0;
|
||
}
|
||
|
||
/**
|
||
* 功能:广播每次只准备一个目标,复用同一FIFO槽。快照排除后来新站;当前站另持引用,
|
||
* 输入参数:self——本模块实例。
|
||
* task——业务任务。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* task——业务任务的更新结果。
|
||
* 返回值:按处理分支返回0、-1、1。
|
||
* 说明:这样QRP1接受时可转交复位槽,后续快照结束也不会释放已确定授权的原站。
|
||
*/
|
||
static int Next_Broadcast_Target(IEC104_SystemCommand_t *self, SystemTask *task)
|
||
{
|
||
IEC104_Station_t *station;
|
||
uint16_t ca;
|
||
Release_Station(self, &task->station);
|
||
task->reset_confirm = false;
|
||
task->send_waiting = false;
|
||
station = IEC104_Slave_StationSnapshot_Next(&task->stations);
|
||
if (station == NULL) { Remove_Task(self, task); return 0; }
|
||
if (IEC104_Slave_Acquire_Station(self->slave, station) != IEC104_STATION_OK) { return -1; }
|
||
task->station = station;
|
||
ca = IEC104_Station_Get_Common_Address(station);
|
||
task->bytes[4] = (uint8_t)ca;
|
||
task->bytes[5] = (uint8_t)(ca >> 8);
|
||
task->phase = task->broadcast_decide ? SYSTEM_DECIDE : SYSTEM_REPLY;
|
||
task->cause = task->broadcast_cause == 0U ? IEC60870_ASDU_COT_ACTIVATION_CON : task->broadcast_cause;
|
||
task->negative = task->broadcast_cause != 0U;
|
||
return 1;
|
||
}
|
||
|
||
/**
|
||
* 功能:[FIFO/SUBMIT] 确认留在原位直到OK。QRP1只有此处分离FIFO与ACK等待,绝不越序提交。
|
||
* 输入参数:self——本模块实例。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值: 返回1表示任务推进/取消,0表示本轮停止FIFO,-1表示回显容器准备失败。
|
||
* 说明:返回1表示任务推进/取消,0表示本轮停止FIFO,-1表示回显容器准备失败。
|
||
* 原文在借用容器内只修改COT/P/N;WAIT后重用这份副本,不再执行业务动作。
|
||
* 104的错误测试码同样保留原文;合法104/107只产生一次ACT_CON,不追加ACT_TERM或动作授权。
|
||
* 107直接回显保存的CP56七字节,不重编码解码值,因其星期已归一化且不再含GEN。
|
||
*/
|
||
static int Submit_Head(IEC104_SystemCommand_t *self)
|
||
{
|
||
SystemTask *task;
|
||
IEC60870_Asdu_t asdu;
|
||
IEC104_TcpSubmitResult_t submitted;
|
||
if (self->count == 0U) { return 0; }
|
||
task = &self->tasks[self->order[0]];
|
||
if (task->phase != SYSTEM_REPLY) { return 0; }
|
||
if (IEC60870_Asdu_Create_From_Buffer(&asdu, IEC104_Slave_Get_Application_Layer_Parameters(self->slave),
|
||
task->bytes, task->length) != IEC60870_ASDU_OK ||
|
||
IEC60870_Asdu_Set_COT(&asdu, task->cause) != IEC60870_ASDU_OK ||
|
||
IEC60870_Asdu_Set_Negative(&asdu, task->negative) != IEC60870_ASDU_OK) { return -1; }
|
||
if (task->reset_confirm) {
|
||
submitted = SYSTEM_SEND_ACK(self->slave, &task->identity, &asdu,
|
||
&self->resets[task->reset_index].receipt, IEC104_BUSINESS_PRIORITY_RESET);
|
||
} else {
|
||
/* 104/107在12级业务优先级中扩展归校时应答级;105的肯定/否定均属于复位进程级。 */
|
||
submitted = SYSTEM_SEND(self->slave, &task->identity, &asdu, NULL,
|
||
task->bytes[0] == 105U ? IEC104_BUSINESS_PRIORITY_RESET : IEC104_BUSINESS_PRIORITY_CLOCK);
|
||
}
|
||
if (submitted == IEC104_TCP_SUBMIT_OK) {
|
||
++self->status.submitted;
|
||
/* answered只计发送层接手的肯定测试回复;不是socket写完或主站ACK,否定另计。 */
|
||
if (task->negative) { ++self->status.negative_submitted; }
|
||
else if (task->bytes[0] == 104U || task->bytes[0] == 107U) { ++self->status.test_answered; }
|
||
if (task->reset_confirm) { self->resets[task->reset_index].phase = RESET_WAIT_ACK; }
|
||
if (task->broadcast) {
|
||
if (Next_Broadcast_Target(self, task) < 0) { return -1; }
|
||
} else { Remove_Task(self, task); }
|
||
return 1;
|
||
}
|
||
if (submitted == IEC104_TCP_SUBMIT_WAIT) {
|
||
++self->status.waits;
|
||
task->send_waiting = true;
|
||
return 0;
|
||
}
|
||
if (Defer_For_Stop(self, &task->identity, submitted)) { return 0; }
|
||
if (submitted == IEC104_TCP_SUBMIT_FATAL) { (void)End_Session(self); self->status.active = false; }
|
||
else if (task->reset_confirm) { Cancel_Reset(self, task->reset_index, false); }
|
||
else { ++self->status.cancelled; Remove_Task(self, task); }
|
||
return 1;
|
||
}
|
||
|
||
/**
|
||
* 功能:1/2分别启用标准处理;128..255仅在应用明确选择专用入口后放行。
|
||
* 输入参数:self——本模块实例。
|
||
* qualifier——限定词。
|
||
* 输出参数:无。
|
||
* 返回值:QRP1/QRP2在各自标准功能启用时返回true;128..255在专用入口启用时返回true,其余false。
|
||
* 说明:0及3..127无标准动作定义,不能因启用了专用功能而透传给应用。
|
||
*/
|
||
static bool Reset_Qualifier_Enabled(const IEC104_SystemCommand_t *self, uint8_t qualifier)
|
||
{
|
||
if (qualifier == 1U) { return (self->config.features & IEC104_SYSTEM_COMMAND_FEATURE_RESET_PROCESS) != 0U; }
|
||
if (qualifier == 2U) { return (self->config.features & IEC104_SYSTEM_COMMAND_FEATURE_RESET_EVENTS) != 0U; }
|
||
return qualifier >= 128U && (self->config.features & IEC104_SYSTEM_COMMAND_FEATURE_RESET_PRIVATE) != 0U;
|
||
}
|
||
|
||
/**
|
||
* 功能:专用请求的ACCEPT仅表示许可,实际动作必须由Take_Reset后交应用执行,不能误入QRP2清除。
|
||
* 输入参数:qualifier——限定词。
|
||
* 输出参数:无。
|
||
* 返回值:返回qualifier == 1U || qualifier >= 128U的结果。
|
||
* 说明:直接处理传入的qualifier,不经过其他函数调用。
|
||
*/
|
||
static bool Reset_Needs_Ack(uint8_t qualifier)
|
||
{
|
||
return qualifier == 1U || qualifier >= 128U;
|
||
}
|
||
|
||
/**
|
||
* 功能:[REQUEST/VALIDATION] 头部可解析不代表对象完整。先确保唯一完整对象,再按45/46/47/7排序。
|
||
* 输入参数:self——本模块实例。
|
||
* event——事件。
|
||
* identity——原会话身份。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:按处理分支返回IEC104_SYSTEM_COMMAND_EVENT_IGNORED、IEC104_SYSTEM_COMMAND_EVENT_HANDLED、IEC104_SYSTEM_COMMAND_EVENT_ERROR。
|
||
* 说明:基础截短可能已由Receiver丢弃,不会进入本模块计数;这里仍防御性检查对象数及完整长度。
|
||
* 负回显截到规范长度、VSQ=1;不重编码非法测试码或CP56,保留原对象字节和TEST。
|
||
* 本入口只入槽,不提交回复;单播错误不持站点引用,广播错误仍按快照逐站持引用回复。
|
||
*/
|
||
static IEC104_SystemCommandEventResult_t Request(IEC104_SystemCommand_t *self,
|
||
const IEC104_SlaveEvent_t *event, const IEC104_SlaveEventIdentity_t *identity)
|
||
{
|
||
IEC60870_AsduInfo_t info;
|
||
const uint8_t *data;
|
||
uint16_t length, expected;
|
||
uint32_t ioa;
|
||
uint8_t cause = 0U;
|
||
IEC104_Station_t *station;
|
||
SystemTask *task;
|
||
bool test, broadcast;
|
||
if (!self->status.active || event->asdu_result != IEC60870_ASDU_OK ||
|
||
IEC60870_Asdu_Get_Data(&event->asdu, &data, &length) != IEC60870_ASDU_OK || length == 0U ||
|
||
(data[0] != 104U && data[0] != 105U && data[0] != 107U) ||
|
||
!IEC60870_Parse_ASDU_Header(event->asdu.parameters, data, length, &info)) {
|
||
return IEC104_SYSTEM_COMMAND_EVENT_IGNORED;
|
||
}
|
||
/* test按类型区分测试服务与105复位;info.is_test才是COT中的T位,两者不可混用。
|
||
* 104/107即使T=0也只回显,共用功能位关闭时仍留给调用方继续分派。 */
|
||
test = data[0] == 104U || data[0] == 107U;
|
||
if ((test && !(self->config.features & IEC104_SYSTEM_COMMAND_FEATURE_TEST_COMMAND)) ||
|
||
(!test && !(self->config.features & (IEC104_SYSTEM_COMMAND_FEATURE_RESET_PROCESS |
|
||
IEC104_SYSTEM_COMMAND_FEATURE_RESET_EVENTS | IEC104_SYSTEM_COMMAND_FEATURE_RESET_PRIVATE)))) {
|
||
return IEC104_SYSTEM_COMMAND_EVENT_IGNORED;
|
||
}
|
||
/* Slave固定COT/CA/IOA为2/2/3字节:公共头6 + IOA3 + 载荷2/9/1,不含APCI。
|
||
* 完整长度检查先于固定偏移读取;多余尾字节稍后否定,截短或非单对象不拼造回复。 */
|
||
expected = data[0] == 104U ? 11U : (data[0] == 107U ? 18U : 10U);
|
||
if (info.object_count != 1U || length < expected) {
|
||
++self->status.rejected;
|
||
return IEC104_SYSTEM_COMMAND_EVENT_HANDLED;
|
||
}
|
||
station = IEC104_Slave_Get_Station(self->slave, info.common_address);
|
||
/* 广播遍历只属于105;104/107的广播地址没有定向站,按未知CA否定。 */
|
||
broadcast = !test && info.common_address == IEC104_CA_BROADCAST &&
|
||
IEC104_Slave_Get_Station_Count(self->slave) != 0U;
|
||
ioa = (uint32_t)data[6] | ((uint32_t)data[7] << 8) | ((uint32_t)data[8] << 16);
|
||
if (info.cause_of_transmission != IEC60870_ASDU_COT_ACTIVATION) { cause = IEC60870_ASDU_COT_UNKNOWN_CAUSE; }
|
||
else if (!broadcast && station == NULL) {
|
||
cause = IEC60870_ASDU_COT_UNKNOWN_COMMON_ADDRESS;
|
||
} else if (ioa != 0U) { cause = IEC60870_ASDU_COT_UNKNOWN_IOA; }
|
||
else if (info.is_sequence || info.is_negative_confirm || length != expected) {
|
||
cause = IEC60870_ASDU_COT_ACTIVATION_CON;
|
||
} else if (data[0] == 104U) {
|
||
IEC60870_TestCommand_t command;
|
||
/* 104没有测试序号或时标,只接受固定AA 55;临时对象仅用于校验。
|
||
* 回复取下面保存的请求字节,不能用构造器修正错误图样后再否定回显。 */
|
||
if (IEC60870_TestCommand_Get_From_Buffer(&command, 0U, data + 9U, 2U) != IEC60870_ASDU_OK) {
|
||
cause = IEC60870_ASDU_COT_ACTIVATION_CON;
|
||
}
|
||
} else if (test) {
|
||
IEC60870_TestCommandWithCP56Time2a_t command;
|
||
/* 107只检验测试对象能否按Time_From_CP56契约解析:辅助星期/GEN兼容,日历及RES2/3/4仍校验。
|
||
* IV仅作为测试内容回显,不用于校时或执行命令,故不调用会拒绝IV的CP56_To_Seconds;
|
||
* 这与103/58..64动作前必须取得有效时间的用途不同,107也不产生复位动作或授权。 */
|
||
if (IEC60870_TestCommandWithCP56Time2a_Get_From_Buffer(&command, 0U, data + 9U, 9U) !=
|
||
IEC60870_ASDU_OK) { cause = IEC60870_ASDU_COT_ACTIVATION_CON; }
|
||
} else if (!Reset_Qualifier_Enabled(self, data[9])) {
|
||
cause = IEC60870_ASDU_COT_ACTIVATION_CON;
|
||
}
|
||
if (cause != 0U) { ++self->status.rejected; }
|
||
/* 验证拒绝与容量丢新是两种事实:错误回复无槽时,两类计数都增加。 */
|
||
if (self->count == IEC104_SYSTEM_COMMAND_TASK_CAPACITY) {
|
||
++self->status.overloads; ++self->status.dropped_requests;
|
||
return IEC104_SYSTEM_COMMAND_EVENT_HANDLED;
|
||
}
|
||
task = Allocate_Task(self);
|
||
if (task == NULL) { return IEC104_SYSTEM_COMMAND_EVENT_ERROR; }
|
||
task->identity = *identity;
|
||
task->length = (uint8_t)expected;
|
||
memcpy(task->bytes, data, expected);
|
||
task->bytes[1] = 1U;
|
||
task->receive_serial = event->transport.data.i_frame.receive_serial;
|
||
task->accepted_ms = IEC104_Net_Now_Ms();
|
||
/* 104/107不论T位取值均直接REPLY,不能进入105的QRP动作或ACK授权路径。
|
||
* 对105,TEST只证明库支持该服务并通过报文验证,不代表应用批准真实动作。
|
||
* action没有is_test参数且QRP2会真实清缓存,故TEST不能进入应用决定/执行入口。 */
|
||
task->phase = !test && !info.is_test && cause == 0U ? SYSTEM_DECIDE : SYSTEM_REPLY;
|
||
task->cause = cause == 0U ? IEC60870_ASDU_COT_ACTIVATION_CON : cause;
|
||
task->negative = cause != 0U;
|
||
task->broadcast = broadcast;
|
||
task->broadcast_decide = !test && !info.is_test && cause == 0U;
|
||
task->broadcast_cause = cause;
|
||
if (broadcast) {
|
||
if (IEC104_Slave_StationSnapshot_Begin(self->slave, &task->stations) != IEC104_STATION_OK ||
|
||
Next_Broadcast_Target(self, task) < 0) {
|
||
Remove_Task(self, task);
|
||
return IEC104_SYSTEM_COMMAND_EVENT_ERROR;
|
||
}
|
||
if (cause == 0U) { ++self->status.reset_accepted; } /* 一条广播只算一次受理。 */
|
||
} else if (cause == 0U) {
|
||
if (IEC104_Slave_Acquire_Station(self->slave, station) != IEC104_STATION_OK) {
|
||
Remove_Task(self, task);
|
||
return IEC104_SYSTEM_COMMAND_EVENT_ERROR;
|
||
}
|
||
task->station = station;
|
||
if (test) { ++self->status.test_accepted; }
|
||
else { ++self->status.reset_accepted; }
|
||
}
|
||
return IEC104_SYSTEM_COMMAND_EVENT_HANDLED;
|
||
}
|
||
|
||
/**
|
||
* 功能:库内初始化系统命令的基础字段,上层统一配置入口再设置EVERY_START策略。
|
||
* 输入参数:config——配置。
|
||
* 输出参数:config——配置的更新结果。
|
||
* 返回值:无。
|
||
* 说明:NULL无操作,不消费通知或绑定实例;生命周期事实由FIFO分派建立。
|
||
*/
|
||
void IEC104_SystemCommand_Config_Init_Base(IEC104_SystemCommandConfig_t *config)
|
||
{
|
||
if (config != NULL) {
|
||
memset(config, 0, sizeof(*config));
|
||
config->features = 0x0fU;
|
||
config->init_policy = IEC104_SYSTEM_COMMAND_INIT_ONCE;
|
||
config->decision_timeout_ms = 15000U;
|
||
config->reset_ack_timeout_ms = 30000U;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:校验功能掩码及初始化策略后复制配置并占用静态槽,每个Slave至多绑定一个实例。
|
||
* 输入参数:slave——所属从站服务。
|
||
* config——配置。
|
||
* 输出参数:无。
|
||
* 返回值: 参数非法、重复绑定或池满返回NULL,不消费通知或自动启动Type70轮次。
|
||
* 说明:参数非法、重复绑定或池满返回NULL,不消费通知或自动启动Type70轮次。
|
||
*/
|
||
IEC104_SystemCommand_t *IEC104_SystemCommand_Create(IEC104_Slave_t *slave,
|
||
const IEC104_SystemCommandConfig_t *config)
|
||
{
|
||
IEC104_SystemCommand_t *available = NULL;
|
||
unsigned i;
|
||
if (config == NULL || (config->features & 0xe0U) != 0U ||
|
||
(config->init_policy != IEC104_SYSTEM_COMMAND_INIT_ONCE &&
|
||
config->init_policy != IEC104_SYSTEM_COMMAND_INIT_EVERY_START) ||
|
||
IEC104_Slave_Get_Application_Layer_Parameters(slave) == NULL) { return NULL; }
|
||
for (i = 0U; i < IEC104_SYSTEM_COMMAND_CAPACITY; ++i) {
|
||
if (system_command_pool[i].in_use && system_command_pool[i].slave == slave) { return NULL; }
|
||
if (!system_command_pool[i].in_use && available == NULL) { available = &system_command_pool[i]; }
|
||
}
|
||
if (available == NULL) { return NULL; }
|
||
memset(available, 0, sizeof(*available));
|
||
available->slave = slave;
|
||
available->config = *config;
|
||
available->in_use = true;
|
||
return available;
|
||
}
|
||
|
||
/**
|
||
* 功能:仅在任务、初始化快照/交接和复位回执全部结束后释放静态槽;不隐式Cancel。
|
||
* 输入参数:self——本模块实例。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值: 无效句柄、动作回调重入或尚有持有责任返回false。
|
||
* 说明:无效句柄、动作回调重入或尚有持有责任返回false。
|
||
*/
|
||
bool IEC104_SystemCommand_Destroy(IEC104_SystemCommand_t *self)
|
||
{
|
||
unsigned i;
|
||
if (!Owned(self) || self->in_action || self->count != 0U || self->init.stations._owner != NULL ||
|
||
self->init.state == INIT_SENDING || self->init.state == INIT_HANDOFF) { return false; }
|
||
for (i = 0U; i < IEC104_SYSTEM_COMMAND_RESET_CAPACITY; ++i) {
|
||
if (self->resets[i].phase != RESET_EMPTY || self->resets[i].receipt.ticket != 0U) { return false; }
|
||
}
|
||
memset(self, 0, sizeof(*self));
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:显式结束本模块任务并放弃所有未领取复位授权,已交接的报文不会撤回。
|
||
* 输入参数:self——本模块实例。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:无。
|
||
* 说明:无效句柄或动作回调期间忽略;初始化轮的已交接事实仍先按凭证结算。
|
||
*/
|
||
void IEC104_SystemCommand_Cancel(IEC104_SystemCommand_t *self)
|
||
{
|
||
if (Owned(self) && !self->in_action) { Cancel(self, false); }
|
||
}
|
||
|
||
/**
|
||
* 功能:设置下一轮Type70的COI;发送/交接中的轮次只登记pending,不改写当前轮。
|
||
* 输入参数:self——本模块实例。
|
||
* coi——初始化原因。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:!Owned(self) || self->in_action || !(self->config.features & IEC104_SYSTEM_COMMAND_FEATURE_INIT_END) || (reason >= 3U && reason <= 31U)时返回false;其余分支返回false、true。
|
||
* 说明:未启用功能、保留原因码3..31或回调重入时拒绝;非发送/交接状态置ARMED并允许启动。
|
||
*/
|
||
bool IEC104_SystemCommand_Set_Initialization(IEC104_SystemCommand_t *self, uint8_t coi)
|
||
{
|
||
uint8_t reason = coi & 0x7fU;
|
||
if (!Owned(self) || self->in_action || !(self->config.features & IEC104_SYSTEM_COMMAND_FEATURE_INIT_END) ||
|
||
(reason >= 3U && reason <= 31U)) { return false; }
|
||
if (self->init.state == INIT_SENDING || self->init.state == INIT_HANDOFF) {
|
||
self->init.pending_coi = coi;
|
||
self->init.pending_valid = true;
|
||
} else {
|
||
self->init.coi = coi;
|
||
self->init.state = INIT_ARMED;
|
||
self->init.start_allowed = true;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:按FIFO消费连接/启停通知并路由系统命令I帧;新连接先收尾旧轮,旧代次通知忽略。
|
||
* 输入参数:self——本模块实例。
|
||
* event——事件。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:按处理分支返回IEC104_SYSTEM_COMMAND_EVENT_ERROR、ended ? IEC104_SYSTEM_COMMAND_EVENT_HANDLED : IEC104_SYSTEM_COMMAND_EVENT_ERROR、IEC104_SYSTEM_COMMAND_EVENT_IGNORED、IEC104_SYSTEM_COMMAND_EVENT_HANDLED、Request(self, event, &identity)。
|
||
* 说明:激活通知建立本轮初始化身份;动作由Execute_Next交付,不能在收包时执行复位。
|
||
*/
|
||
IEC104_SystemCommandEventResult_t IEC104_SystemCommand_Handle_Event(IEC104_SystemCommand_t *self,
|
||
const IEC104_SlaveEvent_t *event)
|
||
{
|
||
IEC104_SlaveEventIdentity_t identity;
|
||
bool ended;
|
||
if (!Owned(self) || self->in_action || !IEC104_Slave_Get_Event_Identity(self->slave, event, &identity) ||
|
||
(self->session.instance_id != 0U && self->session.instance_id != identity.instance_id)) {
|
||
return IEC104_SYSTEM_COMMAND_EVENT_ERROR;
|
||
}
|
||
self->session.slave = identity.slave;
|
||
self->session.instance_id = identity.instance_id;
|
||
if (event->transport.type == IEC104_TCP_EVENT_CONNECTED) {
|
||
/* 先结束旧会话的轮次/任务,再绑定新代次;STOP后同代次START由下面状态通知处理。 */
|
||
ended = End_Session(self);
|
||
self->session.generation = identity.generation;
|
||
self->status.active = false;
|
||
return ended ? IEC104_SYSTEM_COMMAND_EVENT_HANDLED : IEC104_SYSTEM_COMMAND_EVENT_ERROR;
|
||
}
|
||
if (identity.generation != self->session.generation) { return IEC104_SYSTEM_COMMAND_EVENT_IGNORED; }
|
||
switch (event->transport.type) {
|
||
case IEC104_TCP_EVENT_ACTIVATED:
|
||
/* 传输层只为真实激活产生此通知:重复START不进这里,同TCP STOP/START仍有新的activation_id。
|
||
* CONNECTED/DEACTIVATED已先结清旧轮;保留旧完成编号作历史记录,直到新轮末帧HANDED才更新。 */
|
||
self->status.active = true;
|
||
self->init.activation_id = event->transport.activation_id;
|
||
if (self->init.state == INIT_ARMED || (self->init.state == INIT_DONE &&
|
||
self->config.init_policy == IEC104_SYSTEM_COMMAND_INIT_EVERY_START)) {
|
||
self->init.state = INIT_ARMED;
|
||
self->init.start_allowed = true;
|
||
}
|
||
return IEC104_SYSTEM_COMMAND_EVENT_HANDLED;
|
||
case IEC104_TCP_EVENT_DEACTIVATED:
|
||
case IEC104_TCP_EVENT_DISCONNECTED:
|
||
ended = End_Session(self);
|
||
self->status.active = false;
|
||
if (event->transport.type == IEC104_TCP_EVENT_DISCONNECTED) { self->session.generation = 0U; }
|
||
return ended ? IEC104_SYSTEM_COMMAND_EVENT_HANDLED : IEC104_SYSTEM_COMMAND_EVENT_ERROR;
|
||
case IEC104_TCP_EVENT_I_FRAME: return Request(self, event, &identity);
|
||
default: return IEC104_SYSTEM_COMMAND_EVENT_IGNORED;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:[PUBLIC/PROCESS] 每调用两个来源各允许一次WAIT重试;某来源成功不能清除另一来源的等待。
|
||
* 输入参数:self——本模块实例。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:!Owned(self) || self->in_action时返回false;state == IEC104_SLAVE_REQUEST_ERROR时返回false;state != IEC104_SLAVE_REQUEST_READY时返回true;!Advance_Reset(self, now, true)时返回false;其余分支返回false、true。
|
||
* 说明:站表无固定容量,故Type70也须限制步数;每步提交前重查通知,避免跨STOP续发。
|
||
*/
|
||
bool IEC104_SystemCommand_Process(IEC104_SystemCommand_t *self)
|
||
{
|
||
unsigned i;
|
||
IEC104_SlaveRequestState_t state;
|
||
uint64_t now;
|
||
if (!Owned(self) || self->in_action) { return false; }
|
||
state = Check_Session(self);
|
||
if (state == IEC104_SLAVE_REQUEST_ERROR) { return false; }
|
||
if (state != IEC104_SLAVE_REQUEST_READY) { return true; }
|
||
now = IEC104_Net_Now_Ms();
|
||
Expire_Decisions(self, now);
|
||
if (!Advance_Reset(self, now, true)) { return false; }
|
||
for (i = 0U; i < 2U * IEC104_SYSTEM_COMMAND_TASK_CAPACITY; ++i) {
|
||
int progressed = Initialization_Step(self);
|
||
if (progressed < 0) { (void)End_Session(self); self->status.active = false; return false; }
|
||
if (progressed == 0) { break; }
|
||
state = Check_Session(self);
|
||
if (state == IEC104_SLAVE_REQUEST_ERROR) { return false; }
|
||
if (state != IEC104_SLAVE_REQUEST_READY) { return true; }
|
||
}
|
||
for (i = 0U; i < IEC104_SYSTEM_COMMAND_TASK_CAPACITY; ++i) {
|
||
int progressed;
|
||
state = Check_Session(self);
|
||
if (state == IEC104_SLAVE_REQUEST_ERROR) { return false; }
|
||
if (state != IEC104_SLAVE_REQUEST_READY) { return true; }
|
||
/* 前面的Type70提交可能花费时间,QRP1确认提交前重新检查其业务期限。 */
|
||
if (!Advance_Reset(self, IEC104_Net_Now_Ms(), true)) { return false; }
|
||
progressed = Submit_Head(self);
|
||
if (progressed < 0) { (void)End_Session(self); self->status.active = false; return false; }
|
||
if (progressed == 0) { break; }
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:[RESET/ACTION] 回调与Take_Reset使用纯值请求,不向应用暴露任务槽或可移动的事件借用。
|
||
* 输入参数:task——业务任务。
|
||
* now——当前时刻。
|
||
* request——请求。
|
||
* 输出参数:request——请求的更新结果。
|
||
* 返回值:无。
|
||
* 说明:内部调用:memset、IEC104_Station_Get_Id。
|
||
*/
|
||
static void Build_Reset_Request(const SystemTask *task, uint64_t now,
|
||
IEC104_SystemCommandResetRequest_t *request)
|
||
{
|
||
memset(request, 0, sizeof(*request));
|
||
request->identity = task->identity;
|
||
request->receive_serial = task->receive_serial;
|
||
request->station_id = IEC104_Station_Get_Id(task->station);
|
||
request->common_address = (uint16_t)((uint16_t)task->bytes[4] | ((uint16_t)task->bytes[5] << 8));
|
||
request->originator_address = task->bytes[3];
|
||
request->qualifier = task->bytes[9];
|
||
request->accepted_ms = task->accepted_ms;
|
||
request->base_ms = now;
|
||
}
|
||
|
||
/**
|
||
* 功能:单站请求保持原有“已有复位未领取则忙”的契约;广播可为不同站分配独立授权。
|
||
* 输入参数:self——本模块实例。
|
||
* task——业务任务。
|
||
* ca——ASDU公共地址。
|
||
* 输出参数:无。
|
||
* 返回值:按处理分支返回IEC104_SYSTEM_COMMAND_RESET_CAPACITY、available。
|
||
* 说明:同一CA已有授权时也拒绝,不能把新请求覆盖到旧确认/ACK上。
|
||
*/
|
||
static unsigned Find_Reset_Slot(const IEC104_SystemCommand_t *self, const SystemTask *task,
|
||
uint16_t ca)
|
||
{
|
||
unsigned i, available = IEC104_SYSTEM_COMMAND_RESET_CAPACITY;
|
||
for (i = 0U; i < IEC104_SYSTEM_COMMAND_RESET_CAPACITY; ++i) {
|
||
if (self->resets[i].phase == RESET_EMPTY) {
|
||
if (available == IEC104_SYSTEM_COMMAND_RESET_CAPACITY) { available = i; }
|
||
} else if (!task->broadcast || !self->resets[i].broadcast ||
|
||
self->resets[i].request.identity.instance_id != task->identity.instance_id ||
|
||
self->resets[i].request.identity.generation != task->identity.generation ||
|
||
self->resets[i].request.receive_serial != task->receive_serial ||
|
||
self->resets[i].request.common_address == ca) {
|
||
return IEC104_SYSTEM_COMMAND_RESET_CAPACITY;
|
||
}
|
||
}
|
||
return available;
|
||
}
|
||
|
||
/**
|
||
* 功能:对队首待决定请求完成站点、期限和容量预检后,至多调用一次同步应用动作。
|
||
* 输入参数:self——本模块实例。
|
||
* action——动作回调。
|
||
* context——调用方上下文。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值: QRP2应用已接受但库侧清事件失败返回FAULT,不回滚或重复应用动作。
|
||
* 说明:需ACK的复位先预占授权槽,实际复位须等待Take_Reset;无任务EMPTY,通知未读WAIT。
|
||
* QRP2应用已接受但库侧清事件失败返回FAULT,不回滚或重复应用动作。
|
||
*/
|
||
IEC104_SystemCommandExecuteResult_t IEC104_SystemCommand_Execute_Next(IEC104_SystemCommand_t *self,
|
||
IEC104_SystemCommandResetAction_t action, void *context)
|
||
{
|
||
SystemTask *task;
|
||
IEC104_SystemCommandResetRequest_t request;
|
||
IEC104_SystemCommandDecision_t decision;
|
||
IEC104_SlaveRequestState_t state;
|
||
uint32_t count;
|
||
unsigned reset_index = IEC104_SYSTEM_COMMAND_RESET_CAPACITY;
|
||
uint64_t now;
|
||
if (!Owned(self) || self->in_action || action == NULL) { return IEC104_SYSTEM_COMMAND_EXECUTE_ERROR; }
|
||
if (self->count == 0U || self->tasks[self->order[0]].phase != SYSTEM_DECIDE) {
|
||
return IEC104_SYSTEM_COMMAND_EXECUTE_EMPTY;
|
||
}
|
||
state = Check_Session(self);
|
||
if (state == IEC104_SLAVE_REQUEST_ERROR) { return IEC104_SYSTEM_COMMAND_EXECUTE_ERROR; }
|
||
if (state == IEC104_SLAVE_REQUEST_WAIT_EVENTS) { return IEC104_SYSTEM_COMMAND_EXECUTE_WAIT; }
|
||
if (state != IEC104_SLAVE_REQUEST_READY) { return IEC104_SYSTEM_COMMAND_EXECUTE_EMPTY; }
|
||
task = &self->tasks[self->order[0]];
|
||
now = IEC104_Net_Now_Ms();
|
||
Expire_Decisions(self, now);
|
||
if (task->phase != SYSTEM_DECIDE) { return IEC104_SYSTEM_COMMAND_EXECUTE_OK; }
|
||
Build_Reset_Request(task, now, &request);
|
||
if (!IEC104_Station_Is_Registered(task->station) ||
|
||
IEC104_Slave_Get_Station_By_Id(self->slave, request.station_id) != task->station ||
|
||
IEC104_Slave_Get_Station(self->slave, request.common_address) != task->station) {
|
||
++self->status.station_mismatches;
|
||
Negative_Reply(self, task);
|
||
return IEC104_SYSTEM_COMMAND_EXECUTE_OK;
|
||
}
|
||
if (Reset_Needs_Ack(request.qualifier)) {
|
||
reset_index = Find_Reset_Slot(self, task, request.common_address);
|
||
if (reset_index == IEC104_SYSTEM_COMMAND_RESET_CAPACITY) {
|
||
++self->status.reset_busy;
|
||
Negative_Reply(self, task);
|
||
return IEC104_SYSTEM_COMMAND_EXECUTE_OK;
|
||
}
|
||
}
|
||
if (request.qualifier == 2U && SYSTEM_COUNT(self->slave, request.common_address,
|
||
IEC104_SLAVE_EVENTS_TIME_TAGGED, &count, NULL) != IEC104_TCP_OK) {
|
||
Negative_Reply(self, task);
|
||
return IEC104_SYSTEM_COMMAND_EXECUTE_OK;
|
||
}
|
||
/* 队列预检可扫描较大的NORMAL,期限终点是回调开始而非预检开始。
|
||
* 更新base_ms后再判断,回调一旦开始则不再以决定期限撤销动作。 */
|
||
request.base_ms = IEC104_Net_Now_Ms();
|
||
Expire_Decisions(self, request.base_ms);
|
||
if (task->phase != SYSTEM_DECIDE) { return IEC104_SYSTEM_COMMAND_EXECUTE_OK; }
|
||
/* 回调开始后不重查决定期限,也不重做动作;只保护本模块,Slave约束由调用者遵守。 */
|
||
self->in_action = true;
|
||
decision = action(context, &request);
|
||
self->in_action = false;
|
||
if (decision != IEC104_SYSTEM_COMMAND_DECISION_ACCEPT) {
|
||
if (decision != IEC104_SYSTEM_COMMAND_DECISION_REJECT) { ++self->status.invalid_decisions; }
|
||
Negative_Reply(self, task);
|
||
return IEC104_SYSTEM_COMMAND_EXECUTE_OK;
|
||
}
|
||
task->phase = SYSTEM_REPLY;
|
||
task->cause = IEC60870_ASDU_COT_ACTIVATION_CON;
|
||
task->negative = false;
|
||
task->send_waiting = false;
|
||
if (Reset_Needs_Ack(task->bytes[9])) {
|
||
SystemReset *reset = &self->resets[reset_index];
|
||
/* 只预占复位槽;FIFO中的肯定确认必须等提交OK才移走,后续请求不能抢先应答。 */
|
||
reset->request = request;
|
||
reset->station = task->station;
|
||
task->station = NULL; /* 所有权转移,FIFO确认删除不释放复位授权的引用。 */
|
||
reset->accept_ms = request.base_ms;
|
||
reset->phase = RESET_CONFIRM_PENDING;
|
||
reset->broadcast = task->broadcast;
|
||
task->reset_index = reset_index;
|
||
task->reset_confirm = true;
|
||
} else if (task->bytes[9] == 2U) {
|
||
/* 应用缓冲已经清除;库清除失败不能假装回滚,保留否定回复并向应用报告FAULT。 */
|
||
if (SYSTEM_DISCARD(self->slave, request.common_address, IEC104_SLAVE_EVENTS_TIME_TAGGED,
|
||
&count, NULL) != IEC104_TCP_OK) {
|
||
++self->status.partial_failures;
|
||
Negative_Reply(self, task);
|
||
return IEC104_SYSTEM_COMMAND_EXECUTE_FAULT;
|
||
}
|
||
++self->status.events_cleared_requests;
|
||
self->status.events_discarded += count;
|
||
}
|
||
return IEC104_SYSTEM_COMMAND_EXECUTE_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能:同一服务实例和连接内以接收序号识别广播复位批次;
|
||
* 输入参数:request——请求。
|
||
* identity——原会话身份。
|
||
* receive_serial——接收事件序号。
|
||
* 输出参数:无。
|
||
* 返回值:返回request->identity.instance_id == identity->instance_id && request->identity.generation == identity->generation && request->receive_serial == receive_serial的结果。
|
||
* 说明:站点CA不同仍可属于同一批次。
|
||
*/
|
||
static bool Same_Reset_Batch(const IEC104_SystemCommandResetRequest_t *request,
|
||
const IEC104_SlaveEventIdentity_t *identity, uint64_t receive_serial)
|
||
{
|
||
return request->identity.instance_id == identity->instance_id &&
|
||
request->identity.generation == identity->generation && request->receive_serial == receive_serial;
|
||
}
|
||
|
||
/**
|
||
* 功能:广播先完成全部站回复,并把同批ACK等待收敛为READY或取消,才交出任何授权。
|
||
* 输入参数:self——本模块实例。
|
||
* index——索引。
|
||
* 输出参数:无。
|
||
* 返回值:本批所有回复均交接、ACK观察均已裁决且目标授权可领取时返回true,否则false。
|
||
* 说明:首站先ACK时不会提前提示reset_ready;STOP清理FIFO和未ACK槽后,已确定的站可领取。
|
||
*/
|
||
static bool Reset_Release_Ready(const IEC104_SystemCommand_t *self, unsigned index)
|
||
{
|
||
const SystemReset *reset = &self->resets[index];
|
||
unsigned i;
|
||
if (reset->phase != RESET_READY) { return false; }
|
||
if (!reset->broadcast) { return true; }
|
||
for (i = 0U; i < self->count; ++i) {
|
||
const SystemTask *task = &self->tasks[self->order[i]];
|
||
if (task->broadcast && Same_Reset_Batch(&reset->request, &task->identity, task->receive_serial)) {
|
||
return false;
|
||
}
|
||
}
|
||
for (i = 0U; i < IEC104_SYSTEM_COMMAND_RESET_CAPACITY; ++i) {
|
||
const SystemReset *other = &self->resets[i];
|
||
if ((other->phase == RESET_CONFIRM_PENDING || other->phase == RESET_WAIT_ACK) &&
|
||
Same_Reset_Batch(&reset->request, &other->request.identity, other->request.receive_serial)) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:领取首个已满足ACK及广播批次屏障的复位授权,成功才写request并释放引用/回执。
|
||
* 输入参数:self——本模块实例。
|
||
* request——请求。
|
||
* 输出参数:request——请求的更新结果。
|
||
* 返回值:成功交出首个可领取的复位请求时返回true;无可领取授权、通知未读或查询失败时返回false。
|
||
* 说明:通知未读或查询错误保留授权;原会话失效不推翻已确定决定,本接口不执行硬件复位。
|
||
*/
|
||
bool IEC104_SystemCommand_Take_Reset(IEC104_SystemCommand_t *self,
|
||
IEC104_SystemCommandResetRequest_t *request)
|
||
{
|
||
IEC104_SlaveRequestState_t state;
|
||
IEC104_SystemCommandResetRequest_t result;
|
||
SystemReset *reset;
|
||
unsigned i;
|
||
if (!Owned(self) || self->in_action || request == NULL) { return false; }
|
||
for (i = 0U; i < IEC104_SYSTEM_COMMAND_RESET_CAPACITY; ++i) {
|
||
if (Reset_Release_Ready(self, i)) { break; }
|
||
}
|
||
if (i == IEC104_SYSTEM_COMMAND_RESET_CAPACITY) { return false; }
|
||
reset = &self->resets[i];
|
||
state = IEC104_Slave_Check_Request(self->slave, &reset->request.identity);
|
||
/* 先读空通知,但原连接已停止/断开/换代不撤销已确定的决定。
|
||
* 返回的仍是原请求身份;不能把它替换成新主站身份,也不向新会话补发确认。 */
|
||
if (state == IEC104_SLAVE_REQUEST_WAIT_EVENTS || state == IEC104_SLAVE_REQUEST_ERROR) { return false; }
|
||
result = reset->request;
|
||
IEC104_Slave_Release_Ack(self->slave, &reset->receipt);
|
||
Release_Station(self, &reset->station);
|
||
memset(reset, 0, sizeof(*reset));
|
||
++self->status.resets_released;
|
||
*request = result;
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:[STATUS/SNAPSHOT] 合并真正启用的期限,0既可能到期也可能无任务,须配合timer_active使用。
|
||
* 输入参数:status——状态快照。
|
||
* remaining——剩余量。
|
||
* 输出参数:status——状态快照的更新结果。
|
||
* 返回值:无。
|
||
* 说明:直接处理传入的status、remaining,不经过其他函数调用。
|
||
*/
|
||
static void Add_Timer(IEC104_SystemCommandStatus_t *status, uint32_t remaining)
|
||
{
|
||
if (!status->timer_active || remaining < status->timeout_remaining_ms) {
|
||
status->timeout_remaining_ms = remaining;
|
||
}
|
||
status->timer_active = true;
|
||
}
|
||
|
||
/* 查询实例归属不推进业务;初始化完成事实仍由Get_Status按本轮身份提供。 */
|
||
IEC104_Slave_t *IEC104_SystemCommand_Get_Slave(const IEC104_SystemCommand_t *self)
|
||
{
|
||
return Owned(self) ? self->slave : NULL;
|
||
}
|
||
|
||
/**
|
||
* 功能:查询通过局部快照保证失败时不改输出;ACK查询ERROR绝不变成need_process成功快照。
|
||
* 输入参数:self——本模块实例。
|
||
* status——状态快照。
|
||
* 输出参数:status——全部查询成功后写回快照,失败保持原值。
|
||
* 返回值: Process再次查询会取消错误授权并报告false,调用者按服务错误清理。
|
||
* 说明:Process再次查询会取消错误授权并报告false,调用者按服务错误清理。
|
||
*/
|
||
bool IEC104_SystemCommand_Get_Status(const IEC104_SystemCommand_t *self,
|
||
IEC104_SystemCommandStatus_t *status)
|
||
{
|
||
IEC104_SystemCommandStatus_t result;
|
||
IEC104_SlaveRequestState_t session;
|
||
IEC104_ResponseState_t handoff = IEC104_RESPONSE_PENDING;
|
||
uint64_t now;
|
||
unsigned i;
|
||
bool work, reset_work = false, reset_progress = false;
|
||
if (!Owned(self) || status == NULL) { return false; }
|
||
session = IEC104_Slave_Check_Request(self->slave, &self->session);
|
||
if (session == IEC104_SLAVE_REQUEST_ERROR) { return false; }
|
||
if (self->init.state == INIT_HANDOFF) {
|
||
handoff = SYSTEM_HANDOFF(self->slave, self->init.last_ticket);
|
||
if (handoff == IEC104_RESPONSE_ERROR) { return false; }
|
||
}
|
||
result = self->status;
|
||
/* 等待标志按查询到的实际结果派生;ACKED/LOST和非PENDING凭证由need_process接手。 */
|
||
result.generation = self->session.generation;
|
||
result.events_pending = session == IEC104_SLAVE_REQUEST_WAIT_EVENTS;
|
||
result.pending_tasks = self->count;
|
||
result.decide_pending = self->count != 0U && self->tasks[self->order[0]].phase == SYSTEM_DECIDE;
|
||
result.send_waiting = self->init.send_waiting ||
|
||
(self->count != 0U && self->tasks[self->order[0]].send_waiting);
|
||
result.handoff_pending = self->init.state == INIT_HANDOFF && handoff == IEC104_RESPONSE_PENDING;
|
||
result.ack_pending = false;
|
||
result.reset_ready = false;
|
||
result.init_registered = self->init.state != INIT_IDLE;
|
||
result.init_armed = self->init.state == INIT_ARMED;
|
||
result.init_start_allowed = self->init.start_allowed;
|
||
result.init_round_active = self->init.state == INIT_SENDING || self->init.state == INIT_HANDOFF;
|
||
result.timer_active = false;
|
||
result.timeout_remaining_ms = 0U;
|
||
result.need_process = false;
|
||
now = IEC104_Net_Now_Ms();
|
||
if (self->config.decision_timeout_ms != 0U) {
|
||
for (i = 0U; i < self->count; ++i) {
|
||
const SystemTask *task = &self->tasks[self->order[i]];
|
||
if (task->phase == SYSTEM_DECIDE) {
|
||
Add_Timer(&result, Remaining(self->config.decision_timeout_ms, task->accepted_ms, now));
|
||
}
|
||
}
|
||
}
|
||
for (i = 0U; i < IEC104_SYSTEM_COMMAND_RESET_CAPACITY; ++i) {
|
||
const SystemReset *reset = &self->resets[i];
|
||
if (reset->phase == RESET_WAIT_ACK) {
|
||
IEC104_SlaveAckState_t ack = SYSTEM_ACK(self->slave, &reset->receipt, NULL);
|
||
if (ack == IEC104_SLAVE_ACK_ERROR) { return false; }
|
||
result.ack_pending = result.ack_pending || ack == IEC104_SLAVE_ACK_QUEUED || ack == IEC104_SLAVE_ACK_SENT;
|
||
reset_progress = reset_progress || ack == IEC104_SLAVE_ACK_ACKED || ack == IEC104_SLAVE_ACK_LOST;
|
||
}
|
||
result.reset_ready = result.reset_ready || Reset_Release_Ready(self, i);
|
||
if (reset->phase == RESET_CONFIRM_PENDING || reset->phase == RESET_WAIT_ACK) {
|
||
reset_work = true;
|
||
if (self->config.reset_ack_timeout_ms != 0U) {
|
||
Add_Timer(&result, Remaining(self->config.reset_ack_timeout_ms, reset->accept_ms, now));
|
||
}
|
||
}
|
||
}
|
||
/* READY由reset_ready提示应用Take,不因离线而要求Process反复做无效清理。 */
|
||
work = self->count != 0U || reset_work || result.init_round_active;
|
||
/* 查询永不推进;回调内或尚有通知时不要求重入Process,调度方先处理相应边界。 */
|
||
if (!self->in_action && !result.events_pending) {
|
||
result.need_process = (work && (session != IEC104_SLAVE_REQUEST_READY || !result.active)) ||
|
||
(result.timer_active && result.timeout_remaining_ms == 0U) ||
|
||
(self->init.state == INIT_HANDOFF && handoff != IEC104_RESPONSE_PENDING) ||
|
||
reset_progress;
|
||
if (result.active && session == IEC104_SLAVE_REQUEST_READY) {
|
||
result.need_process = result.need_process ||
|
||
(self->count != 0U && self->tasks[self->order[0]].phase == SYSTEM_REPLY &&
|
||
!self->tasks[self->order[0]].send_waiting) ||
|
||
(self->init.state == INIT_SENDING && !self->init.send_waiting) ||
|
||
(self->init.state == INIT_ARMED && self->init.start_allowed);
|
||
}
|
||
}
|
||
*status = result;
|
||
return true;
|
||
}
|