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