Files
STM32F4-Base/IEC60870-Slave/104/business/IEC104_SystemCommand.c
T
STF bdcc8b6500
CI / L0 静态门禁 (pre-commit) (push) Failing after 7m46s
CI / L0.5 主机侧单测 (MSVC) (push) Successful in 21s
添加遥控、参数装载、文件传输等业务
2026-11-16 22:19:17 -08:00

1392 lines
71 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.
/*
* 系统命令业务:固定槽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;
}