Files
STM32F4-Base/App/protocol/iec60870/104/business/IEC104_ClockSynchronization.c
T
wandering1 2e9272cc8a feat(iec104): 在模拟器跑通共享协议核心与标准DTU点表
引入成熟 IEC 60870-5-104 子站的只读子集(App/protocol/iec60870,28 个源文件
按原字节复制,UPSTREAM.sha256 记录来源,兼容补丁保留全部断言与容量),在其上
装配单属主共享核心(Start/Poll/Stop/Get_Status),并把标准 DTU 演示点表全量
接入为唯一真源。

- iec104_core:threadless 推进,poll 零等待,通知/交互/COV 扫描全部有界;
  生命周期区分失败启动待重试、重复启动拒绝、断线保固化 RAM。
- iec104_dtu_table / iec104_source:标准 DTU 全点表注册,无数据源的点读 0,
  遥控只做模拟状态可读回,不触碰实际出口。
- iec104_sim:仅窗口与独立服务模式起真实 TCP,无头黄金模式保持确定性假统计。
- test/host/iec104_dtu:独立真实 TCP 11 项、传输层 10 项、生命周期与借用负例。

验证:lvgl_sim 真实 TCP 11/11、传输 10/10,UI 像素回归未回退;AC5 单 TU
编译 0 错误 0 诊断。板端尚未切换:完整库闭包 RAM 超 92% 门禁净增预算 25730B,
结论为停止转实施,记录在 IEC104_MCU最小可行性验证.md。旧实现与 board 服务
保持原样,未提交 MDK 工程改动,未烧板。
2026-11-17 20:48:00 +08:00

826 lines
43 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.
/*
* IEC104时钟同步业务(Type 103,C_CS_NA_1)。
* 用途:COT=6把主站时间交给应用设时;COT=5由应用读取当前本地时间并生成一次快照。
* 本模块只处理协议及时间换算,不直接读写系统时钟或RTC;实际读/设时由应用回调完成。
*
* 推进顺序:Handle_Event校验并保存 -> 显式Execute入口调用一次读/设时 -> Process续交应答。
* 校验失败或设时TEST直接待应答;读TEST仍取只读快照。固定槽的回复严格按受理顺序。
* 时间计算使用Net单调毫秒,不能用正在被校准的日历时钟计算期限和站内等待时间。
* 所有接口由同一事件循环串行调用;STOP/断线取消未交接任务,不回滚已完成的设时。
*/
#include "IEC104_ClockSynchronization.h"
#include "IEC104_TcpServer_Config.h"
#include "IEC104_Net.h"
#include "IEC60870_Codec.h"
#include <string.h>
#ifndef IEC104_CLOCK_SYNCHRONIZATION_CAPACITY
#define IEC104_CLOCK_SYNCHRONIZATION_CAPACITY IEC104_TCP_SERVER_CAPACITY
#endif
#ifndef IEC104_CLOCK_SYNCHRONIZATION_TASK_CAPACITY
#define IEC104_CLOCK_SYNCHRONIZATION_TASK_CAPACITY 4U
#endif
_Static_assert(IEC104_CLOCK_SYNCHRONIZATION_CAPACITY > 0U, "Clock needs instance storage");
_Static_assert(IEC104_CLOCK_SYNCHRONIZATION_TASK_CAPACITY > 0U &&
IEC104_CLOCK_SYNCHRONIZATION_TASK_CAPACITY <= UINT32_MAX / 2U, "Clock needs bounded task storage");
/* EXECUTE等待设时,READ等待取样;统一调度不能越过尚未取样的READ去执行后续设时。
* 调用回调之前先消费操作并转REPLY,in_action保证这段临时状态不会被Process提交。
* 校验拒绝、设时TEST及执行前超时也直接进入REPLY;正常发送WAIT不会回到执行阶段或重新读时。 */
enum { CLOCK_EXECUTE = 1, CLOCK_REPLY = 2, CLOCK_READ = 3 };
typedef struct {
IEC104_SlaveEventIdentity_t identity; /* 原Slave实例及连接代次,防止旧确认发到新连接。 */
uint8_t bytes[16]; /* 6字节ASDU头+3字节IOA+7字节CP56;设时保留原时间,读成功时填入固定快照。 */
IEC104_StationSnapshot_t stations; /* 广播受理时固定目标集合;含自引用,禁止移动槽。 */
IEC104_Station_t *station; /* 定向Acquire;广播由活动快照保护当前节点。 */
uint64_t receive_serial, accepted_ms; /* 原I帧编号;Handle_Event受理时的单调毫秒。 */
uint16_t response_ca; /* 定向原CA;广播当前应答站的CA,WAIT期间保持目标不变。 */
uint8_t phase, cause; /* EXECUTE/READ/REPLY;待回传的COT,0表示尚未生成应答。 */
bool negative, executed, send_waiting, occupied; /* P/N、设时动作已消费、上次提交WAIT、槽已占用。 */
} ClockTask;
struct IEC104_ClockSynchronization {
IEC104_Slave_t *slave; /* 借用服务,必须先销毁本模块再销毁Slave。 */
IEC104_SlaveEventIdentity_t session; /* 已消费通知所对应的服务身份和连接代次。 */
IEC104_ClockSynchronizationConfig_t config;
IEC104_ClockSynchronizationStatus_t status; /* 累计计数和活动状态;调度字段由查询即时计算。 */
ClockTask tasks[IEC104_CLOCK_SYNCHRONIZATION_TASK_CAPACITY];
unsigned order[IEC104_CLOCK_SYNCHRONIZATION_TASK_CAPACITY], count; /* FIFO槽下标;占用数量。 */
uint64_t serial; /* 进程内递增的实例编号,销毁后不回收编号。 */
bool in_use, in_action; /* 实例池占用;动作期间阻止修改模块或递归执行其他任务。 */
};
static IEC104_ClockSynchronization_t clock_pool[IEC104_CLOCK_SYNCHRONIZATION_CAPACITY];
static uint64_t next_serial;
/**
* 功能:先比对池内地址再解引用,NULL或不属于本池的句柄均返回false。
* 输入参数:self——本模块实例。
* 输出参数:无。
* 返回值:true表示句柄属于当前占用的静态实例槽;NULL、池外地址或未占用槽返回false。
* 说明:直接处理传入的self,不经过其他函数调用。
*/
static bool Owned(const IEC104_ClockSynchronization_t *self)
{
unsigned i;
for (i = 0U; i < IEC104_CLOCK_SYNCHRONIZATION_CAPACITY; ++i) {
if (self == &clock_pool[i]) { return self->in_use; }
}
return false;
}
/**
* 功能:结束一个任务:广播End快照,定向Release持有的站点,再归还固定槽。
* 输入参数:self——本模块实例。
* task——业务任务。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:无。
* 说明:正常提交、超时应答完成和所有取消路径均使用此入口,避免遗留站点引用。
* 活动快照含自引用,任务永不搬移;仅压缩顺序索引。
*/
static void Remove_Task(IEC104_ClockSynchronization_t *self, ClockTask *task)
{
unsigned index, slot = (unsigned)(task - self->tasks);
if (task->stations._owner != NULL) {
(void)IEC104_Slave_StationSnapshot_End(&task->stations);
} else if (task->station != NULL) {
(void)IEC104_Slave_Release_Station(self->slave, task->station);
}
for (index = 0U; index < self->count; ++index) {
if (self->order[index] == slot) {
memmove(self->order + index, self->order + index + 1U,
(self->count - index - 1U) * sizeof(self->order[0]));
--self->count;
break;
}
}
memset(task, 0, sizeof(*task));
}
/**
* 功能:内部统一清理:cancelled按任务数累计,不按广播站数累计。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:只清理本模块仍持有的任务;发送层已接手的字节和应用已改过的时钟不受影响。
*/
static void Cancel(IEC104_ClockSynchronization_t *self)
{
while (self->count != 0U) {
++self->status.cancelled;
Remove_Task(self, &self->tasks[self->order[0]]);
}
}
/**
* 功能:从空闲固定槽取一个并追加FIFO下标;
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:满槽返回NULL,既不覆盖也不移动旧任务。
* 说明:满槽返回NULL,既不覆盖也不移动旧任务。
*/
static ClockTask *Allocate_Task(IEC104_ClockSynchronization_t *self)
{
unsigned slot;
for (slot = 0U; slot < IEC104_CLOCK_SYNCHRONIZATION_TASK_CAPACITY; ++slot) {
if (!self->tasks[slot].occupied) {
ClockTask *task = &self->tasks[slot];
memset(task, 0, sizeof(*task));
task->occupied = true;
self->order[self->count++] = slot;
return task;
}
}
return NULL;
}
/**
* 功能:UTC纪元毫秒上限:Seconds_To_Local还要加本站UTC+8,须预留这8小时。
* 输入参数:无。
* 输出参数:无。
* 返回值:返回((uint64_t)IEC60870_TIME_MAX_SECONDS - (uint64_t)IEC60870_LOCAL_UTC_OFFSET_MINUTES * 60U) * 1000U + 999U的结果。
* 说明:先转64位再乘1000;尾部999允许最后一个合法整秒内的全部毫秒。
*/
static uint64_t Limit_Ms(void)
{
return ((uint64_t)IEC60870_TIME_MAX_SECONDS -
(uint64_t)IEC60870_LOCAL_UTC_OFFSET_MINUTES * 60U) * 1000U + 999U;
}
/**
* 功能:将完整16字节请求中的CP56换算为UTC毫秒,输出仅在全部检查成功时更新。
* 输入参数:self——本模块实例。
* bytes——字节存储。
* time——时标。
* utc_ms——UTC毫秒时刻。
* 输出参数:time、utc_ms——全部时标检查及换算成功后写入CP56时标和UTC毫秒;失败均保持原值。
* 返回值:converted > Limit_Ms() || !IEC60870_Time_Seconds_To_Local(seconds, command.time.time.ms, &local)时返回false;其余分支返回false、true。
* 说明:对象解码遵循Time_From_CP56接收契约:星期按日期重算,接受GEN但不导出;
* 真实日历和RES2/3/4仍须合法。CP56_To_Seconds另拒绝IV、检查源时区并扣除SU对应的一小时。
* UTC合法之后还须确认固定UTC+8的本站日历没有越界,此处尚不补偿站内等待时间。
* 校时不以本站旧墙钟作新鲜度依据;Execute_Next另查执行期限,再补偿站内等待。
*/
static bool Decode_Time(const IEC104_ClockSynchronization_t *self, const uint8_t *bytes,
IEC60870_CP56Time2a_t *time, uint64_t *utc_ms)
{
IEC60870_ClockSynchronizationCommand_t command;
IEC60870_WallTime_t local;
uint32_t seconds;
uint64_t converted;
if (IEC60870_ClockSynchronizationCommand_Get_From_Buffer(&command, 0U, bytes + 9U, 7U) !=
IEC60870_ASDU_OK ||
!IEC60870_Time_CP56_To_Seconds(&command.time, self->config.master_utc_offset_minutes, &seconds)) {
return false;
}
converted = (uint64_t)seconds * 1000U + command.time.time.ms;
if (converted > Limit_Ms() ||
!IEC60870_Time_Seconds_To_Local(seconds, command.time.time.ms, &local)) { return false; }
*time = command.time;
*utc_ms = converted;
return true;
}
/**
* 功能:校验读请求的七字节占位:bytes须非NULL且至少含完整的16字节ASDU,不修改原文。
* 输入参数:bytes——字节存储。
* 输出参数:无。
* 返回值:请求CP56的七个字节全部为0时返回true,否则false。
* 说明:true仅表示[9..15]全零,false表示至少一个非零;其他结构、CA和IOA校验仍由Request负责。
* 全零不是2000-00-00日历,不能走Decode_Time;也不能把任意七字节都当作可忽略的占位。
*/
static bool Read_Placeholder_Valid(const uint8_t *bytes)
{
unsigned index;
for (index = 9U; index < 16U; ++index) {
if (bytes[index] != 0U) { return false; }
}
return true;
}
/**
* 功能:将回调的栈上time编码到任务bytes[9..15];两指针须非NULL,bytes仍保存已受理的全零读请求。
* 输入参数:time——时标。
* bytes——字节存储。
* 输出参数:time——时标的更新结果。
* 返回值: true只替换后七字节;
* false不改任务原占位,局部time的has_weekday可能已被规范为1。
* 不用CP56_To_Seconds,因为合法IV=1也应成功返回。
* 说明:time必须是本站UTC+8标准日历,与master_utc_offset_minutes无关;先拒绝非零SU及非法标志。
* has_weekday输入0/1都允许,随后强制带星期;公共编码按日期计算线上1..7,不照抄time.weekday。
* true只替换后七字节;false不改任务原占位,局部time的has_weekday可能已被规范为1。
* 公共编码负责真实日期及2000..2099范围校验;不用CP56_To_Seconds,因为合法IV=1也应成功返回。
*/
static bool Encode_Read_Time(IEC60870_CP56Time2a_t *time, uint8_t *bytes)
{
if (time->is_invalid > 1U || time->is_summer_time != 0U || time->has_weekday > 1U) { return false; }
time->has_weekday = 1U;
return IEC60870_Time_To_CP56(time, bytes + 9U, 7U) != 0;
}
/**
* 功能:查询当前身份是否还可执行/提交,不推进网络I/O。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:按处理分支返回state == IEC104_SLAVE_REQUEST_ERROR ? state : IEC104_SLAVE_REQUEST_STALE、state。
* 说明:WAIT_EVENTS先交回应用读通知:即使最终链路又已START,也不能跳过中间的STOP。
* 查询失败或通知读空后发现会话失效,统一取消任务;通知优先于业务期限归因。
*/
static IEC104_SlaveRequestState_t Check_Session(IEC104_ClockSynchronization_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))) {
Cancel(self);
self->status.active = false;
return state == IEC104_SLAVE_REQUEST_ERROR ? state : IEC104_SLAVE_REQUEST_STALE;
}
return state;
}
/**
* 功能:尚未执行的任务因期限或时间错误改为对应操作的否定回复,保留原槽和FIFO位置。
* 输入参数:task——业务任务。
* 输出参数:task——业务任务的更新结果。
* 返回值:无。
* 说明:不置executed,因此它走普通应答路径;后续Execute_Next不会再选中此任务。
*/
static void Negative_Reply(ClockTask *task)
{
/* 必须在改phase之前区分操作;读取失败/超时回复5,设时仍回复7。 */
task->cause = task->phase == CLOCK_READ ? IEC60870_ASDU_COT_REQUEST : IEC60870_ASDU_COT_ACTIVATION_CON;
task->phase = CLOCK_REPLY;
task->negative = true;
task->send_waiting = false;
}
/**
* 功能:返回启用中的执行期限剩余毫秒;0为到期(含单调时间倒退)。
* 输入参数:self——本模块实例。
* task——业务任务。
* now——当前时刻。
* 输出参数:无。
* 返回值:返回启用中的执行期限剩余毫秒;
* 说明:同一采样供到期判断与执行补偿使用;倒退显式归因,不依赖无符号下溢。
*/
static uint32_t Remaining(const IEC104_ClockSynchronization_t *self, const ClockTask *task, uint64_t now)
{
if (now < task->accepted_ms || now - task->accepted_ms >= self->config.execute_timeout_ms) { return 0U; }
return self->config.execute_timeout_ms - (uint32_t)(now - task->accepted_ms);
}
/**
* 功能:Process和Execute_Next共用的期限处理;就地转换,不调用应用、不直接发包。
* 输入参数:self——本模块实例。
* now——当前时刻。
* 输出参数:无。
* 返回值:无。
* 说明:只约束尚未执行的任务;action一旦调用,其确认等待不再受此期限约束。
*/
static void Expire(IEC104_ClockSynchronization_t *self, uint64_t now)
{
unsigned index;
if (self->config.execute_timeout_ms == 0U) { return; }
for (index = 0U; index < self->count; ++index) {
ClockTask *task = &self->tasks[self->order[index]];
if ((task->phase == CLOCK_EXECUTE || task->phase == CLOCK_READ) &&
!task->executed && Remaining(self, task, now) == 0U) {
Negative_Reply(task);
++self->status.timeouts;
}
}
}
/**
* 功能:提交入口可能先处理网络输入,导致前一次检查READY、实际提交却遇到STOP。
* 输入参数:self——本模块实例。
* identity——原会话身份。
* submitted——IEC104_TcpSubmitResult_t值。
* 输出参数:self——本模块实例的更新结果。
* 返回值:仅原会话仍健康、传输已停止且存在待消费通知时返回true;其他情况返回false。
* 说明:仅当同一连接仍健康、传输已停用且有未读通知时,将ERROR归为等待STOP通知。
* 此路径保留任务,不计发送WAIT;应用消费DEACTIVATED后统一取消。
* 其他ERROR不能冒充STOP,FATAL可能已写出字节,始终不可重试。
*/
static bool Defer_For_Stop(IEC104_ClockSynchronization_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;
}
/**
* 功能:一步最多提交一个目标,0表示让出,1表示有进展,-1表示查询/组包失败。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:一步最多提交一个目标,0表示让出,1表示有进展,-1表示查询/组包失败。
* 说明:每次先查会话,不能跨过发送入口顺带交付的新通知;任务头之外的应答不能抢先。
* 读结果在此之前已固定;广播切换目标只改应答CA,保留同一CP56及原OA/T,不为新目标再取时。
*/
static int Submit_Head(IEC104_ClockSynchronization_t *self)
{
ClockTask *task;
IEC60870_Asdu_t reply;
IEC104_TcpSubmitResult_t submitted;
IEC104_SlaveRequestState_t state = Check_Session(self);
if (state == IEC104_SLAVE_REQUEST_ERROR) { return -1; }
if (state != IEC104_SLAVE_REQUEST_READY || self->count == 0U) { return 0; }
task = &self->tasks[self->order[0]];
if (task->phase != CLOCK_REPLY) { return 0; }
if (task->stations._owner != NULL) {
/* WAIT期间删除当前目标也须跳过;快照保护节点存储,不重新按CA绑定替代站。 */
if (task->station != NULL && !IEC104_Station_Is_Registered(task->station)) { task->station = NULL; }
if (task->station == NULL) { task->station = IEC104_Slave_StationSnapshot_Next(&task->stations); }
if (task->station == NULL) { Remove_Task(self, task); return 1; }
task->response_ca = IEC104_Station_Get_Common_Address(task->station);
}
if (IEC60870_Asdu_Create_From_Buffer(&reply, IEC104_Slave_Get_Application_Layer_Parameters(self->slave),
task->bytes, sizeof(task->bytes)) != IEC60870_ASDU_OK ||
IEC60870_Asdu_Set_COT(&reply, task->cause) != IEC60870_ASDU_OK ||
IEC60870_Asdu_Set_Negative(&reply, task->negative) != IEC60870_ASDU_OK ||
IEC60870_Asdu_Set_CA(&reply, task->response_ca) != IEC60870_ASDU_OK) { return -1; }
/* 读/设时应答均走HIGH,不等待NORMAL积压;任务FIFO维护本模块全部应答的顺序。 */
submitted = IEC104_Slave_Send_Response_Priority(self->slave, &task->identity, &reply,
IEC104_BUSINESS_PRIORITY_CLOCK);
if (submitted == IEC104_TCP_SUBMIT_OK) {
/* OK只表示发送层接手,不等于socket写完或主站ACK;此时不可再次提交同一目标。 */
++self->status.submitted;
if (task->negative) { ++self->status.negative_submitted; }
task->send_waiting = false;
if (task->stations._owner != NULL) { task->station = NULL; }
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; }
Cancel(self);
self->status.active = false;
return 0;
}
/**
* 功能:对最早READ取一次快照:调用前已检查会话、通知、期限及非NULL action;now是执行检查tick。
* 输入参数:self——本模块实例。
* task——业务任务。
* action——动作回调。
* context——调用方上下文。
* now——当前时刻。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值: 返回OK表示回调已返回一次,包含false/非法输出以及随后发送等待、取消,不代表读成功或主站收到。
* 回调期间不再计执行期限,executed仍为false,因此本次读取不产生设时confirm_pending。
* 说明:request/time均为本次栈上对象,context仅原样借用;不保存回调,不读取RTC或调整应用时钟。
* 返回OK表示回调已返回一次,包含false/非法输出以及随后发送等待、取消,不代表读成功或主站收到。
* 先消费READ转REPLY再开放回调;in_action阻止提交尚未完成的临时回复,也阻止递归执行后续SET。
* 回调期间不再计执行期限,executed仍为false,因此本次读取不产生设时confirm_pending。
* 只有合法输出才写入原16字节任务;失败忽略输出并保留七零占位,成功IV=1与失败P/N=1分别表达。
* 快照生成后不补偿传输等待;广播各目标及发送WAIT均复用它,后续校时也不能改写这次读结果。
*/
static IEC104_ClockSynchronizationExecuteResult_t Execute_Read(IEC104_ClockSynchronization_t *self,
ClockTask *task, IEC104_ClockSynchronizationReadAction_t action, void *context, uint64_t now)
{
IEC104_ClockSynchronizationReadRequest_t request;
IEC60870_CP56Time2a_t time;
bool read;
memset(&request, 0, sizeof(request));
memset(&time, 0, sizeof(time));
request.generation = task->identity.generation;
request.receive_serial = task->receive_serial;
request.station_id = task->stations._owner != NULL ? 0U : 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.is_test = (task->bytes[2] & 0x80U) != 0U;
request.accepted_ms = task->accepted_ms;
request.base_ms = now;
task->phase = CLOCK_REPLY;
task->cause = IEC60870_ASDU_COT_REQUEST;
task->send_waiting = false;
self->in_action = true;
read = action(context, &request, &time);
self->in_action = false;
read = read && Encode_Read_Time(&time, task->bytes);
task->negative = !read;
++self->status.read_executed;
if (read) { ++self->status.read_succeeded; }
if (&self->tasks[self->order[0]] == task) { (void)Submit_Head(self); }
return IEC104_CLOCK_SYNCHRONIZATION_EXECUTE_OK;
}
/**
* 功能:受理一条103:先确认能对应完整对象,再按COT -> CA -> IOA -> 其他原因判错。
* 输入参数:self——本模块实例。
* event——事件。
* identity——原会话身份。
* 输出参数:self——本模块实例的更新结果。
* 返回值:已识别但畸形/满槽的请求返回HANDLED,不能再走44兜底。
* 说明:非本模块请求交后续处理器;已识别但畸形/满槽的请求返回HANDLED,不能再走44兜底。
* 本函数不调用应用;合法读请求进入READ,非TEST设时进入EXECUTE,其他可应答请求进入REPLY。
*/
static IEC104_ClockSynchronizationEventResult_t Request(IEC104_ClockSynchronization_t *self,
const IEC104_SlaveEvent_t *event, const IEC104_SlaveEventIdentity_t *identity)
{
IEC60870_AsduInfo_t info;
IEC60870_CP56Time2a_t time;
IEC104_Station_t *station;
ClockTask *task;
const uint8_t *data;
uint16_t length;
uint32_t ioa;
uint64_t utc_ms;
uint8_t cause = 0U;
bool broadcast, reading, valid_time;
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] != 103U ||
!IEC60870_Parse_ASDU_Header(event->asdu.parameters, data, length, &info)) {
return IEC104_CLOCK_SYNCHRONIZATION_EVENT_IGNORED;
}
if (info.object_count != 1U || info.information_objects_len < 10U) {
/* 无法保留唯一完整的IOA+CP56,不能靠截取或补零伪造可回显的请求。 */
++self->status.rejected;
return IEC104_CLOCK_SYNCHRONIZATION_EVENT_HANDLED;
}
ioa = (uint32_t)data[6] | ((uint32_t)data[7] << 8) | ((uint32_t)data[8] << 16);
station = IEC104_Slave_Get_Station(self->slave, info.common_address);
broadcast = info.common_address == IEC104_CA_BROADCAST && IEC104_Slave_Get_Station_Count(self->slave) != 0U;
reading = info.cause_of_transmission == IEC60870_ASDU_COT_REQUEST;
valid_time = reading ? Read_Placeholder_Valid(data) : Decode_Time(self, data, &time, &utc_ms);
/* 即使时间或读占位非法也保持COT -> CA -> IOA -> 结构/时间的错误优先级。 */
if (info.cause_of_transmission != IEC60870_ASDU_COT_ACTIVATION && !reading) {
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 || length != 16U || info.is_negative_confirm || !valid_time) {
cause = reading ? IEC60870_ASDU_COT_REQUEST : IEC60870_ASDU_COT_ACTIVATION_CON;
}
if (cause != 0U) { ++self->status.rejected; }
if (self->count == IEC104_CLOCK_SYNCHRONIZATION_TASK_CAPACITY) {
/* 既有任务尚未交完,满槽时立即回复新请求会插队;只丢新并分别计数。 */
++self->status.overloads;
++self->status.dropped_requests;
return IEC104_CLOCK_SYNCHRONIZATION_EVENT_HANDLED;
}
task = Allocate_Task(self);
if (task == NULL) { return IEC104_CLOCK_SYNCHRONIZATION_EVENT_ERROR; }
task->identity = *identity;
/* 原事件仍由调用方持有,只保存对象完整的前16字节;SQ/尾字节错误也可规范回显。
* 设时确认须保留原时标的GEN/星期;读取失败保留原占位,读取成功才替换后七字节。 */
memcpy(task->bytes, data, sizeof(task->bytes));
task->bytes[1] = 1U;
task->response_ca = info.common_address;
task->receive_serial = event->transport.data.i_frame.receive_serial;
/* 事件没有网络接收时刻,补偿从此处受理开始,无法补上此前FIFO及网络等待。 */
task->accepted_ms = IEC104_Net_Now_Ms();
/* 设时TEST仍只回显确认;读TEST必须取一次安全只读快照,不能回显全零并声称读取成功。
* 两类都沿用回复FIFO及广播快照;T位保存在原ASDU头,不产生额外设时动作。 */
task->phase = cause == 0U ? (reading ? CLOCK_READ : (!info.is_test ? CLOCK_EXECUTE : CLOCK_REPLY)) : CLOCK_REPLY;
task->cause = cause == 0U && info.is_test && !reading ? IEC60870_ASDU_COT_ACTIVATION_CON : cause;
task->negative = cause != 0U;
/* 无站广播没有快照,按COT优先级用原CA单帧回45或46。 */
if (broadcast) {
if (IEC104_Slave_StationSnapshot_Begin(self->slave, &task->stations) != IEC104_STATION_OK) {
Remove_Task(self, task);
return IEC104_CLOCK_SYNCHRONIZATION_EVENT_ERROR;
}
} else if (cause == 0U) {
if (IEC104_Slave_Acquire_Station(self->slave, station) != IEC104_STATION_OK) {
Remove_Task(self, task);
return IEC104_CLOCK_SYNCHRONIZATION_EVENT_ERROR;
}
task->station = station;
}
if (cause == 0U) { ++self->status.accepted; }
/* 只有唯一的单目标错误应答可尝试当场提交;Submit_Head仍先检查所有未读通知。 */
if (cause != 0U && !broadcast && self->count == 1U && Submit_Head(self) < 0) {
return IEC104_CLOCK_SYNCHRONIZATION_EVENT_ERROR;
}
return IEC104_CLOCK_SYNCHRONIZATION_EVENT_HANDLED;
}
/**
* 功能:默认主站使用UTC+8标准时,受理后最多等待15秒执行;
* 输入参数:config——配置。
* 输出参数:config——配置的更新结果。
* 返回值:无。
* 说明:NULL配置指针不作处理。
*/
void IEC104_ClockSynchronization_Config_Default(IEC104_ClockSynchronizationConfig_t *config)
{
if (config != NULL) {
memset(config, 0, sizeof(*config));
config->master_utc_offset_minutes = IEC60870_LOCAL_UTC_OFFSET_MINUTES;
config->execute_timeout_ms = 15000U;
}
}
/**
* 功能:创建只分配静态实例并复制配置,不初始化Slave、不消费通知,也不设置设备时间。
* 输入参数:slave——所属从站服务。
* config——配置。
* 输出参数:无。
* 返回值:按处理分支返回NULL、free_slot。
* 说明:同一Slave不能同时绑定两个校时实例;编号耗尽时拒绝创建,避免回绕复用编号。
*/
IEC104_ClockSynchronization_t *IEC104_ClockSynchronization_Create(IEC104_Slave_t *slave,
const IEC104_ClockSynchronizationConfig_t *config)
{
unsigned i;
IEC104_ClockSynchronization_t *free_slot = NULL;
if (config == NULL || config->master_utc_offset_minutes < -1439 ||
config->master_utc_offset_minutes > 1439 || next_serial == UINT64_MAX ||
IEC104_Slave_Get_Application_Layer_Parameters(slave) == NULL) { return NULL; }
for (i = 0U; i < IEC104_CLOCK_SYNCHRONIZATION_CAPACITY; ++i) {
if (clock_pool[i].in_use && clock_pool[i].slave == slave) { return NULL; }
if (!clock_pool[i].in_use && free_slot == NULL) { free_slot = &clock_pool[i]; }
}
if (free_slot == NULL) { return NULL; }
memset(free_slot, 0, sizeof(*free_slot));
free_slot->slave = slave;
free_slot->config = *config;
free_slot->serial = ++next_serial;
free_slot->in_use = true;
return free_slot;
}
/**
* 功能:有未完成任务时由调用方先Cancel;
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:!Owned(self) || self->in_action || self->count != 0U时返回false;其余分支返回false、true。
* 说明:回调期间不能释放action正在使用的实例。
*/
bool IEC104_ClockSynchronization_Destroy(IEC104_ClockSynchronization_t *self)
{
if (!Owned(self) || self->in_action || self->count != 0U) { return false; }
memset(self, 0, sizeof(*self));
return true;
}
/**
* 功能:本地取消保持会话激活状态,后续新请求仍可受理;
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:回调内调用无操作。
*/
void IEC104_ClockSynchronization_Cancel(IEC104_ClockSynchronization_t *self)
{
if (Owned(self) && !self->in_action) { Cancel(self); }
}
/**
* 功能:与其他业务模块一同按Slave FIFO顺序接收连接及启停通知,再分派I帧。
* 输入参数:self——本模块实例。
* event——事件。
* 输出参数:self——本模块实例的更新结果。
* 返回值:按处理分支返回IEC104_CLOCK_SYNCHRONIZATION_EVENT_ERROR、IEC104_CLOCK_SYNCHRONIZATION_EVENT_HANDLED、IEC104_CLOCK_SYNCHRONIZATION_EVENT_IGNORED、Request(self, event, &identity)。
* 说明:服务实例身份一旦绑定不得替换;CONNECTED重置连接代次,旧代次通知不推进任务。
* STOP/断线清理待执行及待确认任务,已调用action的设备时间不会被回滚。
*/
IEC104_ClockSynchronizationEventResult_t IEC104_ClockSynchronization_Handle_Event(
IEC104_ClockSynchronization_t *self, const IEC104_SlaveEvent_t *event)
{
IEC104_SlaveEventIdentity_t identity;
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_CLOCK_SYNCHRONIZATION_EVENT_ERROR;
}
self->session.slave = identity.slave;
self->session.instance_id = identity.instance_id;
if (event->transport.type == IEC104_TCP_EVENT_CONNECTED) {
Cancel(self);
self->session.generation = identity.generation;
self->status.active = false;
return IEC104_CLOCK_SYNCHRONIZATION_EVENT_HANDLED;
}
if (identity.generation != self->session.generation) { return IEC104_CLOCK_SYNCHRONIZATION_EVENT_IGNORED; }
switch (event->transport.type) {
case IEC104_TCP_EVENT_ACTIVATED:
self->status.active = true;
return IEC104_CLOCK_SYNCHRONIZATION_EVENT_HANDLED;
case IEC104_TCP_EVENT_DEACTIVATED:
case IEC104_TCP_EVENT_DISCONNECTED:
Cancel(self);
self->status.active = false;
if (event->transport.type == IEC104_TCP_EVENT_DISCONNECTED) { self->session.generation = 0U; }
return IEC104_CLOCK_SYNCHRONIZATION_EVENT_HANDLED;
case IEC104_TCP_EVENT_I_FRAME: return Request(self, event, &identity);
default: return IEC104_CLOCK_SYNCHRONIZATION_EVENT_IGNORED;
}
}
/**
* 功能:有界推进:每步先核对会话,再处理期限、尝试交接队首回复,绝不调用action。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值: ERROR/FATAL已按提交结果清理任务时返回true,false仅表示接口/查询/组包故障。
* 说明:广播每交接一个站或结束一次遍历均消耗一步;预算耗尽交回应用,避免独占事件循环。
* ERROR/FATAL已按提交结果清理任务时返回true,false仅表示接口/查询/组包故障。
*/
bool IEC104_ClockSynchronization_Process(IEC104_ClockSynchronization_t *self)
{
unsigned step;
if (!Owned(self) || self->in_action) { return false; }
for (step = 0U; step < 2U * IEC104_CLOCK_SYNCHRONIZATION_TASK_CAPACITY; ++step) {
IEC104_SlaveRequestState_t state = Check_Session(self);
int submitted;
if (state == IEC104_SLAVE_REQUEST_ERROR) { return false; }
if (state != IEC104_SLAVE_REQUEST_READY || self->count == 0U) { return true; }
Expire(self, IEC104_Net_Now_Ms());
if (self->tasks[self->order[0]].phase != CLOCK_REPLY) { return true; }
submitted = Submit_Head(self);
if (submitted <= 0) { return submitted == 0; }
}
return true;
}
/**
* 功能:保留原仅设时接口;缺少读回调时不能把READ当作已处理应答而越过去设时。
* 输入参数:self——本模块实例。
* action——动作回调。
* context——调用方上下文。
* 输出参数:self——本模块实例的更新结果。
* 返回值:按处理分支返回IEC104_CLOCK_SYNCHRONIZATION_EXECUTE_ERROR、IEC104_ClockSynchronization_Execute_Next_With_Read(self, action, NULL, context)。
* 说明:原接口的NULL action仍立即报参数错误,新入口按当前操作选择对应回调。
*/
IEC104_ClockSynchronizationExecuteResult_t IEC104_ClockSynchronization_Execute_Next(
IEC104_ClockSynchronization_t *self, IEC104_ClockSynchronizationAction_t action, void *context)
{
if (action == NULL) { return IEC104_CLOCK_SYNCHRONIZATION_EXECUTE_ERROR; }
return IEC104_ClockSynchronization_Execute_Next_With_Read(self, action, NULL, context);
}
/**
* 功能:显式统一调度:self须有效且不在回调中,至少提供一种回调;context只传给本次选中的回调。
* 输入参数:self——本模块实例。
* set_action——设置动作回调。
* read_action——读取动作回调。
* context——调用方上下文。
* 输出参数:self——本模块实例的更新结果。
* 返回值: 缺当前回调返回ERROR且保留任务,未读通知返回WAIT,无待执行操作返回EMPTY;
* 这些返回均不调用应用。
* 一次回调返回即为OK,即使其结果失败或应答发送WAIT;
* 说明:先选最早READ/EXECUTE,只能跳过已固定应答的REPLY;这是应用操作顺序,不要求前一应答先获ACK。
* READ取样后才可能执行后续SET,先设后读则由回调观察设时后的设备状态;应答另由Submit_Head保持FIFO。
* 缺当前回调返回ERROR且保留任务,未读通知返回WAIT,无待执行操作返回EMPTY;这些返回均不调用应用。
* 已过期或设时不可用的请求转否定后继续寻找,最终可能EMPTY且仍有回复待交。
* 一次回调返回即为OK,即使其结果失败或应答发送WAIT;不得把OK理解为可再调用同一读/设时操作。
*/
IEC104_ClockSynchronizationExecuteResult_t IEC104_ClockSynchronization_Execute_Next_With_Read(
IEC104_ClockSynchronization_t *self, IEC104_ClockSynchronizationAction_t set_action,
IEC104_ClockSynchronizationReadAction_t read_action, void *context)
{
unsigned index;
if (!Owned(self) || self->in_action || (set_action == NULL && read_action == NULL)) {
return IEC104_CLOCK_SYNCHRONIZATION_EXECUTE_ERROR;
}
for (;;) {
IEC104_ClockSynchronizationRequest_t request;
IEC104_SlaveRequestState_t state;
ClockTask *task = NULL;
uint64_t now, utc_ms;
bool synchronized;
for (index = 0U; index < self->count; ++index) {
if (self->tasks[self->order[index]].phase == CLOCK_EXECUTE ||
self->tasks[self->order[index]].phase == CLOCK_READ) {
task = &self->tasks[self->order[index]];
break;
}
}
if (task == NULL) { return IEC104_CLOCK_SYNCHRONIZATION_EXECUTE_EMPTY; }
state = Check_Session(self);
if (state == IEC104_SLAVE_REQUEST_ERROR) { return IEC104_CLOCK_SYNCHRONIZATION_EXECUTE_ERROR; }
if (state == IEC104_SLAVE_REQUEST_WAIT_EVENTS) { return IEC104_CLOCK_SYNCHRONIZATION_EXECUTE_WAIT; }
if (state != IEC104_SLAVE_REQUEST_READY) { return IEC104_CLOCK_SYNCHRONIZATION_EXECUTE_EMPTY; }
/* 缺少当前操作回调时保留原任务;尤其旧Execute_Next不能越过READ执行后续SET。
* Process仍可独立推进该任务的期限并在到期后生成否定回复。 */
if ((task->phase == CLOCK_READ && read_action == NULL) ||
(task->phase == CLOCK_EXECUTE && set_action == NULL)) {
return IEC104_CLOCK_SYNCHRONIZATION_EXECUTE_ERROR;
}
/* 期限与设时基准使用同一采样;到期转换保持原槽及顺序,不调用应用。 */
now = IEC104_Net_Now_Ms();
Expire(self, now);
if (task->phase == CLOCK_REPLY) { continue; }
if (task->phase == CLOCK_READ) {
/* 禁用期限也不能把倒退的单调时刻当作正常执行检查时刻。 */
if (now < task->accepted_ms) {
Negative_Reply(task);
++self->status.time_errors;
continue;
}
return Execute_Read(self, task, read_action, context, now);
}
memset(&request, 0, sizeof(request));
/* Decode_Time成功保证utc_ms不大于上限;先比较剩余空间,再加等待毫秒,
* 同时防止64位溢出及本站日历越2099年。期限关闭也不能跳过这些检查。 */
if (now < task->accepted_ms || !Decode_Time(self, task->bytes, &request.master_time, &utc_ms) ||
now - task->accepted_ms > Limit_Ms() - utc_ms) {
Negative_Reply(task);
++self->status.time_errors;
continue;
}
utc_ms += now - task->accepted_ms;
/* 只将补偿后的时间交给action;task->bytes中的主站CP56保持原样供Submit_Head回显。
* 成功、动作失败或超时否定均只改应答头,不能把归一化/补偿后的时间写回原请求。 */
if (!IEC60870_Time_Seconds_To_Local((uint32_t)(utc_ms / 1000U),
(uint16_t)(utc_ms % 1000U), &request.local_time)) {
Negative_Reply(task);
++self->status.time_errors;
continue;
}
request.generation = task->identity.generation;
request.receive_serial = task->receive_serial;
request.station_id = task->stations._owner != NULL ? 0U : 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.utc_ms = utc_ms;
request.accepted_ms = task->accepted_ms;
request.base_ms = now;
/* 先消费,再开放只读查询:回调内已不计执行期限,且confirm_pending为true。
* in_action阻止递归执行下一槽或释放当前槽,回调返回后不重新判定业务超时。 */
task->executed = true;
task->phase = CLOCK_REPLY;
task->cause = IEC60870_ASDU_COT_ACTIVATION_CON;
task->send_waiting = false;
self->in_action = true;
synchronized = set_action(context, &request);
self->in_action = false;
task->negative = !synchronized;
++self->status.executed;
if (synchronized) { ++self->status.synchronized; }
/* 动作结果与传输结果分开:此后无论等待、STOP或故障均不会重复动作。 */
if (&self->tasks[self->order[0]] == task) { (void)Submit_Head(self); }
return IEC104_CLOCK_SYNCHRONIZATION_EXECUTE_OK;
}
}
/**
* 功能:只读快照:重算未读通知、待执行/确认以及最近期限,不触发Expire或取消任务。
* 输入参数:self——本模块实例。
* status——状态快照。
* 输出参数:status——状态快照的更新结果。
* 返回值:!Owned(self) || status == NULL时返回false;state == IEC104_SLAVE_REQUEST_ERROR时返回false;其余分支返回false、true。
* 说明:回调中当前读/设时均已消费,不再计其期限;confirm_pending专指已开始的设时。
*/
bool IEC104_ClockSynchronization_Get_Status(const IEC104_ClockSynchronization_t *self,
IEC104_ClockSynchronizationStatus_t *status)
{
IEC104_SlaveRequestState_t state;
uint64_t now;
unsigned index;
if (!Owned(self) || status == NULL) { return false; }
state = IEC104_Slave_Check_Request(self->slave, &self->session);
if (state == IEC104_SLAVE_REQUEST_ERROR) { return false; }
*status = self->status;
status->generation = self->session.generation;
status->pending_requests = self->count;
status->events_pending = state == IEC104_SLAVE_REQUEST_WAIT_EVENTS;
status->execute_pending = false;
status->read_pending = false;
status->confirm_pending = false;
status->timer_active = false;
status->timeout_remaining_ms = 0U;
status->need_process = false;
now = IEC104_Net_Now_Ms();
for (index = 0U; index < self->count; ++index) {
const ClockTask *task = &self->tasks[self->order[index]];
if (task->executed) { status->confirm_pending = true; }
else if (task->phase == CLOCK_EXECUTE || task->phase == CLOCK_READ) {
status->execute_pending = true;
if (task->phase == CLOCK_READ) { status->read_pending = true; }
if (self->config.execute_timeout_ms != 0U) {
uint32_t remaining = Remaining(self, task, now);
if (!status->timer_active || remaining < status->timeout_remaining_ms) {
status->timer_active = true;
status->timeout_remaining_ms = remaining;
}
}
}
}
if (self->count != 0U && !self->in_action && !status->events_pending) {
const ClockTask *head = &self->tasks[self->order[0]];
/* 发送WAIT不要求空转;应用每次Poll并读空通知后仍必须Process重试。
* 需要清理的失效会话、到期任务或尚未等待发送的队首回复则应立即推进。 */
status->need_process = state != IEC104_SLAVE_REQUEST_READY || !status->active ||
(status->timer_active && status->timeout_remaining_ms == 0U) ||
(head->phase == CLOCK_REPLY && !head->send_waiting);
}
return true;
}