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

759 lines
37 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 Type102读命令:固定槽FIFO、会话隔离及受理到提交前的期限。
*
* 入口分工:Handle_Event只校验/保存请求;Process只清理与发送错误回复;
* Execute_Next才调用应用lookup,Get_Status只导出调度快照。全部与Slave串行调用。
*
* 任务不变量:order[0..count)唯一列出所有occupied槽;稳定状态的READ_VALUE持有原站引用,
* READ_REPLY只需请求副本。发送/取值只能操作队首,超时扫描可以移除任意到期槽。
* 数据应答仅存在于Execute_Next栈上,提交WAIT丢弃值但保留READ_VALUE;
* UNKNOWN在原槽转READ_REPLY并立即释放引用,后续仅重发47,不再取值。
*
* 本模块完成点是发送层接手;不等待ACK,也不向应用提供“成功上报后清标志”回调。
* 公共契约见IEC104_Read.h;流程及验证见docs/104/IEC104_Read_设计架构.md。
*/
#include "IEC104_Read.h"
#include "IEC104_TcpServer_Config.h"
#include "IEC104_Net.h"
#include "IEC104_AsduQueue.h"
#include <string.h>
#ifndef IEC104_READ_CAPACITY
#define IEC104_READ_CAPACITY IEC104_TCP_SERVER_CAPACITY
#endif
#ifndef IEC104_READ_TASK_CAPACITY
#define IEC104_READ_TASK_CAPACITY 4U
#endif
_Static_assert(IEC104_READ_CAPACITY > 0U, "Read needs instance storage");
_Static_assert(IEC104_READ_TASK_CAPACITY > 0U && IEC104_READ_TASK_CAPACITY <= UINT32_MAX / 2U,
"Read needs bounded task storage");
/**
* 功能:专项测试只替换“余量快照”和“提交”两个边界;会话检查仍使用真实Slave。
* 输入参数:self——有效句柄;status——非NULL输出存储;error——可选诊断。
* 输出参数:status——状态快照的更新结果。
* error——错误诊断的更新结果。
* 返回值:OK写入status,失败保持输出;Create后、Init失败后和Close后均可查询。
* 说明:生产编译不定义此宏,也不保留钩子函数指针或测试符号。
*/
#ifdef IEC104_READ_TEST_HOOKS
extern IEC104_TcpResult_t IEC104_Read_Test_Get_Status(const IEC104_Slave_t *slave,
IEC104_TcpServerStatus_t *status, IEC104_TcpError_t *error);
/**
* 功能:使用默认业务等级向请求所属连接提交应答。
* 输入参数:self/identity——从站服务及请求身份;asdu——待提交的应答ASDU。
* 输出参数:self——本模块实例的更新结果。
* 返回值:OK已复制接手;WAIT未接手;ERROR为身份或ASDU非法;FATAL为连接故障。
* 说明:可直接交接或进入HIGH队列;本入口不返回票据,成功不表示对端已确认。
*/
extern IEC104_TcpSubmitResult_t IEC104_Read_Test_Send_Response(IEC104_Slave_t *slave,
const IEC104_SlaveEventIdentity_t *identity, const IEC60870_Asdu_t *response);
#define READ_ROOM_STATUS IEC104_Read_Test_Get_Status
#define READ_SEND_RESPONSE IEC104_Read_Test_Send_Response
#else
#define READ_ROOM_STATUS IEC104_Slave_Get_Status
/* 读命令在12级业务优先级中扩展与非初始化召唤同级,不据返回数据Type改变应答等级。 */
#define READ_SEND_RESPONSE(s, i, a) IEC104_Slave_Send_Response_Priority(s, i, a, IEC104_BUSINESS_PRIORITY_INTERROGATION)
#endif
/* 0保留给清零后的空槽;occupied决定槽是否有效,不借phase代替占用判断。 */
enum { READ_VALUE = 1, READ_REPLY = 2 };
typedef struct {
IEC104_SlaveEventIdentity_t identity; /* 原Slave实例及TCP代次,提交时不改绑当前连接。 */
IEC104_Station_t *station; /* READ_VALUE持有一个引用;释放或转REPLY后置NULL。 */
uint64_t receive_serial, accepted_ms; /* 诊断流水号;固定期限起点,重试不刷新。 */
uint8_t bytes[9]; /* 规范Type102副本;仅REPLY构造时允许改其中COT/P-N。 */
uint8_t phase, cause; /* READ_VALUE/READ_REPLY;REPLY的45/46/47原因。 */
bool occupied, send_waiting; /* 后者只表示该队首上次受发送容量阻塞。 */
} ReadTask;
struct IEC104_Read {
IEC104_Slave_t *slave; /* 借用,必须晚于Read销毁。 */
IEC104_SlaveEventIdentity_t session; /* 由已分派通知建立,不能只读传输最终状态猜测。 */
IEC104_ReadConfig_t config;
IEC104_ReadStatus_t status; /* 持久计数/激活标志;队列与期限字段由Get_Status合成。 */
ReadTask tasks[IEC104_READ_TASK_CAPACITY];
unsigned order[IEC104_READ_TASK_CAPACITY], count; /* FIFO下标/占槽数,任务本体地址稳定。 */
bool in_use, in_lookup; /* 池占用;仅保护本实例的修改入口,不是线程锁或Slave全局锁。 */
};
static IEC104_Read_t read_pool[IEC104_READ_CAPACITY];
/**
* 功能:先用地址匹配池槽再解引用,NULL/池外指针安全返回false;
* 输入参数:self——本模块实例。
* 输出参数:无。
* 返回值:true表示句柄属于当前占用的静态实例槽;NULL、池外地址或未占用槽返回false。
* 说明:销毁后的旧句柄不得复用。
*/
static bool Owned(const IEC104_Read_t *self)
{
unsigned i;
for (i = 0U; i < IEC104_READ_CAPACITY; ++i) {
if (self == &read_pool[i]) { return self->in_use; }
}
return false;
}
/**
* 功能:归还本任务Acquire的那一个引用并清指针,随后Remove_Task不会重复Release。
* 输入参数:self——本模块实例。
* task——业务任务。
* 输出参数:task——业务任务的更新结果。
* 返回值:无。
* 说明:Release可能使已删除节点立即可复用;本任务之后不能再依赖此前借用的原站/context。
*/
static void Release_Station(IEC104_Read_t *self, ReadTask *task)
{
if (task->station != NULL) {
(void)IEC104_Slave_Release_Station(self->slave, task->station);
task->station = NULL;
}
}
/**
* 功能:task必须是本实例的占用槽。释放站点、删除顺序下标并清空槽,不搬移其他任务。
* 输入参数:self——本模块实例。
* task——业务任务。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:无。
* 说明:计数由结束原因所在分支增加;这里不把超时、取消和应用失败混记。
* 队首变化即清除新队首的send_waiting,旧任务的背压不能抑制新任务首次尝试。
*/
static void Remove_Task(IEC104_Read_t *self, ReadTask *task)
{
unsigned i, slot = (unsigned)(task - self->tasks);
bool was_head = self->count != 0U && self->order[0] == slot;
Release_Station(self, task);
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 (was_head && self->count != 0U) { self->tasks[self->order[0]].send_waiting = false; }
}
/**
* 功能:内部统一收尾:每个仍占槽的READ/REPLY计一次cancelled,不改变激活状态或已提交帧。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:调用方按原因决定是否active=false;公共Cancel允许本会话继续接纳新请求。
*/
static void Cancel(IEC104_Read_t *self)
{
while (self->count != 0U) {
++self->status.cancelled;
Remove_Task(self, &self->tasks[self->order[0]]);
}
}
/**
* 功能:查询并归一化会话状态,同时处理ERROR/STALE的整队列取消。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值: 返回READY才可继续取值或提交;
* ERROR/STALE返回前可能已清空全部槽。
* 说明:WAIT_EVENTS优先于最终连接状态:不能越过同代次内尚未分派的STOP/START执行旧请求。
* 返回READY才可继续取值或提交;ERROR/STALE返回前可能已清空全部槽。
*/
static IEC104_SlaveRequestState_t Check_Session(IEC104_Read_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;
}
/**
* 功能:调用前须确认期限非0。先检查64位倒退/到期,再将已证明小于期限的差值收窄到32位。
* 输入参数:self——本模块实例。
* task——业务任务。
* now——当前时刻。
* 输出参数:无。
* 返回值:按处理分支返回0U、self->config.request_timeout_ms - (uint32_t)(now - task->accepted_ms)。
* 说明:接受时刻固定,重试不得重置期限;now与accepted_ms相等时仍有完整预算。
*/
static uint32_t Remaining(const IEC104_Read_t *self, const ReadTask *task, uint64_t now)
{
if (now < task->accepted_ms || now - task->accepted_ms >= self->config.request_timeout_ms) { return 0U; }
return self->config.request_timeout_ms - (uint32_t)(now - task->accepted_ms);
}
/**
* 功能:用同一采样扫描全部占槽任务,保证Get_Status报告的最小期限都能被处理。
* 输入参数:self——本模块实例。
* now——当前时刻。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:移除后下标i处已换成下一项,不能自增跳过它;结束后调用方必须重新检查空队列/队首。
*/
static void Expire(IEC104_Read_t *self, uint64_t now)
{
unsigned i = 0U;
if (self->config.request_timeout_ms == 0U) { return; }
while (i < self->count) {
ReadTask *task = &self->tasks[self->order[i]];
if (Remaining(self, task, now) == 0U) {
++self->status.timeouts;
Remove_Task(self, task);
} else { ++i; }
}
}
/**
* 功能:Send_Response可能先处理已缓存的STOP;只有ERROR且原连接仍健康、已停止传输、
* 输入参数:self——本模块实例。
* identity——原会话身份。
* submitted——IEC104_TcpSubmitResult_t值。
* 输出参数:self——本模块实例的更新结果。
* 返回值:仅原会话仍健康、传输已停止且存在待消费通知时返回true;其他情况返回false。
* 说明:还有未读通知时让出,由DEACTIVATED按FIFO取消任务。普通ERROR和FATAL不能重试。
* 这里只读状态并设置提示;不消费通知,不替调用者推进Slave。
*/
static bool Defer_For_Stop(IEC104_Read_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;
}
/**
* 功能:前置:任务为队首,已完成会话及最后一次期限检查;response只在调用内借用。
* 输入参数:self——本模块实例。
* task——业务任务。
* response——应答。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值: true表示原任务已移除(提交成功或发送故障取消),不等同发送成功;
* false表示WAIT或正常STOP待通知,任务保持占槽。
* 调用者不得在true后继续解引用task。
* 说明:true表示原任务已移除(提交成功或发送故障取消),不等同发送成功;
* false表示WAIT或正常STOP待通知,任务保持占槽。调用者不得在true后继续解引用task。
* 提交OK后原文已由发送层接手,直接累计并释放,不再按新的时钟值追认超时。
*/
static bool Submit(IEC104_Read_t *self, ReadTask *task, const IEC60870_Asdu_t *response)
{
IEC104_TcpSubmitResult_t submitted = READ_SEND_RESPONSE(self->slave, &task->identity, response);
if (submitted == IEC104_TCP_SUBMIT_OK) {
++self->status.submitted;
if (task->phase == READ_REPLY) { ++self->status.negative_submitted; }
else { ++self->status.answered; }
Remove_Task(self, task);
return true;
}
if (submitted == IEC104_TCP_SUBMIT_WAIT) {
++self->status.waits;
task->send_waiting = true;
return false;
}
if (Defer_For_Stop(self, &task->identity, submitted)) { return false; }
Cancel(self);
self->status.active = false;
return true;
}
/**
* 功能:前置:队首READ_REPLY且station=NULL,会话/期限已检查。
* 输入参数:self——本模块实例。
* task——业务任务。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值: 返回1:任务已移除;
* 说明:错误回复只借用槽内9字节副本,经Set_COT/Set_Negative原位改头;重试重复设置幂等,
* 不需要额外数据缓存,不改变TEST/OA/CA/IOA。原Slave事件从未被修改。
* 返回1:任务已移除;0:保留等待;-1:内部组包失败且已取消、停用实例。
*/
static int Submit_Reply(IEC104_Read_t *self, ReadTask *task)
{
IEC60870_Asdu_t reply;
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, 1) != IEC60870_ASDU_OK) {
Cancel(self);
self->status.active = false;
return -1;
}
return Submit(self, task, &reply) ? 1 : 0;
}
/**
* 功能:选一个空槽并把下标追加到FIFO;调用方随后填身份和阶段,申请站点失败须Remove_Task回滚。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值: 满槽返回NULL且不改队列;
* 说明:满槽返回NULL且不改队列;正常入口已先检查count,用于防御内部状态不一致。
*/
static ReadTask *Allocate_Task(IEC104_Read_t *self)
{
unsigned i;
for (i = 0U; i < IEC104_READ_TASK_CAPACITY; ++i) {
if (!self->tasks[i].occupied) {
ReadTask *task = &self->tasks[i];
memset(task, 0, sizeof(*task));
task->occupied = true;
self->order[self->count++] = i;
return task;
}
}
return NULL;
}
/**
* 功能:Slave固定使用标准104参数,IOA为3字节小端;
* 输入参数:data——数据存储。
* 输出参数:无。
* 返回值:返回(uint32_t)data[0] | ((uint32_t)data[1] << 8) | ((uint32_t)data[2] << 16)的结果。
* 说明:只读Parse已证明完整的对象区。
*/
static uint32_t Read_IOA(const uint8_t *data)
{
return (uint32_t)data[0] | ((uint32_t)data[1] << 8) | ((uint32_t)data[2] << 16);
}
/**
* 功能:仅由Handle_Event在核对I帧归属/当前代次后调用,不执行应用lookup。
* 输入参数:self——本模块实例。
* event——事件。
* identity——原会话身份。
* 输出参数:self——本模块实例的更新结果。
* 返回值:按处理分支返回IEC104_READ_EVENT_IGNORED、IEC104_READ_EVENT_HANDLED、IEC104_READ_EVENT_ERROR。
* 说明:畸形请求不占槽;语义错误和合法READ共用FIFO。rejected先于满槽判断,
* 所以错误请求遇满槽会同时计rejected、overloads和dropped_requests。
*/
static IEC104_ReadEventResult_t Request(IEC104_Read_t *self, const IEC104_SlaveEvent_t *event,
const IEC104_SlaveEventIdentity_t *identity)
{
IEC60870_AsduInfo_t info;
const uint8_t *data;
uint16_t length;
IEC104_Station_t *station;
ReadTask *task;
uint8_t cause = 0U;
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] != 102U) { return IEC104_READ_EVENT_IGNORED; }
/* 畸形请求优先静默丢弃,不能被COT/CA/IOA错误变成可应答请求。 */
if (IEC60870_Asdu_Parse(event->asdu.parameters, data, length, &info) != IEC60870_ASDU_OK ||
info.is_negative_confirm) {
++self->status.rejected;
return IEC104_READ_EVENT_HANDLED;
}
station = IEC104_Slave_Get_Station(self->slave, info.common_address);
if (info.cause_of_transmission != IEC60870_ASDU_COT_REQUEST) { cause = IEC60870_ASDU_COT_UNKNOWN_CAUSE; }
else if (station == NULL || info.common_address == IEC104_CA_BROADCAST) {
cause = IEC60870_ASDU_COT_UNKNOWN_COMMON_ADDRESS;
} else if (Read_IOA(info.information_objects) == 0U) { cause = IEC60870_ASDU_COT_UNKNOWN_IOA; }
if (cause != 0U) { ++self->status.rejected; }
if (self->count == IEC104_READ_TASK_CAPACITY) {
++self->status.overloads;
++self->status.dropped_requests;
return IEC104_READ_EVENT_HANDLED;
}
task = Allocate_Task(self);
if (task == NULL) { return IEC104_READ_EVENT_ERROR; }
task->identity = *identity;
memcpy(task->bytes, data, sizeof(task->bytes));
task->receive_serial = event->transport.data.i_frame.receive_serial;
task->accepted_ms = IEC104_Net_Now_Ms(); /* 从入槽受理开始计时,不含此前Slave通知排队。 */
task->cause = cause;
task->phase = cause == 0U ? READ_VALUE : READ_REPLY;
/* READ先持有原站;唯一错误回复可立即尝试,已有队首时则留队,绝不越过READ。 */
if (cause == 0U) {
if (IEC104_Slave_Acquire_Station(self->slave, station) != IEC104_STATION_OK) {
Remove_Task(self, task);
return IEC104_READ_EVENT_ERROR;
}
task->station = station;
++self->status.accepted;
} else if (self->count == 1U && !IEC104_Read_Process(self)) { return IEC104_READ_EVENT_ERROR; }
return IEC104_READ_EVENT_HANDLED;
}
/**
* 功能:写项目默认受理期限;
* 输入参数:config——配置。
* 输出参数:config——配置的更新结果。
* 返回值:无。
* 说明:NULL兼容无操作,不创建定时器。
*/
void IEC104_Read_Config_Default(IEC104_ReadConfig_t *config)
{
if (config != NULL) { config->request_timeout_ms = 15000U; }
}
/**
* 功能:绑定有效Slave并占用静态实例槽,复制配置;
* 输入参数:slave——所属从站服务。
* config——配置。
* 输出参数:无。
* 返回值:成功句柄;非法参数、同Slave重复绑定或池满为NULL,失败不改变已有实例。
* 生命周期起点由后续通知建立,不能用本接口把新模块热挂到已消费通知的会话。
* 说明:不监听网络或保存应用回调。
*/
IEC104_Read_t *IEC104_Read_Create(IEC104_Slave_t *slave, const IEC104_ReadConfig_t *config)
{
IEC104_Read_t *free_slot = NULL;
unsigned i;
if (config == NULL || IEC104_Slave_Get_Application_Layer_Parameters(slave) == NULL) { return NULL; }
for (i = 0U; i < IEC104_READ_CAPACITY; ++i) {
if (read_pool[i].in_use && read_pool[i].slave == slave) { return NULL; }
if (!read_pool[i].in_use && free_slot == NULL) { free_slot = &read_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->in_use = true;
return free_slot;
}
/**
* 功能:仅归还空闲模块的池槽,不隐式Cancel或销毁Slave;
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:!Owned(self) || self->in_lookup || self->count != 0U时返回false;其余分支返回false、true。
* 说明:失败时句柄仍有效。
*/
bool IEC104_Read_Destroy(IEC104_Read_t *self)
{
if (!Owned(self) || self->in_lookup || self->count != 0U) { return false; }
memset(self, 0, sizeof(*self));
return true;
}
/**
* 功能:主动取消本模块尚持有的请求;
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:无效/回调重入无操作,不影响已接手的HIGH原帧。
*/
void IEC104_Read_Cancel(IEC104_Read_t *self)
{
if (Owned(self) && !self->in_lookup) { Cancel(self); }
}
/**
* 功能:按应用分派顺序维护生命周期或接收Type102;事件只借用,不修改或保存其指针。
* ERROR表示归属/重入等失败,不能继续当未知类型兜底;HANDLED包含主动丢弃。
* CONNECTED先换代再比较generation;其他旧代次通知均忽略。
* 输入参数:self——本模块实例。
* event——事件。
* 输出参数:self——本模块实例的更新结果。
* 返回值:按处理分支返回IEC104_READ_EVENT_ERROR、IEC104_READ_EVENT_HANDLED、IEC104_READ_EVENT_IGNORED、Request(self, event, &identity)。
* 说明:内部调用:Owned、IEC104_Slave_Get_Event_Identity、Cancel、Request。
*/
IEC104_ReadEventResult_t IEC104_Read_Handle_Event(IEC104_Read_t *self, const IEC104_SlaveEvent_t *event)
{
IEC104_SlaveEventIdentity_t identity;
if (!Owned(self) || self->in_lookup ||
!IEC104_Slave_Get_Event_Identity(self->slave, event, &identity) ||
(self->session.instance_id != 0U && self->session.instance_id != identity.instance_id)) {
return IEC104_READ_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_READ_EVENT_HANDLED;
}
if (identity.generation != self->session.generation) { return IEC104_READ_EVENT_IGNORED; }
switch (event->transport.type) {
case IEC104_TCP_EVENT_ACTIVATED:
self->status.active = true;
return IEC104_READ_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_READ_EVENT_HANDLED;
case IEC104_TCP_EVENT_I_FRAME: return Request(self, event, &identity);
default: return IEC104_READ_EVENT_IGNORED;
}
}
/**
* 功能:有界清理失效/到期任务并提交队首错误回复,遇READ或WAIT就返回,不执行lookup。
* 返回true包含“等待通知/网络”和“发送故障已清理”,不表示所有请求已经应答。
* 即使Get_Status没有need_process,每轮网络推进后也必须调用,以重试REPLY的WAIT。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:功能:有界清理失效/到期任务并提交队首错误回复,遇READ或WAIT就返回,不执行lookup。
* 返回true包含“等待通知/网络”和“发送故障已清理”,不表示所有请求已经应答。
* 说明:内部调用:Owned、Check_Session、Expire、IEC104_Net_Now_Ms、Submit_Reply。
*/
bool IEC104_Read_Process(IEC104_Read_t *self)
{
unsigned step;
if (!Owned(self) || self->in_lookup) { return false; }
for (step = 0U; step < 2U * IEC104_READ_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->count == 0U || self->tasks[self->order[0]].phase == READ_VALUE) { return true; }
submitted = Submit_Reply(self, &self->tasks[self->order[0]]);
if (submitted <= 0) { return submitted == 0; }
}
return true;
}
/**
* 功能:保守检查最大应答容量,不预留空间;即使实际点只有10字节也按最大21字节预检。
* 输入参数:self——本模块实例。
* task——业务任务。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值: 返回1:空间够并清send_waiting;
* 说明:返回1:空间够并清send_waiting;0:不足、记room_waits;-1:查询/快照错误并整队列取消。
* 不替代Check_Session。lookup禁止推进Slave是预检与提交间容量保持的调用前提。
*/
static int Check_Room(IEC104_Read_t *self, ReadTask *task)
{
IEC104_TcpServerStatus_t status;
if (IEC104_Slave_Strict_Priority_Enabled(self->slave)) {
/* 低等级原文占满HIGH时,本轮获准的较高等级仍可能直接交接;不能只按字节环余量拒绝取值。
* Query只是容量/阶段预检,不预约资源;预检WAIT时保留队首、不调用lookup。
* 后续真实提交仍可能WAIT,此时按原契约丢弃临时结果,下轮重新取值。 */
IEC104_TcpSubmitResult_t room = IEC104_Slave_Query_Response_Priority(self->slave, &task->identity,
IEC104_READ_RESPONSE_MAX_LEN, IEC104_BUSINESS_PRIORITY_INTERROGATION);
if (room == IEC104_TCP_SUBMIT_WAIT) {
++self->status.room_waits; task->send_waiting = true; return 0;
}
if (room != IEC104_TCP_SUBMIT_OK) {
Cancel(self); self->status.active = false; return -1;
}
task->send_waiting = false; return 1;
}
if (READ_ROOM_STATUS(self->slave, &status, NULL) != IEC104_TCP_OK || !status.asdu_queue_status_valid) {
Cancel(self);
self->status.active = false;
return -1;
}
if (status.high_queue.free_bytes < IEC104_ASDU_HIGH_ENTRY_HEADER_LEN + IEC104_READ_RESPONSE_MAX_LEN) {
++self->status.room_waits;
task->send_waiting = true;
return 0;
}
task->send_waiting = false;
return 1;
}
/**
* 功能:读业务类型白名单,不等于对象编解码器支持的全部类型。
* 输入参数:type——类型。
* 输出参数:无。
* 返回值:类型1/3/5/7/9/11/13/20/21及30..36返回true,其余类型返回false。
* 说明:新增项须重算最大应答长度。
*/
static bool Allowed_Type(uint8_t type)
{
switch (type) {
case 1: case 3: case 5: case 7: case 9: case 11: case 13: case 20: case 21:
case 30: case 31: case 32: case 33: case 34: case 35: case 36: return true;
default: return false;
}
}
/**
* 功能:仅FOUND需要此检查,所有判断无副作用;先查容器归属,避免使用被替换的缓冲/参数。
* 输入参数:response——应答。
* buffer——缓冲区。
* capacity——存储容量。
* parameters——应用层参数。
* task——业务任务。
* 输出参数:无。
* 返回值:容器归属、对象类型/数量、COT、标志及CA/OA/IOA均符合原读请求返回true,否则false。
* 说明:Get_Data校验容器内部一致性;Parse逐对象解码,不再Get_Element重复解码。
* 公共头与IOA使用槽内原请求比较,不相信回调借用的request结构仍未被违规改写。
* 这些检查不能防止回调先修改capacity并越界写,调用方必须遵守容器契约。
*/
static bool Response_Valid(const IEC60870_Asdu_t *response, uint8_t *buffer, uint16_t capacity,
const IEC60870_AppLayerParameters_t *parameters, const ReadTask *task)
{
IEC60870_AsduInfo_t info;
const uint8_t *data;
uint16_t length;
if (response->buffer != buffer || response->capacity != capacity ||
response->parameters != parameters || response->is_from_buffer != 0U ||
IEC60870_Asdu_Get_Data(response, &data, &length) != IEC60870_ASDU_OK ||
IEC60870_Asdu_Parse(parameters, data, length, &info) != IEC60870_ASDU_OK) { return false; }
return Allowed_Type(info.type_id) && info.object_count == 1U && !info.is_sequence &&
info.cause_of_transmission == IEC60870_ASDU_COT_REQUEST && !info.is_negative_confirm &&
info.is_test == ((task->bytes[2] >> 7) & 1U) && info.originator_address == task->bytes[3] &&
info.common_address == ((uint16_t)task->bytes[4] | ((uint16_t)task->bytes[5] << 8)) &&
Read_IOA(info.information_objects) == Read_IOA(task->bytes + 6U);
}
/**
* 功能:对清理后的队首READ至多取值一次,合法值在本次调用内立即尝试提交。
* 返回值区分“调用过lookup且READ已结束/转回复”(OK)与“保留READ等待”(WAIT),
* 让应用可按OK有界续跑;到期清理本身不算一次lookup,可能清空队列并返回EMPTY。
* lookup与借用容器只在本栈帧存活,模块不缓存正数据或回调。完整契约见头文件。
* 输入参数:self——本模块实例。
* lookup——取值回调。
* context——调用方上下文。
* 输出参数:self——本模块实例的更新结果。
* 返回值: 返回值区分“调用过lookup且READ已结束/转回复”(OK)与“保留READ等待”(WAIT), 让应用可按OK有界续跑;
* 到期清理本身不算一次lookup,可能清空队列并返回EMPTY。
* 说明:内部调用:Owned、Check_Session、IEC104_Net_Now_Ms、Expire、Check_Room、memset等。
*/
IEC104_ReadExecuteResult_t IEC104_Read_Execute_Next(IEC104_Read_t *self,
IEC104_ReadLookup_t lookup, void *context)
{
IEC104_SlaveRequestState_t state;
IEC104_ReadLookupResult_t result;
IEC104_ReadRequest_t request;
IEC60870_AsduHeader_t header;
IEC60870_Asdu_t response;
const IEC60870_AppLayerParameters_t *parameters;
uint8_t bytes[IEC104_READ_RESPONSE_MAX_LEN];
uint16_t capacity;
ReadTask *task;
uint64_t now;
int room;
if (!Owned(self) || self->in_lookup || lookup == NULL) { return IEC104_READ_EXECUTE_ERROR; }
/* EMPTY不查询会话:WAIT始终对应真实存在且未离开READ状态的队首。 */
if (self->count == 0U || self->tasks[self->order[0]].phase != READ_VALUE) { return IEC104_READ_EXECUTE_EMPTY; }
state = Check_Session(self);
if (state == IEC104_SLAVE_REQUEST_ERROR) { return IEC104_READ_EXECUTE_ERROR; }
if (state == IEC104_SLAVE_REQUEST_WAIT_EVENTS) { return IEC104_READ_EXECUTE_WAIT; }
if (state != IEC104_SLAVE_REQUEST_READY) { return IEC104_READ_EXECUTE_EMPTY; }
now = IEC104_Net_Now_Ms();
Expire(self, now);
if (self->count == 0U || self->tasks[self->order[0]].phase != READ_VALUE) { return IEC104_READ_EXECUTE_EMPTY; }
task = &self->tasks[self->order[0]];
room = Check_Room(self, task);
if (room < 0) { return IEC104_READ_EXECUTE_ERROR; }
if (room == 0) { return IEC104_READ_EXECUTE_WAIT; }
memset(&request, 0, sizeof(request));
request.generation = task->identity.generation;
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.is_test = (task->bytes[2] & 0x80U) != 0U;
request.ioa = Read_IOA(task->bytes + 6U);
request.accepted_ms = task->accepted_ms;
request.base_ms = now;
memset(&header, 0, sizeof(header));
header.cause_of_transmission = IEC60870_ASDU_COT_REQUEST;
header.common_address = request.common_address;
header.originator_address = request.originator_address;
header.is_test = request.is_test;
parameters = IEC104_Slave_Get_Application_Layer_Parameters(self->slave);
if (IEC60870_Asdu_Create(&response, parameters, bytes, sizeof(bytes), &header, 0) != IEC60870_ASDU_OK) {
Cancel(self);
self->status.active = false;
return IEC104_READ_EXECUTE_ERROR;
}
capacity = response.capacity;
++self->status.lookups;
self->in_lookup = true;
result = lookup(context, &request, &response);
self->in_lookup = false;
/* 无可发送结果时先按应用失败归因并结束;只有FOUND/UNKNOWN通过检查后才再查会话和期限。
* 因而返回ERROR或非法FOUND的同次回调,即使耗时跨期限,也不重复计timeouts。 */
if (result == IEC104_READ_LOOKUP_ERROR) {
++self->status.lookup_errors;
Remove_Task(self, task);
return IEC104_READ_EXECUTE_OK;
}
if ((result != IEC104_READ_LOOKUP_FOUND && result != IEC104_READ_LOOKUP_UNKNOWN) ||
(result == IEC104_READ_LOOKUP_FOUND && !Response_Valid(&response, bytes, capacity, parameters, task))) {
++self->status.invalid_responses;
Remove_Task(self, task);
return IEC104_READ_EXECUTE_OK;
}
/* 合法结果也要重新检查会话与期限;不能把取值耗时当作有效期之外的时间。 */
state = Check_Session(self);
if (state == IEC104_SLAVE_REQUEST_ERROR) { return IEC104_READ_EXECUTE_ERROR; }
if (state == IEC104_SLAVE_REQUEST_WAIT_EVENTS) { return IEC104_READ_EXECUTE_WAIT; }
if (state != IEC104_SLAVE_REQUEST_READY) { return IEC104_READ_EXECUTE_OK; }
if (self->config.request_timeout_ms != 0U && Remaining(self, task, IEC104_Net_Now_Ms()) == 0U) {
++self->status.timeouts;
Remove_Task(self, task);
return IEC104_READ_EXECUTE_OK;
}
if (result == IEC104_READ_LOOKUP_UNKNOWN) {
++self->status.unknown_ioa;
Release_Station(self, task);
task->phase = READ_REPLY;
task->cause = IEC60870_ASDU_COT_UNKNOWN_IOA;
task->send_waiting = false;
/* READ已经结束;WAIT只重试47,不再调用lookup。 */
if (Submit_Reply(self, task) < 0) { return IEC104_READ_EXECUTE_ERROR; }
return IEC104_READ_EXECUTE_OK;
}
/* OK后绝不追认超时;提交可能已经写出字节。WAIT丢弃本次栈上数据,下轮重新取值。 */
return Submit(self, task, &response) ? IEC104_READ_EXECUTE_OK : IEC104_READ_EXECUTE_WAIT;
}
/**
* 功能:只读生成调度快照;先查服务,成功后才写输出,查询失败保持调用方原内容。
* 不调用有清理副作用的Check_Session,也不Expire;应用仍须显式Process/Execute_Next。
* 回调内允许查询,need_process在in_lookup时抑制;这不授权回调递归推进模块。
* 输入参数:self——本模块实例。
* status——状态快照。
* 输出参数:status——状态快照的更新结果。
* 返回值:!Owned(self) || status == NULL时返回false;state == IEC104_SLAVE_REQUEST_ERROR时返回false;其余分支返回false、true。
* 说明:内部调用:Owned、IEC104_Slave_Check_Request、IEC104_Net_Now_Ms、Remaining。
*/
bool IEC104_Read_Get_Status(const IEC104_Read_t *self, IEC104_ReadStatus_t *status)
{
IEC104_SlaveRequestState_t state;
unsigned i;
uint64_t now;
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 = self->count != 0U && self->tasks[self->order[0]].phase == READ_VALUE;
status->send_waiting = self->count != 0U && self->tasks[self->order[0]].send_waiting;
status->timer_active = false;
status->timeout_remaining_ms = 0U;
status->need_process = false;
now = IEC104_Net_Now_Ms();
if (self->config.request_timeout_ms != 0U) {
for (i = 0U; i < self->count; ++i) {
uint32_t remaining = Remaining(self, &self->tasks[self->order[i]], 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_lookup && !status->events_pending) {
status->need_process = state != IEC104_SLAVE_REQUEST_READY || !status->active ||
(status->timer_active && status->timeout_remaining_ms == 0U) ||
(!status->execute_pending && !status->send_waiting);
}
return true;
}