826 lines
43 KiB
C
826 lines
43 KiB
C
/*
|
||
* 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;
|
||
}
|