1878 lines
106 KiB
C
1878 lines
106 KiB
C
/**
|
||
* 子站串行发送管理:发送流程、子站启停封装和初始化入口集中在本文件。
|
||
* 本模块由Connection内部调用;业务通过TcpServer提交ASDU并读取事件副本,不直接操作Manager。
|
||
* 完成分派按原帧类型直接调用公共或子站Link接口,不经过角色回调。
|
||
* S/TESTFR与子站启停构帧入口复用控制槽预留、取消和提交,状态机仍由Link维护。
|
||
* Init只绑定CONTROLLED链路;启停流程接收ACT并发送CON。
|
||
*/
|
||
#include "IEC104_SendManager.h"
|
||
#include "IEC104_Link_Slave_StartStop.h"
|
||
|
||
#include <stddef.h>
|
||
#include <string.h>
|
||
|
||
/* ==================== 公共管理:调度、进度、确认与回收 ==================== */
|
||
|
||
/**
|
||
* 功能:计算15位序号沿发送方向的循环距离。
|
||
* 输入参数:from——起始序号,范围0..32767。
|
||
* to——目标序号,范围0..32767。
|
||
* 输出参数:无。
|
||
* 返回值:0..32767范围内的模32768距离。
|
||
* 说明:调用方须先保证区间受窗口或容量约束;不能直接用序号大小判断先后。
|
||
*/
|
||
static uint16_t Sequence_Distance(uint16_t from, uint16_t to)
|
||
{
|
||
return (uint16_t)(((uint32_t)to + 32768U - from) & IEC104_SEQUENCE_MASK);
|
||
}
|
||
|
||
/**
|
||
* 功能:将业务记录相对队首的逻辑偏移换算为数组下标。
|
||
* 输入参数:manager——存储边界已验证且record_capacity非零的发送管理器。
|
||
* offset——相对记录队首的槽数偏移,不是字节数,可定位现有记录或下一个空槽。
|
||
* 输出参数:无。
|
||
* 返回值:0..record_capacity-1范围内的物理下标。
|
||
* 说明:用32位加法避免索引相加溢出;本函数不验证该槽是否已有有效记录。
|
||
*/
|
||
static uint16_t Record_Index_From_Offset(const IEC104_SendManager_t *manager, uint16_t offset)
|
||
{
|
||
return (uint16_t)(((uint32_t)manager->record_head_index + offset) % manager->record_capacity);
|
||
}
|
||
|
||
/**
|
||
* 功能:检查发送管理器自身的存储边界、绑定指针和配置。
|
||
* 输入参数:manager——待检查的发送管理器,允许NULL。
|
||
* 输出参数:无。
|
||
* 返回值:控制结构合法返回1,否则返回0。
|
||
* 说明:不要求Link及两个队列仍可运行,也不扫描业务记录。
|
||
* 故障回收仍须读取帧身份、NORMAL来源编号和ACK事实,不能被故障后的会话状态阻断。
|
||
*/
|
||
static int Manager_Storage_Valid(const IEC104_SendManager_t *manager)
|
||
{
|
||
return manager != NULL && manager->is_initialized == 1U && manager->asdu_queue != NULL &&
|
||
manager->send_buffer != NULL && manager->link_state != NULL && manager->records != NULL &&
|
||
manager->record_capacity != 0U && manager->record_capacity <= IEC104_SEQUENCE_MASK &&
|
||
manager->record_head_index < manager->record_capacity &&
|
||
manager->record_count <= manager->record_capacity && manager->connection_generation != 0U &&
|
||
(uint32_t)manager->high_unacked_count + manager->idle_unacked_count <= manager->record_count &&
|
||
manager->send_window_k != 0U && manager->send_window_k <= IEC104_SEQUENCE_MASK &&
|
||
manager->next_record_ns <= IEC104_SEQUENCE_MASK &&
|
||
manager->high_priority_burst_count <= manager->high_priority_burst_limit;
|
||
}
|
||
|
||
/**
|
||
* 功能:检查业务记录的身份、序号快照、完成标志及有效发送时刻。
|
||
* 输入参数:manager——已通过Manager_Storage_Valid检查的发送管理器。
|
||
* record——指向已登记记录的非NULL指针。
|
||
* offset——该记录相对队首的偏移,调用方保证小于record_count。
|
||
* 输出参数:无。
|
||
* 返回值:记录符合当前位置的约束返回1,否则返回0。
|
||
* 说明:队列发送及直接应答共用Prepare_I_Asdu连续登记,记录只从队首释放,因此首条N(S)=next_record_ns-record_count。
|
||
* 记录容量小于序号环,可按offset推导唯一N(S)。
|
||
* 本地完成和对端ACK分别记录;已确认的业务记录必须已经提交本地完成。
|
||
*/
|
||
static int I_Frame_Record_Valid(const IEC104_SendManager_t *manager,
|
||
const IEC104_IFrameSendRecordStorage_t *record, uint16_t offset)
|
||
{
|
||
uint16_t expected = (uint16_t)(((uint32_t)manager->next_record_ns + 32768U -
|
||
manager->record_count + offset) & IEC104_SEQUENCE_MASK);
|
||
return record->frame_serial != 0U &&
|
||
(((record->asdu_priority == IEC104_ASDU_PRIORITY_HIGH ||
|
||
record->asdu_priority == IEC104_ASDU_PRIORITY_IDLE) && record->asdu_entry_serial == 0U) ||
|
||
(record->asdu_priority == IEC104_ASDU_PRIORITY_NORMAL && record->asdu_entry_serial != 0U)) &&
|
||
record->i_frame_snapshot.send_number == expected && record->i_frame_snapshot.receive_number <= IEC104_SEQUENCE_MASK &&
|
||
record->i_frame_snapshot.frame_length >= IEC104_APCI_LEN + IEC104_ASDU_HEADER_LEN &&
|
||
record->i_frame_snapshot.frame_length <= IEC104_MAX_APDU_LEN &&
|
||
record->local_send_completed <= 1U && record->peer_acknowledged <= 1U &&
|
||
(record->peer_acknowledged == 0U || record->local_send_completed != 0U) &&
|
||
(record->local_send_completed == 0U || record->written_at_ms >= record->queued_at_ms);
|
||
}
|
||
|
||
/**
|
||
* 功能:检查当前连接的Link序号、当前I帧、保留ASDU和记录数量是否一致。
|
||
* 输入参数:manager——待检查对象,允许NULL;connection_generation——本次事件的代次。
|
||
* 输出参数:无,通过公开查询读取各模块数值,不修改它们的控制字段。
|
||
* 返回值:运行状态自洽返回1,否则0;不证明TCP仍然可用。
|
||
* 说明:Link独占协议边界;Buffer报告至多一个当前I帧;HIGH/IDLE未确认数量由Manager维护。
|
||
* 本模块只服务CONTROLLED角色,绑定后的角色变化属于本地状态非法。
|
||
* HIGH/IDLE未确认记录数加NORMAL保留及覆盖待确认条目数,等于Link已编号未ACK的I帧数。
|
||
* 未消费的已ACK回执仍占记录,所以record_count可以大于未ACK帧数。
|
||
* 公开入口不允许遗留预留;整个跨模块事务完成后才检查,不能检查提交中间态。
|
||
*/
|
||
static int Manager_Session_Valid(const IEC104_SendManager_t *manager, uint64_t connection_generation)
|
||
{
|
||
IEC104_IFrameSendProgress_t link_progress;
|
||
IEC104_LinkStatus_t link_status;
|
||
IEC104_AsduQueueStatus_t asdu_status;
|
||
IEC104_SendBufferStatus_t buffer_status;
|
||
uint16_t pending, outstanding;
|
||
|
||
if (!Manager_Storage_Valid(manager) || connection_generation != manager->connection_generation ||
|
||
IEC104_Link_Get_Status(manager->link_state, &link_status) != 1 ||
|
||
link_status.role != IEC104_ROLE_CONTROLLED ||
|
||
IEC104_Link_Get_Send_Progress(manager->link_state, &link_progress) != 1 ||
|
||
IEC104_AsduQueue_Get_Status(manager->asdu_queue, &asdu_status) != IEC104_ASDU_QUEUE_OK ||
|
||
IEC104_SendBuffer_Get_Status(manager->send_buffer, &buffer_status) != IEC104_SEND_BUFFER_OK ||
|
||
asdu_status.connection_generation != connection_generation ||
|
||
buffer_status.connection_generation != connection_generation) {
|
||
return 0;
|
||
}
|
||
/* pending只统计唯一当前I帧;outstanding还包含已经写完但尚未ACK的I帧。 */
|
||
pending = Sequence_Distance(link_progress.next_completion_ns, link_progress.next_frame_ns);
|
||
outstanding = Sequence_Distance(link_progress.peer_ack_nr, link_progress.next_frame_ns);
|
||
return manager->next_record_ns == link_progress.next_frame_ns &&
|
||
pending <= 1U && buffer_status.has_i_frame == pending &&
|
||
(pending == 0U || buffer_status.i_frame_ns == link_progress.next_completion_ns) &&
|
||
buffer_status.has_reservation == 0U && outstanding <= manager->send_window_k &&
|
||
manager->record_count >= outstanding &&
|
||
asdu_status.retained_unacked_count[IEC104_ASDU_PRIORITY_HIGH] == 0U &&
|
||
(uint64_t)manager->high_unacked_count + manager->idle_unacked_count +
|
||
asdu_status.retained_unacked_count[IEC104_ASDU_PRIORITY_NORMAL] +
|
||
asdu_status.overwritten_unacked_count == outstanding;
|
||
}
|
||
|
||
/**
|
||
* 功能:已校验会话;START受理即允许接手应答,STOP受理即拒绝。
|
||
* 输入参数:manager——发送管理器。
|
||
* 输出参数:无。
|
||
* 返回值:1表示已启动且启停过程空闲,允许接手应答,否则0。
|
||
* 说明:这里只判生命周期准入;实际选帧由兼容模式的FIFO/配额或严格模式的业务等级决定。
|
||
*/
|
||
static int Response_Submit_Allowed(const IEC104_SendManager_t *manager)
|
||
{
|
||
const IEC104_LinkState_t *state = manager->link_state;
|
||
return state->dt_state == IEC104_DT_STARTED && state->dt_procedure == IEC104_DT_PROC_IDLE;
|
||
}
|
||
|
||
/**
|
||
* 功能:只在已验证的会话上调用;本层检查链路阶段、发送缓冲、两级业务队列和编号资源。
|
||
* 输入参数:manager——发送管理器。
|
||
* reserve——须保留的窗口及记录槽数量。
|
||
* priority——优先级。
|
||
* 输出参数:无。
|
||
* 返回值:合法reserve暂时不能保留足额余量才返回WAIT。
|
||
* 说明:当前帧和控制帧先于新的IDLE;兼容模式另让出全部排队业务,严格模式仅让出同级及更高级可选条目。
|
||
* 上层另查未读通知、待交付请求及协议期限,不能用此处的队列空闲代替完整业务就绪判定。
|
||
* 启动暂停必须单独检查:IDLE不经过NORMAL选帧,即使队列为空也不能绕过启动顺序。
|
||
* reserve本身占满任一种资源属于配置错误;合法reserve暂时不能保留足额余量才返回WAIT。
|
||
*/
|
||
static IEC104_SendManagerResult_t Idle_Admission(const IEC104_SendManager_t *manager, uint16_t reserve,
|
||
IEC104_BusinessPriority_t priority)
|
||
{
|
||
IEC104_SendBufferHeadInfo_t head;
|
||
IEC104_AsduHeadInfo_t queued;
|
||
IEC104_AsduQueueResult_t result;
|
||
unsigned lane;
|
||
IEC104_IFrameSendProgress_t progress;
|
||
IEC104_SendBufferResult_t buffer;
|
||
uint16_t outstanding;
|
||
int link;
|
||
if (reserve >= manager->send_window_k || reserve >= manager->record_capacity) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
if (!Response_Submit_Allowed(manager) || manager->asdu_queue->startup_pending != 0U) {
|
||
return IEC104_SEND_MANAGER_WAIT;
|
||
}
|
||
buffer = IEC104_SendBuffer_Peek_Send_Head(manager->send_buffer, &head);
|
||
if (buffer == IEC104_SEND_BUFFER_OK) { return IEC104_SEND_MANAGER_WAIT; }
|
||
if (buffer != IEC104_SEND_BUFFER_EMPTY) { return IEC104_SEND_MANAGER_ERROR; }
|
||
if (priority < IEC104_BUSINESS_PRIORITY_NONE || priority >= IEC104_BUSINESS_PRIORITY_COUNT) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
if (manager->asdu_queue->strict_business_priority != 0U) {
|
||
if (priority == IEC104_BUSINESS_PRIORITY_NONE) { priority = IEC104_BUSINESS_PRIORITY_MEASUREMENT; }
|
||
/* pending是尚未组帧的立即就绪候选,direct是应用本轮授予的取值/直交阶段。
|
||
* 两者都要检查:只看已编码队列会漏掉目录扫描等本轮尚未完成准备的高级业务。 */
|
||
if ((manager->pending_business_priority != IEC104_BUSINESS_PRIORITY_NONE &&
|
||
priority > manager->pending_business_priority) ||
|
||
(manager->business_cycle_active != 0U &&
|
||
(manager->direct_business_priority != priority || manager->business_frame_used != 0U))) {
|
||
return IEC104_SEND_MANAGER_WAIT;
|
||
}
|
||
for (lane = 0U; lane < IEC104_ASDU_PRIORITY_COUNT; ++lane) {
|
||
result = IEC104_AsduQueue_Peek_Unsubmitted(manager->asdu_queue, (IEC104_AsduPriority_t)lane, &queued);
|
||
if (result == IEC104_ASDU_QUEUE_ERROR) { return IEC104_SEND_MANAGER_ERROR; }
|
||
/* IDLE此刻才提交;同级已入队条目更早接手,必须先发,保证跨生命周期的同级FIFO。 */
|
||
if (result == IEC104_ASDU_QUEUE_OK && queued.business_priority <= priority) {
|
||
return IEC104_SEND_MANAGER_WAIT;
|
||
}
|
||
}
|
||
} else {
|
||
IEC104_AsduQueueStatus_t queued_status;
|
||
/* 保留兼容模式“全部未交接原文先于IDLE”的准入规则,并计入独立SOE及补报占位。 */
|
||
if (IEC104_AsduQueue_Get_Status(manager->asdu_queue, &queued_status) != IEC104_ASDU_QUEUE_OK) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
if (queued_status.entry_count[IEC104_ASDU_PRIORITY_HIGH] != 0U ||
|
||
queued_status.entry_count[IEC104_ASDU_PRIORITY_NORMAL] >
|
||
queued_status.retained_unacked_count[IEC104_ASDU_PRIORITY_NORMAL]) {
|
||
return IEC104_SEND_MANAGER_WAIT;
|
||
}
|
||
}
|
||
link = IEC104_Link_Can_Prepare_I_Frame(manager->link_state, manager->send_window_k);
|
||
if (link < 0 || IEC104_Link_Get_Send_Progress(manager->link_state, &progress) != 1) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
/* 已ACK未消费的记录仍占槽,所以窗口余量与记录余量分别扣除本帧及reserve。 */
|
||
outstanding = Sequence_Distance(progress.peer_ack_nr, progress.next_frame_ns);
|
||
if (link == 0 || (uint32_t)outstanding + 1U + reserve > manager->send_window_k ||
|
||
(uint32_t)manager->record_count + 1U + reserve > manager->record_capacity) {
|
||
return IEC104_SEND_MANAGER_WAIT;
|
||
}
|
||
return IEC104_SEND_MANAGER_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能:纯查询,不编号、不占槽;
|
||
* 输入参数:manager——发送管理器。
|
||
* connection_generation——连接代次。
|
||
* reserve——须保留的窗口及记录槽数量。
|
||
* priority——优先级。
|
||
* 输出参数:无。
|
||
* 返回值:按处理分支返回IEC104_SEND_MANAGER_ERROR、Idle_Admission(manager, reserve, priority)。
|
||
* 说明:取值期间状态可能变化,Submit必须再执行同一准入判定。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Can_Submit_Idle_Priority(
|
||
const IEC104_SendManager_t *manager, uint64_t connection_generation, uint16_t reserve,
|
||
IEC104_BusinessPriority_t priority)
|
||
{
|
||
if (!Manager_Session_Valid(manager, connection_generation)) { return IEC104_SEND_MANAGER_ERROR; }
|
||
return Idle_Admission(manager, reserve, priority);
|
||
}
|
||
|
||
/**
|
||
* 功能:使用默认业务等级查询IDLE业务的发送准入条件。
|
||
* 输入参数:manager/connection_generation——发送管理器及代次;reserve——提交后须保留的资源数量。
|
||
* 输出参数:无。
|
||
* 返回值:OK当前可提交;WAIT暂受链路、队列或资源限制;ERROR为参数或会话非法。
|
||
* 说明:只查询,不分配N(S)或预留槽位;实际提交仍须重新检查。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Can_Submit_Idle(
|
||
const IEC104_SendManager_t *manager, uint64_t connection_generation, uint16_t reserve)
|
||
{
|
||
return IEC104_SendManager_Can_Submit_Idle_Priority(manager, connection_generation, reserve, IEC104_BUSINESS_PRIORITY_NONE);
|
||
}
|
||
|
||
/**
|
||
* 功能:返回发送记录存储概况,使连接层无需读取Manager内部字段。
|
||
* 输入参数:manager——尚未Abort的管理器;status——不重叠的输出存储。
|
||
* 输出参数:status——状态快照的更新结果。
|
||
* 返回值:OK写数值副本,ERROR参数/存储非法且不改输出。
|
||
* 说明:不依赖故障后的Link运行状态,可在连接冻结期间用于记录回收和状态展示。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Get_Status(
|
||
const IEC104_SendManager_t *manager, IEC104_SendManagerStatus_t *status)
|
||
{
|
||
IEC104_SendManagerStatus_t prepared;
|
||
if (status == NULL || !Manager_Storage_Valid(manager)) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
prepared.connection_generation = manager->connection_generation;
|
||
prepared.record_capacity = manager->record_capacity;
|
||
prepared.record_count = manager->record_count;
|
||
prepared.high_unacked_count = manager->high_unacked_count;
|
||
*status = prepared;
|
||
return IEC104_SEND_MANAGER_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能:校验当前发送会话后,将业务ASDU交给绑定队列复制保存。
|
||
* 输入参数:manager/connection_generation——有效会话及代次;priority/asdu/asdu_length——待入队业务。
|
||
* 输出参数:manager——发送管理器的更新结果。
|
||
* 返回值:OK成功,WAIT容量/条目编号窗口不足,ERROR参数、会话或HIGH准入阶段非法。
|
||
* 说明:调用关系:Connection推迟应答及Submit_Response回退时使用,向上隐藏队列指针及专用返回值。
|
||
* HIGH与Submit_Response共用准入检查,先于队列容量判断;NORMAL不受此检查限制。
|
||
* 内部条目编号由队列管理,协议N(S)在实际准备I帧时分配;不推进发送进度。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Enqueue(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation,
|
||
IEC104_AsduPriority_t priority, const uint8_t *asdu, uint16_t asdu_length)
|
||
{
|
||
IEC104_AsduQueueResult_t result;
|
||
if (!Manager_Session_Valid(manager, connection_generation)) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
if (priority == IEC104_ASDU_PRIORITY_HIGH && !Response_Submit_Allowed(manager)) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
/* 队列同步复制原文;这里不创建APDU,后续Prepare_Next_Send才选择业务并分配协议序号。 */
|
||
result = IEC104_AsduQueue_Enqueue(manager->asdu_queue, connection_generation, priority, asdu, asdu_length);
|
||
if (result == IEC104_ASDU_QUEUE_OK) {
|
||
return IEC104_SEND_MANAGER_OK;
|
||
}
|
||
/* FULL是可等待的背压;其他非法输入或状态统一返回ERROR,不作为容量不足反复重试。 */
|
||
return result == IEC104_ASDU_QUEUE_FULL ? IEC104_SEND_MANAGER_WAIT : IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
|
||
/**
|
||
* 功能:应答始终属于当前HIGH会话;
|
||
* 输入参数:manager——发送管理器。
|
||
* connection_generation——连接代次。
|
||
* asdu——ASDU报文。
|
||
* asdu_length——ASDU字节长度。
|
||
* ticket——应答交接票据。
|
||
* priority——优先级。
|
||
* 输出参数:manager——发送管理器的更新结果。
|
||
* ticket——应答交接票据的更新结果。
|
||
* 返回值:按处理分支返回IEC104_SEND_MANAGER_ERROR、IEC104_SEND_MANAGER_OK、result == IEC104_ASDU_QUEUE_FULL ? IEC104_SEND_MANAGER_WAIT : IEC104_SEND_MANAGER_ERROR。
|
||
* 说明:成功才输出交接凭证,不在此处分配N(S)。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Enqueue_Response_Priority(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation,
|
||
const uint8_t *asdu, uint16_t asdu_length, uint64_t *ticket,
|
||
IEC104_BusinessPriority_t priority)
|
||
{
|
||
IEC104_AsduQueueResult_t result;
|
||
if (!Manager_Session_Valid(manager, connection_generation) || !Response_Submit_Allowed(manager)) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
if (priority == IEC104_BUSINESS_PRIORITY_NONE) { priority = IEC104_BUSINESS_PRIORITY_INTERROGATION; }
|
||
result = IEC104_AsduQueue_Enqueue_Response_Priority(manager->asdu_queue, connection_generation,
|
||
asdu, asdu_length, ticket, priority);
|
||
if (result == IEC104_ASDU_QUEUE_OK) { return IEC104_SEND_MANAGER_OK; }
|
||
return result == IEC104_ASDU_QUEUE_FULL ? IEC104_SEND_MANAGER_WAIT : IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
|
||
/**
|
||
* 功能:使用默认业务等级将应答复制到HIGH队列。
|
||
* 输入参数:manager/connection_generation——发送管理器及代次;asdu/asdu_length——原文及长度。
|
||
* 输出参数:ticket——成功时的交接票据,可为NULL。
|
||
* 返回值:OK已接手;WAIT暂无入队空间;ERROR为参数、链路阶段或队列状态非法。
|
||
* 说明:严格模式默认总召等级;本入口只排队,不分配N(S)或准备I帧。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Enqueue_Response(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation,
|
||
const uint8_t *asdu, uint16_t asdu_length, uint64_t *ticket)
|
||
{
|
||
return IEC104_SendManager_Enqueue_Response_Priority(manager, connection_generation, asdu, asdu_length, ticket, IEC104_BUSINESS_PRIORITY_NONE);
|
||
}
|
||
|
||
/**
|
||
* 功能:为发送队首定位尚未提交本地完成的I帧业务记录。
|
||
* 输入参数:manager——会话及存储边界已验证的发送管理器。
|
||
* head_info——当前发送队首的有效I帧信息,代次已由调用入口验证。
|
||
* 输出参数:无,不修改记录。
|
||
* 返回值:成功返回内部记录指针;找不到或身份、快照不匹配时返回NULL。
|
||
* 说明:先按N(S)计算偏移,再核对frame_id的frame_serial、原始N(R)、长度和入队时刻。
|
||
* 不能只用可能回绕的N(S)识别完成事件;返回指针只供当前串行操作使用。
|
||
*/
|
||
static IEC104_IFrameSendRecordStorage_t *Find_Pending_Send_Record(IEC104_SendManager_t *manager,
|
||
const IEC104_SendBufferHeadInfo_t *head_info)
|
||
{
|
||
uint16_t first = (uint16_t)(((uint32_t)manager->next_record_ns + 32768U -
|
||
manager->record_count) & IEC104_SEQUENCE_MASK);
|
||
uint16_t offset = Sequence_Distance(first, head_info->i_frame_snapshot.send_number);
|
||
IEC104_IFrameSendRecordStorage_t *record;
|
||
|
||
if (offset >= manager->record_count) {
|
||
return NULL;
|
||
}
|
||
record = &manager->records[Record_Index_From_Offset(manager, offset)];
|
||
if (!I_Frame_Record_Valid(manager, record, offset) || record->local_send_completed != 0U ||
|
||
record->frame_serial != head_info->frame_id.frame_serial ||
|
||
record->i_frame_snapshot.receive_number != head_info->i_frame_snapshot.receive_number ||
|
||
record->i_frame_snapshot.frame_length != head_info->apdu_length || record->queued_at_ms != head_info->queued_at_ms) {
|
||
return NULL;
|
||
}
|
||
return record;
|
||
}
|
||
|
||
/**
|
||
* 功能:按保存的帧类型将完整发送或发送失败结果交给对应链路完成接口。
|
||
* 输入参数:manager——已校验的子站管理器,绑定本连接CONTROLLED链路。
|
||
* head_info——有效队首信息,保存原始帧类型及I帧快照。
|
||
* sent_len——实际整帧发送长度;发送失败时传-1。
|
||
* 输出参数:manager->link_state——由匹配的链路完成接口按其约定提交或清理状态。
|
||
* 返回值:返回对应接口的OK、IGNORED或FATAL;本端不支持的帧类型返回FATAL。
|
||
* 说明:不按当前dt_procedure猜测报文身份,不执行I/O或发送队列出队。
|
||
* STARTDT_CON/STOPDT_CON直接提交子站完成接口;帧类型在缓冲提交时已完成校验。
|
||
* TESTFR_CON为无状态应答,没有Link完成接口;长度为6返回OK,否则返回FATAL。
|
||
*/
|
||
static IEC104_LinkResult_t Dispatch_Link_Send_Completion(const IEC104_SendManager_t *manager,
|
||
const IEC104_SendBufferHeadInfo_t *head_info, int sent_len)
|
||
{
|
||
IEC104_LinkState_t *link_state = manager->link_state;
|
||
|
||
switch (head_info->frame_type) {
|
||
case IEC104_SEND_BUFFER_FRAME_I:
|
||
return IEC104_Link_Complete_I_Send(link_state, &head_info->i_frame_snapshot, sent_len);
|
||
case IEC104_SEND_BUFFER_FRAME_S_ACK:
|
||
return IEC104_Link_Complete_S_Ack_Send(link_state, sent_len);
|
||
case IEC104_SEND_BUFFER_FRAME_STARTDT_CON:
|
||
return IEC104_Link_Complete_Startdt_Con_Send(link_state, sent_len);
|
||
case IEC104_SEND_BUFFER_FRAME_STOPDT_CON:
|
||
return IEC104_Link_Complete_Stopdt_Con_Send(link_state, sent_len);
|
||
case IEC104_SEND_BUFFER_FRAME_TESTFR_ACT:
|
||
return IEC104_Link_Complete_Testfr_Act_Send(link_state, sent_len);
|
||
case IEC104_SEND_BUFFER_FRAME_TESTFR_CON:
|
||
return sent_len == IEC104_APCI_LEN ? IEC104_LINK_RESULT_OK : IEC104_LINK_RESULT_FATAL;
|
||
default:
|
||
return IEC104_LINK_RESULT_FATAL;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:校验同连接各模块的状态,并为一帧S/U取得控制槽。
|
||
* 输入参数:manager——待校验的管理器;connection_generation——本次调用所属连接代次。
|
||
* 输出参数:reservation——非NULL,仅OK时写入帧身份、可写APDU地址及容量。
|
||
* 返回值:OK表示预留成功;缓冲报告FULL/BUSY时返回WAIT;会话或缓冲非法返回ERROR。
|
||
* 调用关系:公共S/TESTFR及子站应答入口在调用Link构帧前使用,成功后须提交或取消预留。
|
||
* 说明:本函数不调用Link构帧或接收处理,不改变链路过程;WAIT表示尚未取得应答槽。
|
||
* TESTFR接收入口在本函数之前登记主站ACT事实,WAIT不撤回该事实。
|
||
* 预留只占用控制槽,不进入发送FIFO,也不占用Manager的I帧业务记录槽。
|
||
* 会话入口要求无外部遗留预留,因此外部未结束的预留会先被判为ERROR。
|
||
*/
|
||
static IEC104_SendManagerResult_t Reserve_Control_Frame(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation,
|
||
IEC104_SendBufferReservation_t *reservation)
|
||
{
|
||
IEC104_SendBufferResult_t result;
|
||
|
||
if (!Manager_Session_Valid(manager, connection_generation)) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
result = IEC104_SendBuffer_Reserve_S_U_Frame(manager->send_buffer, reservation);
|
||
if (result == IEC104_SEND_BUFFER_FULL || result == IEC104_SEND_BUFFER_BUSY) {
|
||
return IEC104_SEND_MANAGER_WAIT;
|
||
}
|
||
return result == IEC104_SEND_BUFFER_OK ? IEC104_SEND_MANAGER_OK : IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
|
||
/**
|
||
* 功能:归还本次未生成S/U报文的预留控制槽,并传回调用方选定的处理结果。
|
||
* 输入参数:manager——已校验的管理器;reservation——本次有效预留;result——取消成功后的返回值。
|
||
* 输出参数:无独立输出对象;成功时由SendBuffer释放预留,已使用的frame_serial不复用。
|
||
* 返回值:取消成功原样返回result,取消失败返回FATAL,要求结束连接。
|
||
* 前置条件:指针有效,Link尚未为本次预留生成报文;不可用于撤回已经构帧成功的发送义务。
|
||
* 说明:只归还尚未提交的控制槽,不回滚Link状态。
|
||
*/
|
||
static IEC104_SendManagerResult_t Cancel_Control_Reservation(
|
||
IEC104_SendManager_t *manager, const IEC104_SendBufferReservation_t *reservation,
|
||
IEC104_SendManagerResult_t result)
|
||
{
|
||
return IEC104_SendBuffer_Cancel_Reservation(manager->send_buffer, reservation->frame_id) ==
|
||
IEC104_SEND_BUFFER_OK ? result : IEC104_SEND_MANAGER_FATAL;
|
||
}
|
||
|
||
/**
|
||
* 功能:将预留控制槽内已生成的固定6字节S/U报文追加到发送FIFO。
|
||
* 输入参数:manager——已校验的管理器;reservation——本次有效预留,APDU已由Link写入;
|
||
* frame_type——与APDU一致的S/U完成分派类型;now_ms——本次入队单调时刻,允许0。
|
||
* 输出参数:无独立输出对象;SendBuffer保存帧类型、长度及入队时间,不登记I帧业务记录。
|
||
* 返回值:QUEUED表示提交成功;FATAL表示提交失败,须结束连接,不能按容量不足重试。
|
||
* 前置条件:指针有效且Link已生成报文;S/U不传I帧快照,容量已由Reserve_Control_Frame保障。
|
||
* 说明:失败时不取消预留、不回滚Link;成功后实际I/O及Handle_Send_Progress另由接入方驱动。
|
||
*/
|
||
static IEC104_SendManagerResult_t Commit_Control_Frame(
|
||
IEC104_SendManager_t *manager, const IEC104_SendBufferReservation_t *reservation,
|
||
IEC104_SendBufferFrameType_t frame_type, uint64_t now_ms)
|
||
{
|
||
return IEC104_SendBuffer_Commit_Frame(manager->send_buffer, reservation->frame_id,
|
||
frame_type, IEC104_APCI_LEN, NULL, now_ms) == IEC104_SEND_BUFFER_OK ?
|
||
IEC104_SEND_MANAGER_QUEUED : IEC104_SEND_MANAGER_FATAL;
|
||
}
|
||
|
||
/**
|
||
* 功能:将公共S/TESTFR准备接口返回的长度转换为提交或取消操作。
|
||
* 输入参数:manager/reservation——已校验的管理器及本次有效预留;frame_type——预期帧类型;
|
||
* length——Link.Prepare的原始返回值;now_ms——生成报文时使用的入队时刻。
|
||
* 输出参数:无独立输出对象;按length提交FIFO或归还预留,不执行网络发送。
|
||
* 返回值:length为6时提交并返回QUEUED;为0时取消并返回WAIT;为负时取消并返回ERROR;
|
||
* 提交/取消失败或其他正长度返回FATAL。
|
||
* 说明:0/负值表示Link未生成报文,才允许取消;异常正长度可能已有发送义务,保留现场并断连。
|
||
*/
|
||
static IEC104_SendManagerResult_t Finish_Control_Prepare(
|
||
IEC104_SendManager_t *manager, const IEC104_SendBufferReservation_t *reservation,
|
||
IEC104_SendBufferFrameType_t frame_type, int length, uint64_t now_ms)
|
||
{
|
||
if (length <= 0) {
|
||
return Cancel_Control_Reservation(manager, reservation,
|
||
length == 0 ? IEC104_SEND_MANAGER_WAIT : IEC104_SEND_MANAGER_ERROR);
|
||
}
|
||
if (length != IEC104_APCI_LEN) {
|
||
return IEC104_SEND_MANAGER_FATAL;
|
||
}
|
||
return Commit_Control_Frame(manager, reservation, frame_type, now_ms);
|
||
}
|
||
|
||
/**
|
||
* 功能:按接收门限、立即确认或子站停止排空规则生成S确认并入队。
|
||
* 输入参数:manager——当前连接管理器;connection_generation——连接代次;w——1..32767的门限;
|
||
* immediate——非0表示立即确认;now_ms——入队单调时刻,允许0。
|
||
* 输出参数:无独立输出对象;生成成功时Link保存本帧N(R)及S在途状态,SendBuffer持有报文。
|
||
* 返回值:QUEUED表示S入队;WAIT表示控制容量不足,或Link判断当前无需、不能生成;
|
||
* ERROR表示参数、会话或准备结果非法;提交/取消异常返回FATAL。
|
||
* 调用时机:接收I帧后、启动CON完成后或确认条件变化时,由连接调度代码驱动。
|
||
* 说明:immediate只跳过数量门限,不跳过启停门控、已有S在途及无待确认数据检查。
|
||
* 构帧只冻结N(R),完整发送后由Handle_Send_Progress提交确认;WAIT不等于已确认。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Queue_S_Ack(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation,
|
||
uint16_t w, int immediate, uint64_t now_ms)
|
||
{
|
||
IEC104_SendBufferReservation_t reservation;
|
||
IEC104_SendManagerResult_t result;
|
||
int length;
|
||
|
||
if (w == 0U || w > IEC104_SEQUENCE_MASK) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
result = Reserve_Control_Frame(manager, connection_generation, &reservation);
|
||
if (result != IEC104_SEND_MANAGER_OK) {
|
||
return result;
|
||
}
|
||
length = IEC104_Link_Prepare_S_Ack(manager->link_state, w, immediate,
|
||
reservation.apdu, reservation.apdu_capacity);
|
||
return Finish_Control_Prepare(manager, &reservation, IEC104_SEND_BUFFER_FRAME_S_ACK, length, now_ms);
|
||
}
|
||
|
||
/**
|
||
* 功能:待确认数据的t2到期后,按公共S确认规则构帧并入队。
|
||
* 输入参数:manager——当前连接管理器;connection_generation——连接代次;
|
||
* elapsed_ms——从原待确认数据起点计算的经过毫秒数;t2_ms——非0的t2配置;
|
||
* now_ms——本次入队单调时刻,与elapsed_ms的相对时间含义不同。
|
||
* 输出参数:无独立输出对象;成功时Link记录S在途状态,报文进入SendBuffer。
|
||
* 返回值:QUEUED表示S入队;WAIT表示控制容量不足、未到期或Link当前不生成S;
|
||
* ERROR表示参数、会话或准备结果非法;提交/取消异常返回FATAL。
|
||
* 调用时机:接入方的定时唤醒或连接调度;elapsed_ms等于t2_ms即满足到期条件。
|
||
* 说明:到期仍受启停及已有S在途约束;函数不读取时钟、不重置起点,重试须沿用原计时。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Queue_T2_Ack(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation,
|
||
uint32_t elapsed_ms, uint32_t t2_ms, uint64_t now_ms)
|
||
{
|
||
IEC104_SendBufferReservation_t reservation;
|
||
IEC104_SendManagerResult_t result;
|
||
int length;
|
||
|
||
if (t2_ms == 0U) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
result = Reserve_Control_Frame(manager, connection_generation, &reservation);
|
||
if (result != IEC104_SEND_MANAGER_OK) {
|
||
return result;
|
||
}
|
||
length = IEC104_Link_Prepare_T2_Ack(manager->link_state, elapsed_ms, t2_ms,
|
||
reservation.apdu, reservation.apdu_capacity);
|
||
return Finish_Control_Prepare(manager, &reservation, IEC104_SEND_BUFFER_FRAME_S_ACK, length, now_ms);
|
||
}
|
||
|
||
/**
|
||
* 功能:子站主动生成并排队一帧TESTFR_ACT。
|
||
* 输入参数:manager——当前连接管理器;connection_generation——连接代次;now_ms——入队单调时刻。
|
||
* 输出参数:无独立输出对象;生成后Link进入ACT_SEND_PENDING,SendBuffer持有ACT报文。
|
||
* 返回值:QUEUED表示ACT入队;WAIT表示容量不足、已有探测或已收到主站ACT;ERROR表示会话或准备非法;
|
||
* 提交/取消异常返回FATAL。
|
||
* 调用时机:连接调度代码决定主动探测时;按空闲时间触发可使用Queue_T3_Testfr。
|
||
* 说明:本入口不检查空闲时长。ACT完整发送后才由Handle_Send_Progress提交CON_PENDING,
|
||
* 接入方以实际written_at_ms作为等待CON的t1起点;不能在入队时提前提交发送完成。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Queue_Testfr_Act(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation, uint64_t now_ms)
|
||
{
|
||
IEC104_SendBufferReservation_t reservation;
|
||
IEC104_SendManagerResult_t result = Reserve_Control_Frame(manager, connection_generation, &reservation);
|
||
int length;
|
||
|
||
if (result != IEC104_SEND_MANAGER_OK) {
|
||
return result;
|
||
}
|
||
length = IEC104_Link_Prepare_Testfr_Act(manager->link_state, reservation.apdu, reservation.apdu_capacity);
|
||
return Finish_Control_Prepare(manager, &reservation, IEC104_SEND_BUFFER_FRAME_TESTFR_ACT, length, now_ms);
|
||
}
|
||
|
||
/**
|
||
* 功能:链路空闲达到t3后,复用Link的主动探测流程生成TESTFR_ACT并入队。
|
||
* 输入参数:manager——当前连接管理器;connection_generation——连接代次;
|
||
* idle_elapsed_ms——接入方计算的空闲毫秒数;t3_ms——非0的t3配置;now_ms——入队单调时刻。
|
||
* 输出参数:无独立输出对象;生成成功后记录ACT待发送状态,并发布到同一FIFO。
|
||
* 返回值:QUEUED表示ACT入队;WAIT表示容量不足、未到期、已有探测或已收到主站ACT;
|
||
* ERROR表示参数、会话或准备结果非法;提交/取消异常返回FATAL。
|
||
* 调用时机:接入方定时唤醒后,以当前有效活动起点计算时间差;等于t3_ms即满足到期条件。
|
||
* 说明:不创建定时器、不更新活动起点;已有探测的t1不能因活动、重复调用或WAIT而续期。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Queue_T3_Testfr(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation,
|
||
uint32_t idle_elapsed_ms, uint32_t t3_ms, uint64_t now_ms)
|
||
{
|
||
IEC104_SendBufferReservation_t reservation;
|
||
IEC104_SendManagerResult_t result;
|
||
int length;
|
||
|
||
if (t3_ms == 0U) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
result = Reserve_Control_Frame(manager, connection_generation, &reservation);
|
||
if (result != IEC104_SEND_MANAGER_OK) {
|
||
return result;
|
||
}
|
||
length = IEC104_Link_Prepare_T3_Testfr(manager->link_state, idle_elapsed_ms, t3_ms,
|
||
reservation.apdu, reservation.apdu_capacity);
|
||
return Finish_Control_Prepare(manager, &reservation, IEC104_SEND_BUFFER_FRAME_TESTFR_ACT, length, now_ms);
|
||
}
|
||
|
||
/**
|
||
* 功能:子站接收TESTFR_ACT,为其生成并排队一帧TESTFR_CON。
|
||
* 输入参数:manager——当前连接管理器;connection_generation——接收所属连接代次;
|
||
* apci——已通过Parse_APCI且功能码为TESTFR_ACT的U帧;now_ms——应答入队单调时刻。
|
||
* 输出参数:合法接收立即禁止本连接的新主动ACT;QUEUED时SendBuffer另持有CON,已有探测进度不变。
|
||
* 返回值:QUEUED表示应答入队;WAIT表示已登记接收事实,但尚未取得CON应答槽;
|
||
* ERROR表示前置输入或会话非法,未登记接收事实;登记后的预留、编码或提交异常返回FATAL。
|
||
* 调用链:会话校验 -> Link.Handle_Testfr_Act -> Reserve_Control_Frame -> Build_Uframe -> Commit。
|
||
* 说明:先记录主站ACT,避免应答背压期间新生主动ACT;幂等登记不等于可以丢弃应答。
|
||
* WAIT须按序保留请求后重试,无法保留则断连;收到多个ACT时分别调用并逐个应答。
|
||
* TESTFR_CON没有Link完成接口,但实际发送仍交给Handle_Send_Progress/Failure统一处理。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Handle_Testfr_Act(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation,
|
||
const IEC104_ApciInfo_t *apci, uint64_t now_ms)
|
||
{
|
||
IEC104_SendBufferReservation_t reservation;
|
||
IEC104_SendManagerResult_t result;
|
||
|
||
if (apci == NULL || apci->frame_type != IEC104_FRAME_TYPE_U || apci->u_function != IEC104_U_TESTFR_ACT ||
|
||
!Manager_Session_Valid(manager, connection_generation)) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
if (IEC104_Link_Handle_Testfr_Act(manager->link_state, apci) != IEC104_LINK_RESULT_OK) {
|
||
return IEC104_SEND_MANAGER_FATAL;
|
||
}
|
||
result = Reserve_Control_Frame(manager, connection_generation, &reservation);
|
||
if (result != IEC104_SEND_MANAGER_OK) {
|
||
return result == IEC104_SEND_MANAGER_WAIT ? result : IEC104_SEND_MANAGER_FATAL;
|
||
}
|
||
if (reservation.apdu_capacity < IEC104_APCI_LEN ||
|
||
IEC104_Build_Uframe(reservation.apdu, IEC104_U_TESTFR_CON) != IEC104_APCI_LEN) {
|
||
return Cancel_Control_Reservation(manager, &reservation, IEC104_SEND_MANAGER_FATAL);
|
||
}
|
||
return Commit_Control_Frame(manager, &reservation, IEC104_SEND_BUFFER_FRAME_TESTFR_CON, now_ms);
|
||
}
|
||
|
||
/**
|
||
* 功能:TESTFR的接收确认与发送完成使用同一个Manager入口边界。
|
||
* 输入参数:manager——发送管理器。
|
||
* connection_generation——连接代次。
|
||
* apci——APCI控制头。
|
||
* 输出参数:manager——发送管理器的更新结果。
|
||
* 返回值:按处理分支返回IEC104_SEND_MANAGER_ERROR、IEC104_SEND_MANAGER_OK、result == IEC104_LINK_RESULT_IGNORED ? IEC104_SEND_MANAGER_IGNORED : IEC104_SEND_MANAGER_FATAL。
|
||
* 说明:不预留控制槽,槽满不影响接受确认;只有CON_PENDING才结束本端探测。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Handle_Testfr_Con(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation, const IEC104_ApciInfo_t *apci)
|
||
{
|
||
IEC104_LinkResult_t result;
|
||
if (apci == NULL || apci->frame_type != IEC104_FRAME_TYPE_U || apci->u_function != IEC104_U_TESTFR_CON ||
|
||
!Manager_Session_Valid(manager, connection_generation)) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
result = IEC104_Link_Handle_Testfr_Con(manager->link_state, apci);
|
||
if (result == IEC104_LINK_RESULT_OK) {
|
||
return IEC104_SEND_MANAGER_OK;
|
||
}
|
||
return result == IEC104_LINK_RESULT_IGNORED ? IEC104_SEND_MANAGER_IGNORED : IEC104_SEND_MANAGER_FATAL;
|
||
}
|
||
|
||
/**
|
||
* 功能:HIGH快速路径也遵守事件公平配额,不能通过反复调用应答接口绕过已配置的调度规则。
|
||
* 输入参数:manager——发送管理器。
|
||
* normal_waiting——int值。
|
||
* 输出参数:无。
|
||
* 返回值:1表示无NORMAL候选、未限制HIGH连发或HIGH连发尚未达到限额,否则0。
|
||
* 说明:直接处理传入的manager、normal_waiting,不经过其他函数调用。
|
||
*/
|
||
static int High_Has_Priority(const IEC104_SendManager_t *manager, int normal_waiting)
|
||
{
|
||
return !normal_waiting || manager->high_priority_burst_limit == 0U ||
|
||
manager->high_priority_burst_count < manager->high_priority_burst_limit;
|
||
}
|
||
|
||
/**
|
||
* 功能:仅用于Connection/TcpServer内部关联,安装本身不观察或重放历史发送记录。
|
||
* 输入参数:manager——发送管理器。
|
||
* connection_generation——连接代次。
|
||
* observer——ACK观察回调。
|
||
* 输出参数:manager——发送管理器的更新结果。
|
||
* 返回值:按处理分支返回IEC104_SEND_MANAGER_ERROR、IEC104_SEND_MANAGER_OK。
|
||
* 说明:内部调用:Manager_Session_Valid、memset。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Set_Ack_Observer(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation,
|
||
const IEC104_SendManagerAckObserver_t *observer)
|
||
{
|
||
if (!Manager_Session_Valid(manager, connection_generation)) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
if (observer != NULL) { manager->ack_observer = *observer; }
|
||
else { memset(&manager->ack_observer, 0, sizeof(manager->ack_observer)); }
|
||
return IEC104_SEND_MANAGER_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能:仅有序业务阶段允许队满旁路;同级前驱、已有帧和链路容量仍必须满足。
|
||
* 输入参数:manager——发送管理器。
|
||
* priority——优先级。
|
||
* 输出参数:无。
|
||
* 返回值:按处理分支返回IEC104_SEND_MANAGER_WAIT、IEC104_SEND_MANAGER_ERROR、checked == IEC104_ASDU_QUEUE_FULL ? IEC104_SEND_MANAGER_WAIT : IEC104_SEND_MANAGER_ERROR、link == 0 || manager->record_count == manager->record_capacity ? IEC104_SEND_MANAGER_WAIT : IEC104_SEND_MANAGER_OK。
|
||
* 说明:应用已依次给更高等级生产者准备机会,才可把本级候选交给现有单帧缓冲;不能任意直发抢占。
|
||
* 这里不删除低级原文,也不额外分配报文缓存;只是避免低级占满HIGH后阻塞高级候选。
|
||
* 不复制ASDU、不编号,可用于动作执行前的保守容量预检;实际提交必须重新校验。
|
||
*/
|
||
static IEC104_SendManagerResult_t Direct_Response_Admission(const IEC104_SendManager_t *manager,
|
||
IEC104_BusinessPriority_t priority)
|
||
{
|
||
IEC104_AsduHeadInfo_t queued;
|
||
IEC104_SendBufferHeadInfo_t frame;
|
||
IEC104_AsduQueueResult_t checked;
|
||
IEC104_SendBufferResult_t buffered;
|
||
unsigned lane;
|
||
int link;
|
||
if (manager->asdu_queue->strict_business_priority == 0U ||
|
||
manager->business_cycle_active == 0U || manager->business_frame_used != 0U ||
|
||
manager->direct_business_priority != priority ||
|
||
(manager->pending_business_priority != IEC104_BUSINESS_PRIORITY_NONE &&
|
||
priority > manager->pending_business_priority)) { return IEC104_SEND_MANAGER_WAIT; }
|
||
buffered = IEC104_SendBuffer_Peek_Send_Head(manager->send_buffer, &frame);
|
||
if (buffered == IEC104_SEND_BUFFER_OK) { return IEC104_SEND_MANAGER_WAIT; }
|
||
if (buffered != IEC104_SEND_BUFFER_EMPTY) { return IEC104_SEND_MANAGER_ERROR; }
|
||
for (lane = 0U; lane < IEC104_ASDU_PRIORITY_COUNT; ++lane) {
|
||
checked = IEC104_AsduQueue_Peek_Unsubmitted(manager->asdu_queue, (IEC104_AsduPriority_t)lane, &queued);
|
||
if (checked == IEC104_ASDU_QUEUE_ERROR) { return IEC104_SEND_MANAGER_ERROR; }
|
||
if (checked == IEC104_ASDU_QUEUE_OK && queued.business_priority <= priority) {
|
||
return IEC104_SEND_MANAGER_WAIT;
|
||
}
|
||
}
|
||
/* 同级没有待发前驱才可直接登记HANDED;票据耗尽或队列状态非法须在分配N(S)之前发现。 */
|
||
checked = IEC104_AsduQueue_Can_Record_Direct_Response(manager->asdu_queue,
|
||
manager->connection_generation, priority);
|
||
if (checked != IEC104_ASDU_QUEUE_OK) {
|
||
return checked == IEC104_ASDU_QUEUE_FULL ? IEC104_SEND_MANAGER_WAIT : IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
link = IEC104_Link_Can_Prepare_I_Frame(manager->link_state, manager->send_window_k);
|
||
if (link < 0) { return IEC104_SEND_MANAGER_ERROR; }
|
||
return link == 0 || manager->record_count == manager->record_capacity ?
|
||
IEC104_SEND_MANAGER_WAIT : IEC104_SEND_MANAGER_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能:容量提示同时承认“可入队”和“本阶段可旁路”两种接手方式;OK不表示当前就能上网发送。
|
||
* 输入参数:manager——发送管理器。
|
||
* generation——连接代次。
|
||
* asdu_length——ASDU字节长度。
|
||
* priority——优先级。
|
||
* 输出参数:无。
|
||
* 返回值:按处理分支返回IEC104_SEND_MANAGER_ERROR、IEC104_SEND_MANAGER_OK、Direct_Response_Admission(manager, priority)。
|
||
* 说明:使用当前模式的真实管理头长度,不能用兼容模式2字节头估算严格应答的余量。
|
||
* 查询不占空间、不取得票据,也不执行协议推进;业务决定和后续Submit之间仍须保持串行。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Can_Submit_Response_Priority(
|
||
const IEC104_SendManager_t *manager, uint64_t generation, uint16_t asdu_length,
|
||
IEC104_BusinessPriority_t priority)
|
||
{
|
||
uint32_t free_bytes, header;
|
||
if (asdu_length < IEC104_ASDU_HEADER_LEN || asdu_length > IEC104_MAX_ASDU_LEN ||
|
||
priority < IEC104_BUSINESS_PRIORITY_NONE || priority >= IEC104_BUSINESS_PRIORITY_COUNT ||
|
||
!Manager_Session_Valid(manager, generation) || !Response_Submit_Allowed(manager)) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
if (priority == IEC104_BUSINESS_PRIORITY_NONE) { priority = IEC104_BUSINESS_PRIORITY_INTERROGATION; }
|
||
header = manager->asdu_queue->strict_business_priority != 0U ?
|
||
IEC104_ASDU_STRICT_HIGH_ENTRY_HEADER_LEN : IEC104_ASDU_HIGH_ENTRY_HEADER_LEN;
|
||
if (IEC104_AsduQueue_Get_Free_Bytes(manager->asdu_queue, IEC104_ASDU_PRIORITY_HIGH,
|
||
&free_bytes) != IEC104_ASDU_QUEUE_OK) { return IEC104_SEND_MANAGER_ERROR; }
|
||
if (free_bytes >= header + asdu_length) { return IEC104_SEND_MANAGER_OK; }
|
||
return Direct_Response_Admission(manager, priority);
|
||
}
|
||
|
||
/**
|
||
* 功能:统一交接一帧I报文:预留、Link编号、提交APDU、建立记录、更新来源及调度额度。
|
||
* 输入参数:manager——发送管理器。
|
||
* asdu——ASDU报文。
|
||
* asdu_length——ASDU字节长度。
|
||
* priority——优先级。
|
||
* queue_entry——const IEC104_AsduEntryId_t *所指数据。
|
||
* normal_waiting——int值。
|
||
* response_ticket——uint64_t值。
|
||
* now_ms——当前单调毫秒时刻。
|
||
* head_info——队首信息。
|
||
* 输出参数:manager——发送管理器的更新结果。
|
||
* head_info——队首信息的更新结果。
|
||
* 返回值:严格旁路票据在成功返回后单独登记。
|
||
* 说明:queue_entry非NULL表示来自队列,response_ticket是已选中HIGH条目的真实票据,不能换成物理队首票据。
|
||
* 直接HIGH应答和IDLE传NULL,不虚构队列条目或执行Mark;严格旁路票据在成功返回后单独登记。
|
||
* 调用方已验证会话、ASDU及发送顺序;WAIT尚未接手原文,Link编号后的失败必须FATAL收尾。
|
||
*/
|
||
static IEC104_SendManagerResult_t Prepare_I_Asdu(
|
||
IEC104_SendManager_t *manager, const uint8_t *asdu, uint16_t asdu_length,
|
||
IEC104_AsduPriority_t priority, const IEC104_AsduEntryId_t *queue_entry,
|
||
int normal_waiting, uint64_t response_ticket, uint64_t now_ms, IEC104_SendBufferHeadInfo_t *head_info)
|
||
{
|
||
IEC104_SendBufferReservation_t reservation;
|
||
IEC104_SendBufferResult_t tx_result;
|
||
IEC104_SendBufferHeadInfo_t prepared_head;
|
||
IEC104_IFrameSendRecordStorage_t prepared;
|
||
int apdu_length;
|
||
|
||
/* 已ACK但未消费的记录仍占槽;没有记录容量时不得分配协议序号。 */
|
||
if (manager->record_count == manager->record_capacity) {
|
||
return IEC104_SEND_MANAGER_WAIT;
|
||
}
|
||
tx_result = IEC104_SendBuffer_Reserve_I_Frame(manager->send_buffer, &reservation);
|
||
if (tx_result == IEC104_SEND_BUFFER_FULL || tx_result == IEC104_SEND_BUFFER_BUSY) {
|
||
return IEC104_SEND_MANAGER_WAIT;
|
||
}
|
||
if (tx_result != IEC104_SEND_BUFFER_OK) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
memset(&prepared, 0, sizeof(prepared));
|
||
apdu_length = IEC104_Link_Prepare_I_Frame(manager->link_state, manager->send_window_k,
|
||
asdu, asdu_length,
|
||
reservation.apdu, reservation.apdu_capacity, &prepared.i_frame_snapshot);
|
||
if (apdu_length <= 0) {
|
||
if (IEC104_SendBuffer_Cancel_Reservation(manager->send_buffer, reservation.frame_id) != IEC104_SEND_BUFFER_OK) {
|
||
return IEC104_SEND_MANAGER_FATAL;
|
||
}
|
||
return apdu_length == 0 ? IEC104_SEND_MANAGER_WAIT : IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
/* 从Prepare成功起N(S)不可撤回,后续异常必须结束连接;此时原始ASDU尚未释放。 */
|
||
if (prepared.i_frame_snapshot.send_number != manager->next_record_ns ||
|
||
IEC104_SendBuffer_Commit_Frame(manager->send_buffer, reservation.frame_id, IEC104_SEND_BUFFER_FRAME_I,
|
||
(uint16_t)apdu_length, &prepared.i_frame_snapshot, now_ms) != IEC104_SEND_BUFFER_OK) {
|
||
return IEC104_SEND_MANAGER_FATAL;
|
||
}
|
||
/* 队列提交与直接提交共用发送记录及ACK记账。队列来源随后Mark;直接HIGH及IDLE的serial为0。
|
||
* SendBuffer已复制完整APDU,成功后不再借用业务输入;本步骤尚未执行socket发送。 */
|
||
prepared.frame_serial = reservation.frame_id.frame_serial;
|
||
prepared.asdu_entry_serial = queue_entry != NULL ? queue_entry->entry_serial : 0U;
|
||
prepared.asdu_priority = priority;
|
||
prepared.queued_at_ms = now_ms;
|
||
manager->records[Record_Index_From_Offset(manager, manager->record_count)] = prepared;
|
||
manager->record_count++;
|
||
if (priority == IEC104_ASDU_PRIORITY_HIGH) {
|
||
manager->high_unacked_count++;
|
||
} else if (priority == IEC104_ASDU_PRIORITY_IDLE) {
|
||
manager->idle_unacked_count++;
|
||
}
|
||
manager->next_record_ns = (uint16_t)((manager->next_record_ns + 1U) & IEC104_SEQUENCE_MASK);
|
||
manager->network_frame_used = 1U;
|
||
/* 在出HIGH之前固定关联;即使之后Mark失败,SendBuffer接手的事实也不撤回。
|
||
* 直接构帧的queue_entry为空;严格旁路由Submit_Response在本函数返回OK后登记非零票据并通知handed。
|
||
* IDLE不调用handed、不建立观察槽,也不参与队列Mark;仍保留真实帧身份供累计ACK及收尾回执使用。 */
|
||
if (priority == IEC104_ASDU_PRIORITY_HIGH && queue_entry != NULL &&
|
||
manager->ack_observer.handed != NULL) {
|
||
manager->ack_observer.handed(manager->ack_observer.context,
|
||
response_ticket, reservation.frame_id);
|
||
}
|
||
if (queue_entry != NULL && IEC104_AsduQueue_Mark_Submitted(manager->asdu_queue, priority,
|
||
*queue_entry) != IEC104_ASDU_QUEUE_OK) {
|
||
return IEC104_SEND_MANAGER_FATAL;
|
||
}
|
||
/* 只计本次成功选择;normal_waiting表示当前可选的NORMAL,已缓存但暂停的数据不计。
|
||
* 无可选NORMAL时清零,避免HIGH为尚不能发送的数据累积欠额;严格选帧不读取此公平配额。 */
|
||
if (priority == IEC104_ASDU_PRIORITY_HIGH &&
|
||
normal_waiting && manager->high_priority_burst_limit != 0U) {
|
||
/* 饱和计数;兼容模式达到配额后,下一次两级都可发时轮到NORMAL。 */
|
||
if (manager->high_priority_burst_count < manager->high_priority_burst_limit) {
|
||
manager->high_priority_burst_count++;
|
||
}
|
||
} else {
|
||
manager->high_priority_burst_count = 0U;
|
||
}
|
||
if (IEC104_SendBuffer_Peek_Send_Head(manager->send_buffer, &prepared_head) != IEC104_SEND_BUFFER_OK) {
|
||
return IEC104_SEND_MANAGER_FATAL;
|
||
}
|
||
if (manager->asdu_queue->strict_business_priority != 0U && manager->business_cycle_active != 0U) {
|
||
manager->business_frame_used = 1U;
|
||
}
|
||
*head_info = prepared_head;
|
||
return IEC104_SEND_MANAGER_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能:紧邻实际写socket前取得待写字节;没有已准备帧时选择ASDU并分配一个N(S)。
|
||
* 输入参数:manager/connection_generation——当前管理器及匹配代次;
|
||
* now_ms——单调毫秒,仅准备新I帧时成为本地发送期限起点。
|
||
* 输出参数:head_info——非NULL,仅OK时写入当前帧身份、描述和剩余字节借用指针。
|
||
* 返回值:OK返回当前帧剩余字节;EMPTY表示既无已准备帧,也无当前允许选择的ASDU;WAIT表示门控、窗口或记录容量阻塞;
|
||
* ERROR表示输入、会话或准备非法;Link准备成功后的提交异常返回FATAL。
|
||
* 调用链:续传当前I/控制帧;无当前帧时Peek_Unsubmitted -> Reserve_I_Frame -> Link.Prepare
|
||
* -> Buffer.Commit_Frame接手报文 -> 登记记录 -> Queue.Mark_Submitted完成队列交接记账 -> 返回待写字节。
|
||
* 说明:APDU提交且发送记录建立后,HIGH原文立即出队,NORMAL标记已提交并保留原文至ACK或覆盖。
|
||
* 控制帧先于尚未分配协议N(S)的ASDU,已准备的I帧即使EAGAIN零进度也必须先完成。
|
||
* 重复取得当前帧不编号、不改变配额或期限;函数不执行实际I/O。
|
||
* 只有启动/EOF暂停的NORMAL积压时EMPTY是正常空闲;调用方等待网络、期限或显式放行,不按缓存条数忙轮询。
|
||
* 跨尾部原文用249字节局部缓冲拼接后调用Link;连续原文直接借用,不增加动态分配。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Prepare_Next_Send(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation, uint64_t now_ms,
|
||
IEC104_SendBufferHeadInfo_t *head_info)
|
||
{
|
||
IEC104_AsduHeadInfo_t high_head_info, normal_head_info, selected_head_info;
|
||
IEC104_AsduQueueResult_t high_result, normal_result;
|
||
IEC104_SendBufferResult_t tx_result;
|
||
IEC104_SendBufferHeadInfo_t prepared_head;
|
||
uint8_t wrapped_asdu[IEC104_MAX_ASDU_LEN];
|
||
const uint8_t *selected_asdu;
|
||
int high_eligible, normal_eligible, normal_waiting;
|
||
|
||
if (head_info == NULL || !Manager_Session_Valid(manager, connection_generation)) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
/* 续传已准备帧,不为后续业务预建APDU;控制FIFO在选择新I帧之前排空。 */
|
||
tx_result = IEC104_SendBuffer_Peek_Send_Head(manager->send_buffer, &prepared_head);
|
||
if (tx_result == IEC104_SEND_BUFFER_OK) {
|
||
*head_info = prepared_head;
|
||
return IEC104_SEND_MANAGER_OK;
|
||
}
|
||
if (tx_result != IEC104_SEND_BUFFER_EMPTY) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
/* 已有帧及S/U继续;未分派业务通知先让应用形成完整候选集合。 */
|
||
if (manager->new_i_frame_blocked != 0U) { return IEC104_SEND_MANAGER_WAIT; }
|
||
high_result = IEC104_AsduQueue_Peek_Unsubmitted(manager->asdu_queue, IEC104_ASDU_PRIORITY_HIGH, &high_head_info);
|
||
normal_result = IEC104_AsduQueue_Peek_Unsubmitted(manager->asdu_queue, IEC104_ASDU_PRIORITY_NORMAL, &normal_head_info);
|
||
if (high_result == IEC104_ASDU_QUEUE_ERROR || normal_result == IEC104_ASDU_QUEUE_ERROR) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
if (high_result == IEC104_ASDU_QUEUE_EMPTY && normal_result == IEC104_ASDU_QUEUE_EMPTY) {
|
||
return IEC104_SEND_MANAGER_EMPTY;
|
||
}
|
||
high_eligible = high_result == IEC104_ASDU_QUEUE_OK;
|
||
normal_eligible = normal_result == IEC104_ASDU_QUEUE_OK;
|
||
/* 暂停的NORMAL不参与公平配额;即使此前HIGH已达配额,也必须允许本轮初始化/总召应答继续。
|
||
* 这里依据Peek的可选结果,不直接读取物理积压数,避免错误地选中尚未开放的NORMAL。 */
|
||
normal_waiting = normal_eligible;
|
||
/* Peek在严格模式分别给出两种生命周期中最优的可选条目,再比较业务等级。
|
||
* 同级比较两份存储共享的admission_order,不能固定偏向HIGH,也不能比较分级票据或N(S)。
|
||
* 兼容模式仍按HIGH配额选择,不要求NORMAL排空。 */
|
||
if (high_eligible && (manager->asdu_queue->strict_business_priority != 0U ?
|
||
(!normal_eligible || high_head_info.business_priority < normal_head_info.business_priority ||
|
||
(high_head_info.business_priority == normal_head_info.business_priority &&
|
||
high_head_info.admission_order < normal_head_info.admission_order)) :
|
||
High_Has_Priority(manager, normal_eligible))) {
|
||
selected_head_info = high_head_info;
|
||
} else {
|
||
selected_head_info = normal_head_info;
|
||
}
|
||
/* 已编码集合的最优条目仍可能低于待准备候选;暂停新编号,给下一业务轮继续准备的机会。
|
||
* 这个上限只限制等级更低者,同级已接手条目仍可推进;已编号帧在本函数开头已先行返回。 */
|
||
if (manager->asdu_queue->strict_business_priority != 0U &&
|
||
manager->pending_business_priority != IEC104_BUSINESS_PRIORITY_NONE &&
|
||
selected_head_info.business_priority > manager->pending_business_priority) {
|
||
return IEC104_SEND_MANAGER_WAIT;
|
||
}
|
||
/* 连续原文直接借用;跨尾部的两段仅在此拼成连续ASDU,原队列数据不移动。 */
|
||
selected_asdu = selected_head_info.asdu_first;
|
||
if (selected_head_info.asdu_second != NULL) {
|
||
if (IEC104_AsduQueue_Copy_Asdu(&selected_head_info, wrapped_asdu, sizeof(wrapped_asdu)) != IEC104_ASDU_QUEUE_OK) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
selected_asdu = wrapped_asdu;
|
||
}
|
||
return Prepare_I_Asdu(manager, selected_asdu, selected_head_info.asdu_length,
|
||
selected_head_info.priority, &selected_head_info.entry_id,
|
||
normal_waiting, selected_head_info.response_ticket, now_ms, head_info);
|
||
}
|
||
|
||
/**
|
||
* 功能:按启停阶段接手当前连接应答;兼容模式先试直发,严格模式先入队并仅在允许的阶段尝试队满旁路。
|
||
* 输入参数:asdu/asdu_length——业务原文;now_ms——准备帧时的单调时刻。
|
||
* 输出参数:仅OK写head_info,返回直接准备好的应答帧;成功后不再借用业务原文。
|
||
* 返回值:OK已准备、尚未实际写;QUEUED已缓存HIGH;WAIT未接手、由调用方保留重试;
|
||
* ERROR非法参数/状态或HIGH总容量装不下;FATAL表示编号后的交接失败,必须结束连接。
|
||
* 说明:仅STARTED/IDLE时接手;否则ERROR且不入HIGH。
|
||
* 准入先于容量及窗口判断;兼容模式的帧/配额/窗口阻塞转入HIGH,严格模式仅容量背压可尝试有序直交。
|
||
* 新STOP受理时取消HIGH待发应答;已经交给SendBuffer的I帧继续原发送及确认流程。
|
||
* 直接路径与队列路径共用Prepare_I_Asdu,不另建序号、帧缓冲或ACK逻辑。
|
||
* HIGH直发也通过Peek_Unsubmitted取得NORMAL资格;不能因旧缓存或旧配额而阻断启动所需的应答。
|
||
*/
|
||
static IEC104_SendManagerResult_t Submit_Response(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation,
|
||
const uint8_t *asdu, uint16_t asdu_length, uint64_t now_ms,
|
||
IEC104_SendBufferHeadInfo_t *head_info, uint64_t *ticket,
|
||
IEC104_BusinessPriority_t priority)
|
||
{
|
||
IEC104_AsduHeadInfo_t high_head, normal_head;
|
||
IEC104_SendBufferHeadInfo_t current_head;
|
||
IEC104_AsduQueueResult_t high_result, normal_result;
|
||
IEC104_SendBufferResult_t current_result;
|
||
IEC104_SendManagerResult_t result;
|
||
|
||
if (head_info == NULL || asdu == NULL || asdu_length < IEC104_ASDU_HEADER_LEN ||
|
||
asdu_length > IEC104_MAX_ASDU_LEN || !Manager_Session_Valid(manager, connection_generation)) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
if (priority < IEC104_BUSINESS_PRIORITY_NONE || priority >= IEC104_BUSINESS_PRIORITY_COUNT ||
|
||
!Response_Submit_Allowed(manager)) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
if (manager->asdu_queue->strict_business_priority != 0U) {
|
||
uint64_t direct_ticket;
|
||
if (priority == IEC104_BUSINESS_PRIORITY_NONE) { priority = IEC104_BUSINESS_PRIORITY_INTERROGATION; }
|
||
/* 统一入队;低级原文占满时,只允许当前有序阶段借用已有单帧缓冲,
|
||
* 既不撤回已接受的低级响应,也不让它们阻塞更高级的就绪候选。 */
|
||
result = IEC104_SendManager_Enqueue_Response_Priority(manager, connection_generation,
|
||
asdu, asdu_length, ticket, priority);
|
||
/* 只有容量背压才有旁路资格;非法输入/身份/队列状态不能用直发掩盖。
|
||
* QUEUED同样已复制接手,调用方必须推进游标,不能因尚未HANDED而重复提交。 */
|
||
if (result != IEC104_SEND_MANAGER_WAIT) {
|
||
return result == IEC104_SEND_MANAGER_OK ? IEC104_SEND_MANAGER_QUEUED : result;
|
||
}
|
||
result = Direct_Response_Admission(manager, priority);
|
||
if (result != IEC104_SEND_MANAGER_OK) { return result; }
|
||
result = Prepare_I_Asdu(manager, asdu, asdu_length, IEC104_ASDU_PRIORITY_HIGH, NULL,
|
||
0, 0U, now_ms, head_info);
|
||
if (result != IEC104_SEND_MANAGER_OK) { return result; }
|
||
/* 此时帧已编号且SendBuffer已接手,票据登记失败只能FATAL收尾,不能按未发送重试。
|
||
* 成功票据立即HANDED,但ACK仍须由该frame_id对应的真实累计确认来证明。 */
|
||
if (IEC104_AsduQueue_Record_Direct_Response(manager->asdu_queue, connection_generation,
|
||
priority, &direct_ticket) != IEC104_ASDU_QUEUE_OK) { return IEC104_SEND_MANAGER_FATAL; }
|
||
if (manager->ack_observer.handed != NULL) {
|
||
manager->ack_observer.handed(manager->ack_observer.context, direct_ticket, head_info->frame_id);
|
||
}
|
||
if (ticket != NULL) { *ticket = direct_ticket; }
|
||
return IEC104_SEND_MANAGER_OK;
|
||
}
|
||
current_result = IEC104_SendBuffer_Peek_Send_Head(manager->send_buffer, ¤t_head);
|
||
high_result = IEC104_AsduQueue_Peek_Unsubmitted(manager->asdu_queue, IEC104_ASDU_PRIORITY_HIGH, &high_head);
|
||
normal_result = IEC104_AsduQueue_Peek_Unsubmitted(manager->asdu_queue, IEC104_ASDU_PRIORITY_NORMAL, &normal_head);
|
||
if ((current_result != IEC104_SEND_BUFFER_OK && current_result != IEC104_SEND_BUFFER_EMPTY) ||
|
||
high_result == IEC104_ASDU_QUEUE_ERROR || normal_result == IEC104_ASDU_QUEUE_ERROR) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
if (current_result == IEC104_SEND_BUFFER_EMPTY && high_result == IEC104_ASDU_QUEUE_EMPTY &&
|
||
High_Has_Priority(manager, normal_result == IEC104_ASDU_QUEUE_OK)) {
|
||
result = Prepare_I_Asdu(manager, asdu, asdu_length, IEC104_ASDU_PRIORITY_HIGH, NULL,
|
||
normal_result == IEC104_ASDU_QUEUE_OK,
|
||
0U, now_ms, head_info);
|
||
if (result != IEC104_SEND_MANAGER_WAIT) {
|
||
if (result == IEC104_SEND_MANAGER_OK && ticket != NULL) { *ticket = 0U; }
|
||
return result;
|
||
}
|
||
}
|
||
/* 当前帧、窗口或配额暂不允许直发时,复制进HIGH,NORMAL非空不妨碍接手。 */
|
||
result = IEC104_SendManager_Enqueue_Response(manager, connection_generation, asdu, asdu_length, ticket);
|
||
return result == IEC104_SEND_MANAGER_OK ? IEC104_SEND_MANAGER_QUEUED : result;
|
||
}
|
||
|
||
/**
|
||
* 功能:准入后直接交给唯一SendBuffer;WAIT不转存HIGH/NORMAL,调用方下次重新取得快照。
|
||
* 输入参数:manager——发送管理器。
|
||
* connection_generation——连接代次。
|
||
* asdu——ASDU报文。
|
||
* asdu_length——ASDU字节长度。
|
||
* reserve——须保留的窗口及记录槽数量。
|
||
* now_ms——当前单调毫秒时刻。
|
||
* head_info——队首信息。
|
||
* priority——优先级。
|
||
* 输出参数:manager——发送管理器的更新结果。
|
||
* head_info——队首信息的更新结果。
|
||
* 返回值:按处理分支返回IEC104_SEND_MANAGER_ERROR、ready、Prepare_I_Asdu(manager, asdu, asdu_length, IEC104_ASDU_PRIORITY_IDLE, NULL, 0, 0U, now_ms, head_info)。
|
||
* 说明:兼容模式要求队列无待发;严格模式可越过更低等级条目,但不能越过同级前驱。
|
||
* normal_waiting=0用于维持既有配额记账,严格模式并不据此决定业务先后。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Submit_Idle_Priority(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation,
|
||
const uint8_t *asdu, uint16_t asdu_length, uint16_t reserve, uint64_t now_ms,
|
||
IEC104_SendBufferHeadInfo_t *head_info,
|
||
IEC104_BusinessPriority_t priority)
|
||
{
|
||
IEC104_SendManagerResult_t ready;
|
||
if (head_info == NULL || asdu == NULL || asdu_length < IEC104_ASDU_HEADER_LEN ||
|
||
asdu_length > IEC104_MAX_ASDU_LEN || !Manager_Session_Valid(manager, connection_generation)) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
ready = Idle_Admission(manager, reserve, priority);
|
||
if (ready != IEC104_SEND_MANAGER_OK) { return ready; }
|
||
return Prepare_I_Asdu(manager, asdu, asdu_length, IEC104_ASDU_PRIORITY_IDLE, NULL, 0, 0U, now_ms, head_info);
|
||
}
|
||
|
||
/**
|
||
* 功能:使用默认业务等级尝试直接准备一帧IDLE业务ASDU。
|
||
* 输入参数:manager/connection_generation——发送管理器及代次;asdu/asdu_length——原文及长度。
|
||
* reserve——须保留的窗口和记录槽数量;now_ms——本次单调时刻。
|
||
* 输出参数:head_info——OK时取得已准备的发送帧信息。
|
||
* 返回值:OK已准备;WAIT未接手;ERROR非法;FATAL表示编号后的交接失败。
|
||
* 说明:WAIT不复制到HIGH/NORMAL队列;准备成功后仍须由上层完成实际发送和进度回报。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Submit_Idle(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation,
|
||
const uint8_t *asdu, uint16_t asdu_length, uint16_t reserve, uint64_t now_ms,
|
||
IEC104_SendBufferHeadInfo_t *head_info)
|
||
{
|
||
return IEC104_SendManager_Submit_Idle_Priority(manager, connection_generation, asdu, asdu_length, reserve, now_ms, head_info, IEC104_BUSINESS_PRIORITY_NONE);
|
||
}
|
||
|
||
/**
|
||
* 功能:按指定业务等级提交应答,选择HIGH排队或满足条件的直接交接路径。
|
||
* 输入参数:manager/connection_generation——发送管理器及代次;asdu/asdu_length——原文及长度。
|
||
* now_ms——本次单调时刻;priority——业务等级,NONE表示使用默认等级。
|
||
* 输出参数:head_info——OK时的已准备帧信息。
|
||
* 返回值:OK已准备;QUEUED已排队;WAIT未接手;ERROR非法;FATAL为交接故障。
|
||
* 说明:本入口不返回票据;OK和QUEUED都已复制接手,调用方不可重复提交。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Submit_Response_Priority(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation,
|
||
const uint8_t *asdu, uint16_t asdu_length, uint64_t now_ms,
|
||
IEC104_SendBufferHeadInfo_t *head_info,
|
||
IEC104_BusinessPriority_t priority)
|
||
{
|
||
return Submit_Response(manager, connection_generation, asdu, asdu_length, now_ms, head_info, NULL, priority);
|
||
}
|
||
|
||
/**
|
||
* 功能:使用默认业务等级提交应答,沿用带等级入口的交接和HIGH排队规则。
|
||
* 输入参数:manager/connection_generation——发送管理器及代次;asdu/asdu_length——原文及长度。
|
||
* now_ms——本次单调时刻。
|
||
* 输出参数:head_info——OK时的已准备帧信息。
|
||
* 返回值:OK或QUEUED表示已接手;WAIT未接手;ERROR非法;FATAL为交接故障。
|
||
* 说明:准备或排队均不表示TCP已写完;本入口不返回交接票据。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Submit_Response(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation,
|
||
const uint8_t *asdu, uint16_t asdu_length, uint64_t now_ms,
|
||
IEC104_SendBufferHeadInfo_t *head_info)
|
||
{
|
||
return IEC104_SendManager_Submit_Response_Priority(manager, connection_generation, asdu, asdu_length, now_ms, head_info, IEC104_BUSINESS_PRIORITY_NONE);
|
||
}
|
||
|
||
/**
|
||
* 功能:与普通应答共用发送路径;OK和QUEUED均已接手,调用方不能重复提交同一原文。
|
||
* 输入参数:manager——发送管理器。
|
||
* connection_generation——连接代次。
|
||
* asdu——ASDU报文。
|
||
* asdu_length——ASDU字节长度。
|
||
* now_ms——当前单调毫秒时刻。
|
||
* head_info——队首信息。
|
||
* ticket——应答交接票据。
|
||
* priority——优先级。
|
||
* 输出参数:manager——发送管理器的更新结果。
|
||
* head_info——队首信息的更新结果。
|
||
* ticket——应答交接票据的更新结果。
|
||
* 返回值:严格模式排队或直交均返回非零票据,HANDED仍不等于写完或收到ACK。
|
||
* 说明:兼容模式直交票据为0;严格模式排队或直交均返回非零票据,HANDED仍不等于写完或收到ACK。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Submit_Response_Tracked_Priority(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation,
|
||
const uint8_t *asdu, uint16_t asdu_length, uint64_t now_ms,
|
||
IEC104_SendBufferHeadInfo_t *head_info, uint64_t *ticket,
|
||
IEC104_BusinessPriority_t priority)
|
||
{
|
||
return Submit_Response(manager, connection_generation, asdu, asdu_length, now_ms, head_info, ticket, priority);
|
||
}
|
||
|
||
/**
|
||
* 功能:使用默认业务等级提交应答,并按需返回交接票据。
|
||
* 输入参数:manager/connection_generation——发送管理器及代次;asdu/asdu_length——原文及长度。
|
||
* now_ms——本次单调时刻。
|
||
* 输出参数:head_info——OK时的已准备帧信息;ticket——接手成功时的票据,可为NULL。
|
||
* 返回值:OK或QUEUED已接手;WAIT未接手;ERROR非法;FATAL为交接故障。
|
||
* 说明:兼容模式直交票据为0;严格模式直交和排队均分配非零票据,票据交接不等于ACK。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Submit_Response_Tracked(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation,
|
||
const uint8_t *asdu, uint16_t asdu_length, uint64_t now_ms,
|
||
IEC104_SendBufferHeadInfo_t *head_info, uint64_t *ticket)
|
||
{
|
||
return IEC104_SendManager_Submit_Response_Tracked_Priority(manager, connection_generation, asdu, asdu_length, now_ms, head_info, ticket, IEC104_BUSINESS_PRIORITY_NONE);
|
||
}
|
||
|
||
/**
|
||
* 功能:提交队首实际写入增量,整帧写完后提交适用的链路完成结果并释放发送缓冲槽。
|
||
* 输入参数:manager——有效的本连接发送管理器。
|
||
* frame_id——此前Prepare_Next_Send或Submit_Response返回的当前帧身份。
|
||
* bytes_written_now——本次实际成功写入的增量,不能超过剩余长度;0不推进进度。
|
||
* now_ms——本次完成时刻;最后一段须传实际整帧写完的单调时刻。
|
||
* 输出参数:completion——仅FRAME_WRITTEN时写入数值副本;其他结果保持原值。
|
||
* 发送队列、链路及I帧记录——按实际发送进度提交状态。
|
||
* 返回值:OK表示尚未写完;FRAME_WRITTEN表示本地完成处理及缓冲释放成功;ERROR表示输入或匹配非法;
|
||
* FATAL表示整帧写完后的状态提交失败,必须结束当前连接。
|
||
* 调用方:Connection接收TcpServer的实际写入结果后,用准备帧时取得的frame_id提交本次增量。
|
||
* 调用链:SendBuffer.Record_Written_Bytes;仅整帧写完时继续分派适用的Link.Complete
|
||
* -> Manager登记I帧本地完成 -> SendBuffer.Commit_Send_Completion。
|
||
* 说明:本函数不写socket;调用方先执行实际I/O,再恰好提交一次对应进度。
|
||
* TESTFR_CON没有Link完成接口;完整写入后直接进入缓冲完成处理。
|
||
* 整帧完成时刻不能早于入队时刻;部分写入不更新计时起点。
|
||
* 同一增量不能重复提交,也不能另行调用Buffer.Record_Written_Bytes、Link.Complete或Buffer完成接口。
|
||
* 完成本函数后再分派依赖本地TESTFR_ACT完成的TESTFR_CON;不自动创建t1定时器。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Handle_Send_Progress(
|
||
IEC104_SendManager_t *manager, IEC104_SendFrameId_t frame_id,
|
||
uint16_t bytes_written_now, uint64_t now_ms, IEC104_LocalSendCompletion_t *completion)
|
||
{
|
||
IEC104_SendBufferHeadInfo_t head_info;
|
||
IEC104_SendBufferResult_t tx_result;
|
||
IEC104_LinkResult_t link_completion_result;
|
||
IEC104_IFrameSendRecordStorage_t *record = NULL;
|
||
IEC104_LocalSendCompletion_t prepared;
|
||
|
||
if (completion == NULL || !Manager_Session_Valid(manager, frame_id.connection_generation) ||
|
||
IEC104_SendBuffer_Peek_Send_Head(manager->send_buffer, &head_info) != IEC104_SEND_BUFFER_OK ||
|
||
head_info.frame_id.frame_serial != frame_id.frame_serial || head_info.remaining_bytes == 0U) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
/* 在推进写入进度之前核对业务记录,避免错误frame_id或关联造成部分状态更新。 */
|
||
if (head_info.frame_type == IEC104_SEND_BUFFER_FRAME_I) {
|
||
record = Find_Pending_Send_Record(manager, &head_info);
|
||
if (record == NULL) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
}
|
||
tx_result = IEC104_SendBuffer_Record_Written_Bytes(manager->send_buffer, frame_id, bytes_written_now, now_ms);
|
||
if (tx_result == IEC104_SEND_BUFFER_OK) {
|
||
return IEC104_SEND_MANAGER_OK;
|
||
}
|
||
if (tx_result != IEC104_SEND_BUFFER_FRAME_WRITTEN) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
/*
|
||
* 整帧完成第1步:按原始类型分派适用的Link完成接口;TESTFR_CON无需调用,I帧推进sent_vs及捎带确认。
|
||
* head_info保留构帧时的类型和I帧快照,实际完整发送时刻取本次now_ms。
|
||
*/
|
||
link_completion_result = Dispatch_Link_Send_Completion(manager, &head_info, head_info.apdu_length);
|
||
if (link_completion_result != IEC104_LINK_RESULT_OK && link_completion_result != IEC104_LINK_RESULT_IGNORED) {
|
||
return IEC104_SEND_MANAGER_FATAL;
|
||
}
|
||
if (record != NULL) {
|
||
if (link_completion_result != IEC104_LINK_RESULT_OK) {
|
||
return IEC104_SEND_MANAGER_FATAL;
|
||
}
|
||
/* 第2步:登记Manager业务记录的本地完成;后续接收路径才允许ACK覆盖该帧。 */
|
||
record->local_send_completed = 1U;
|
||
record->written_at_ms = now_ms;
|
||
}
|
||
/*
|
||
* 第3步:释放当前I槽或控制FIFO队首;独立业务记录继续等待ACK,即使NORMAL原文已覆盖。
|
||
* 这里只处理报文存储,就绪记录由TcpServer转为事件后再移除。Complete已提交,缓冲提交失败不能重做Complete。
|
||
*/
|
||
if (IEC104_SendBuffer_Commit_Send_Completion(manager->send_buffer, frame_id) != IEC104_SEND_BUFFER_OK) {
|
||
return IEC104_SEND_MANAGER_FATAL;
|
||
}
|
||
/* 输出只复制数值,避免把已释放帧的借用指针交给后续定时器或业务。 */
|
||
prepared.frame_id = frame_id;
|
||
prepared.frame_type = head_info.frame_type;
|
||
prepared.link_completion_result = link_completion_result;
|
||
prepared.i_frame_snapshot = head_info.i_frame_snapshot;
|
||
prepared.queued_at_ms = head_info.queued_at_ms;
|
||
prepared.written_at_ms = now_ms;
|
||
*completion = prepared;
|
||
return IEC104_SEND_MANAGER_FRAME_WRITTEN;
|
||
}
|
||
|
||
/**
|
||
* 功能:将匹配队首的发送失败或本地发送超时交给链路完成接口。
|
||
* 输入参数:manager——有效的本连接发送管理器。
|
||
* frame_id——尚未整帧完成的发送队首身份。
|
||
* 输出参数:link_state——匹配时按Complete(-1)约定清理;队列及业务记录保留供故障回收。
|
||
* 返回值:ERROR表示参数、会话、队首或身份非法;匹配并提交失败后始终返回FATAL。
|
||
* 说明:即使底层Complete返回IGNORED,实际发送失败仍要求连接层断连。
|
||
* 不自动Abort;调用方须回收业务、关闭TCP并结束或隔离旧I/O。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Handle_Send_Failure(
|
||
IEC104_SendManager_t *manager, IEC104_SendFrameId_t frame_id)
|
||
{
|
||
IEC104_SendBufferHeadInfo_t head_info;
|
||
|
||
if (!Manager_Session_Valid(manager, frame_id.connection_generation) ||
|
||
IEC104_SendBuffer_Peek_Send_Head(manager->send_buffer, &head_info) != IEC104_SEND_BUFFER_OK ||
|
||
head_info.frame_id.frame_serial != frame_id.frame_serial || head_info.remaining_bytes == 0U ||
|
||
(head_info.frame_type == IEC104_SEND_BUFFER_FRAME_I && Find_Pending_Send_Record(manager, &head_info) == NULL)) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
/* 网络失败已决定必须断连,不因底层完成接口返回IGNORED而继续发送。 */
|
||
(void)Dispatch_Link_Send_Completion(manager, &head_info, -1);
|
||
return IEC104_SEND_MANAGER_FATAL;
|
||
}
|
||
|
||
/**
|
||
* 功能:处理已解析I/S帧,验证累计ACK并登记确认事实;仅NORMAL继续确认原文队列。
|
||
* 输入参数:manager/connection_generation——当前管理器及匹配代次;
|
||
* apci——成功Parse_APCI得到的完整I/S帧描述;now_ms——本次协议推进的单调时刻。
|
||
* 输出参数:Link——提交有效ACK及I帧接收位置;records——标记新确认事实;
|
||
* Manager——分别核减HIGH及IDLE未确认记录数;AsduQueue——释放NORMAL原文或核减覆盖待确认数;不消费业务回执。
|
||
* 返回值:OK处理成功;ERROR表示参数、会话或新确认区间的记录非法;
|
||
* PROTOCOL_ERROR表示合法本地会话下Link拒绝报文;FATAL表示受理后的确认同步或原文释放失败。
|
||
* 调用链:读取旧位置 -> 预检新ACK记录 -> Link.Handle -> 登记全部新ACK事实 -> NORMAL逐条Confirm_Next_Normal_Entry。
|
||
* 说明:ACK只能覆盖已提交本地完成的I帧;异步接入须先提交真实发送结果。
|
||
* 重复ACK的新确认数量为0,不重复释放、不重置期限或首次ACK时刻;I帧接收仍由Link处理。
|
||
* 确认处理只访问新确认区间,复杂度O(新确认数)。释放中途失败仍保留整个已接受ACK区间供恢复。
|
||
* NORMAL原文覆盖不撤销帧;记录仍严格匹配序号和本地完成,已覆盖原文由Queue跳过释放。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Handle_I_S_Frame(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation,
|
||
const IEC104_ApciInfo_t *apci, uint64_t now_ms)
|
||
{
|
||
IEC104_IFrameSendProgress_t before_progress, after_progress;
|
||
uint16_t acknowledged, first_offset, i, high_acknowledged = 0U, idle_acknowledged = 0U;
|
||
int ack_in_range;
|
||
IEC104_LinkResult_t result;
|
||
|
||
if (!Manager_Session_Valid(manager, connection_generation) || apci == NULL ||
|
||
(apci->frame_type != IEC104_FRAME_TYPE_I && apci->frame_type != IEC104_FRAME_TYPE_S) ||
|
||
IEC104_Link_Get_Send_Progress(manager->link_state, &before_progress) != 1) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
acknowledged = Sequence_Distance(before_progress.peer_ack_nr, apci->receive_number);
|
||
ack_in_range = apci->receive_number <= IEC104_SEQUENCE_MASK &&
|
||
acknowledged <= Sequence_Distance(before_progress.peer_ack_nr, before_progress.next_completion_ns);
|
||
/* 记录前缀是已ACK未消费回执,后缀是未ACK帧;相减直接定位旧V(A)对应记录。 */
|
||
first_offset = (uint16_t)(manager->record_count -
|
||
Sequence_Distance(before_progress.peer_ack_nr, before_progress.next_frame_ns));
|
||
/* 非法网络N(R)不用于访问记录,仍由Link处理并拒绝。 */
|
||
if (ack_in_range) {
|
||
for (i = 0U; i < acknowledged; ++i) {
|
||
uint16_t offset = (uint16_t)(first_offset + i);
|
||
const IEC104_IFrameSendRecordStorage_t *record = &manager->records[Record_Index_From_Offset(manager, offset)];
|
||
if (!I_Frame_Record_Valid(manager, record, offset) ||
|
||
record->local_send_completed != 1U || record->peer_acknowledged != 0U) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
if (record->asdu_priority == IEC104_ASDU_PRIORITY_HIGH) {
|
||
high_acknowledged++;
|
||
} else if (record->asdu_priority == IEC104_ASDU_PRIORITY_IDLE) {
|
||
idle_acknowledged++;
|
||
}
|
||
}
|
||
if (high_acknowledged > manager->high_unacked_count || idle_acknowledged > manager->idle_unacked_count) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
}
|
||
result = apci->frame_type == IEC104_FRAME_TYPE_I ?
|
||
IEC104_Link_Handle_I_Frame(manager->link_state, apci) :
|
||
IEC104_Link_Handle_S_Frame(manager->link_state, apci);
|
||
/* 本地会话及记录已预检;Link仍检查接收阶段、序号范围及N(R),不检查接收N(S)连续性。 */
|
||
if (result == IEC104_LINK_RESULT_FATAL) {
|
||
return IEC104_SEND_MANAGER_PROTOCOL_ERROR;
|
||
}
|
||
if (result != IEC104_LINK_RESULT_OK || !ack_in_range ||
|
||
IEC104_Link_Get_Send_Progress(manager->link_state, &after_progress) != 1 ||
|
||
after_progress.peer_ack_nr != apci->receive_number) {
|
||
return IEC104_SEND_MANAGER_FATAL;
|
||
}
|
||
/* 即使之后释放原文失败,也不能丢失Link已经接受的累计确认事实。
|
||
* 必须先遍历完整的新ACK区间:较早的NORMAL释放失败时,后面的HIGH及IDLE仍已被同一N(R)确认。
|
||
* 所有来源都通知acknowledged;观察器按帧身份匹配,未建立观察槽的IDLE不会命中HIGH票据。
|
||
* 观察器就在事实生效处登记时刻,不依赖上层收到OK,也不等待记录转成RECORD事件。 */
|
||
for (i = 0U; i < acknowledged; ++i) {
|
||
IEC104_IFrameSendRecordStorage_t *record =
|
||
&manager->records[Record_Index_From_Offset(manager, (uint16_t)(first_offset + i))];
|
||
record->peer_acknowledged = 1U;
|
||
if (manager->ack_observer.acknowledged != NULL) {
|
||
IEC104_SendFrameId_t frame_id;
|
||
frame_id.connection_generation = connection_generation;
|
||
frame_id.frame_serial = record->frame_serial;
|
||
manager->ack_observer.acknowledged(manager->ack_observer.context, frame_id, now_ms);
|
||
}
|
||
}
|
||
manager->high_unacked_count = (uint16_t)(manager->high_unacked_count - high_acknowledged);
|
||
manager->idle_unacked_count = (uint16_t)(manager->idle_unacked_count - idle_acknowledged);
|
||
/* HIGH原文已出队,IDLE没有队列原文;仅NORMAL按真实身份释放原文或核减覆盖计数。 */
|
||
for (i = 0U; i < acknowledged; ++i) {
|
||
const IEC104_IFrameSendRecordStorage_t *record =
|
||
&manager->records[Record_Index_From_Offset(manager, (uint16_t)(first_offset + i))];
|
||
IEC104_AsduEntryId_t entry_id;
|
||
if (record->asdu_priority != IEC104_ASDU_PRIORITY_NORMAL) {
|
||
continue;
|
||
}
|
||
entry_id.connection_generation = connection_generation;
|
||
entry_id.entry_serial = record->asdu_entry_serial;
|
||
if (IEC104_AsduQueue_Confirm_Next_Normal_Entry(manager->asdu_queue, record->asdu_priority, entry_id) != IEC104_ASDU_QUEUE_OK) {
|
||
return IEC104_SEND_MANAGER_FATAL;
|
||
}
|
||
}
|
||
return IEC104_SEND_MANAGER_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能:按交接顺序复制指定偏移处的业务记录,供观察或故障回收。
|
||
* 输入参数:manager——存储结构有效的发送管理器,不要求故障后的Link仍合法。
|
||
* offset——相对当前记录队首的记录数偏移,0表示最早记录,单位不是字节。
|
||
* 输出参数:record——仅OK时写入带完整frame_id的数值副本;EMPTY和ERROR时保持原值。
|
||
* 返回值:OK表示取得记录;EMPTY表示偏移处无记录;ERROR表示参数、存储或记录非法。
|
||
* 说明:frame_id由Manager共享代次和记录frame_serial组合,不依赖Link或原文借用。
|
||
* 不删除记录、不修改完成标志;已关闭TCP不妨碍读取保存的ACK事实。
|
||
* 已确认与未确认事实须供业务回收策略使用;未确认不等于对端未收到。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Get_Record_By_Offset(
|
||
const IEC104_SendManager_t *manager, uint16_t offset, IEC104_IFrameSendRecord_t *record)
|
||
{
|
||
const IEC104_IFrameSendRecordStorage_t *stored;
|
||
IEC104_IFrameSendRecord_t prepared;
|
||
|
||
if (!Manager_Storage_Valid(manager) || record == NULL) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
if (offset >= manager->record_count) {
|
||
return IEC104_SEND_MANAGER_EMPTY;
|
||
}
|
||
stored = &manager->records[Record_Index_From_Offset(manager, offset)];
|
||
if (!I_Frame_Record_Valid(manager, stored, offset)) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
memset(&prepared, 0, sizeof(prepared));
|
||
prepared.frame_id.connection_generation = manager->connection_generation;
|
||
prepared.frame_id.frame_serial = stored->frame_serial;
|
||
prepared.asdu_entry_serial = stored->asdu_entry_serial;
|
||
prepared.queued_at_ms = stored->queued_at_ms;
|
||
prepared.written_at_ms = stored->written_at_ms;
|
||
prepared.i_frame_snapshot = stored->i_frame_snapshot;
|
||
prepared.asdu_priority = stored->asdu_priority;
|
||
prepared.local_send_completed = stored->local_send_completed;
|
||
prepared.peer_acknowledged = stored->peer_acknowledged;
|
||
*record = prepared;
|
||
return IEC104_SEND_MANAGER_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能:读取最早已完成本地发送、尚未被对端确认的I帧记录。
|
||
* 输入参数:manager——当前会话有效的子站管理器;record——非NULL输出。
|
||
* 输出参数:仅OK时复制记录,不返回APDU指针,不改变队列。
|
||
* 返回值:OK、EMPTY(包括只有待发送I帧)或ERROR。
|
||
* 说明:记录环形数组中,已确认未消费的前缀后就是V(A)对应的记录,可直接定位。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Peek_Oldest_Sent_Unacked_Record(
|
||
const IEC104_SendManager_t *manager, IEC104_IFrameSendRecord_t *record)
|
||
{
|
||
IEC104_IFrameSendProgress_t progress;
|
||
IEC104_IFrameSendRecord_t prepared;
|
||
uint16_t offset;
|
||
|
||
if (record == NULL || !Manager_Storage_Valid(manager) ||
|
||
!Manager_Session_Valid(manager, manager->connection_generation) ||
|
||
IEC104_Link_Get_Send_Progress(manager->link_state, &progress) != 1) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
if (progress.peer_ack_nr == progress.next_completion_ns) {
|
||
return IEC104_SEND_MANAGER_EMPTY;
|
||
}
|
||
offset = (uint16_t)(manager->record_count -
|
||
Sequence_Distance(progress.peer_ack_nr, progress.next_frame_ns));
|
||
if (IEC104_SendManager_Get_Record_By_Offset(manager, offset, &prepared) != IEC104_SEND_MANAGER_OK ||
|
||
prepared.i_frame_snapshot.send_number != progress.peer_ack_nr ||
|
||
prepared.local_send_completed != 1U || prepared.peer_acknowledged != 0U) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
*record = prepared;
|
||
return IEC104_SEND_MANAGER_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能:起点与期限已校验;
|
||
* 输入参数:now_ms——当前单调毫秒时刻。
|
||
* started_ms——毫秒计时值。
|
||
* timeout_ms——超时毫秒数。
|
||
* 输出参数:无。
|
||
* 返回值:返回elapsed >= timeout_ms ? 0U : timeout_ms - (uint32_t)elapsed的结果。
|
||
* 说明:先作64位差值再截断,避免绝对期限加法或长时间差溢出。
|
||
*/
|
||
static uint32_t Deadline_Remaining(uint64_t now_ms, uint64_t started_ms, uint32_t timeout_ms)
|
||
{
|
||
uint64_t elapsed = now_ms - started_ms;
|
||
return elapsed >= timeout_ms ? 0U : timeout_ms - (uint32_t)elapsed;
|
||
}
|
||
|
||
/**
|
||
* 功能:向Connection提供同一时刻的队首期限、帧身份、I帧t1和控制容量。
|
||
* 输入参数:manager——发送管理器。
|
||
* connection_generation——连接代次。
|
||
* now_ms——当前单调毫秒时刻。
|
||
* local_send_timeout_ms——毫秒计时值。
|
||
* t1_ms——确认超时毫秒数。
|
||
* deadlines——IEC104_SendManagerDeadlines_t *所指数据。
|
||
* 输出参数:deadlines——IEC104_SendManagerDeadlines_t *所指数据的更新结果。
|
||
* 返回值:按处理分支返回IEC104_SEND_MANAGER_ERROR、IEC104_SEND_MANAGER_OK。
|
||
* 说明:原始起点仍分别来自Buffer和发送记录;此快照只在当前串行调用中使用,不缓存到对象内。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Get_Deadlines(
|
||
const IEC104_SendManager_t *manager, uint64_t connection_generation,
|
||
uint64_t now_ms, uint32_t local_send_timeout_ms, uint32_t t1_ms,
|
||
IEC104_SendManagerDeadlines_t *deadlines)
|
||
{
|
||
IEC104_SendManagerDeadlines_t prepared;
|
||
IEC104_SendBufferStatus_t buffer_status;
|
||
IEC104_SendBufferHeadInfo_t head;
|
||
IEC104_IFrameSendRecord_t record;
|
||
IEC104_SendBufferResult_t buffered;
|
||
IEC104_SendManagerResult_t recorded;
|
||
|
||
if (deadlines == NULL || local_send_timeout_ms == 0U || t1_ms == 0U ||
|
||
!Manager_Session_Valid(manager, connection_generation) ||
|
||
IEC104_SendBuffer_Get_Status(manager->send_buffer, &buffer_status) != IEC104_SEND_BUFFER_OK) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
memset(&prepared, 0, sizeof(prepared));
|
||
prepared.control_has_room = buffer_status.control_has_room;
|
||
buffered = IEC104_SendBuffer_Peek_Send_Head(manager->send_buffer, &head);
|
||
if (buffered == IEC104_SEND_BUFFER_OK) {
|
||
if (now_ms < head.queued_at_ms) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
prepared.has_send_head = 1U;
|
||
prepared.head_frame_id = head.frame_id;
|
||
prepared.local_send_remaining_ms = Deadline_Remaining(now_ms, head.queued_at_ms, local_send_timeout_ms);
|
||
} else if (buffered != IEC104_SEND_BUFFER_EMPTY) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
recorded = IEC104_SendManager_Peek_Oldest_Sent_Unacked_Record(manager, &record);
|
||
if (recorded == IEC104_SEND_MANAGER_OK) {
|
||
if (now_ms < record.written_at_ms) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
prepared.has_i_ack_deadline = 1U;
|
||
prepared.i_ack_remaining_ms = Deadline_Remaining(now_ms, record.written_at_ms, t1_ms);
|
||
} else if (recorded != IEC104_SEND_MANAGER_EMPTY) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
*deadlines = prepared;
|
||
return IEC104_SEND_MANAGER_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能:检查最早已本地完成、尚未收到ACK的I帧是否达到t1。
|
||
* 输入参数:manager/connection_generation——当前管理器及匹配代次;
|
||
* now_ms——当前单调毫秒;t1_ms——非零确认等待期限。
|
||
* 输出参数:无,不更新记录、不启动定时器或关闭连接。
|
||
* 返回值:1到期;0未到期或没有已完成未确认I帧;-1参数、状态或时间非法。
|
||
* 说明:起点取最早未ACK记录的原written_at_ms,等于期限即到期。
|
||
* 部分ACK后选下一帧的原时间,重复ACK或后续帧发送不为前帧续期;
|
||
* 尚未整帧完成的当前I帧使用Buffer的本地发送期限。
|
||
*/
|
||
int IEC104_SendManager_T1_I_Ack_Expired(
|
||
const IEC104_SendManager_t *manager, uint64_t connection_generation,
|
||
uint64_t now_ms, uint32_t t1_ms)
|
||
{
|
||
IEC104_IFrameSendRecord_t record;
|
||
IEC104_SendManagerResult_t result;
|
||
|
||
if (!Manager_Storage_Valid(manager) || connection_generation != manager->connection_generation || t1_ms == 0U) {
|
||
return -1;
|
||
}
|
||
result = IEC104_SendManager_Peek_Oldest_Sent_Unacked_Record(manager, &record);
|
||
if (result == IEC104_SEND_MANAGER_EMPTY) {
|
||
return 0;
|
||
}
|
||
if (result != IEC104_SEND_MANAGER_OK || now_ms < record.written_at_ms) {
|
||
return -1;
|
||
}
|
||
return Deadline_Remaining(now_ms, record.written_at_ms, t1_ms) == 0U;
|
||
}
|
||
|
||
/**
|
||
* 功能:读取同时满足本地完成和对端确认的队首业务回执。
|
||
* 输入参数:manager——存储结构有效的发送管理器。
|
||
* 输出参数:record——仅OK时写入回执副本;其余结果保持原值。
|
||
* 返回值:OK表示队首回执就绪;EMPTY表示无记录;WAIT表示队首尚未同时满足两个条件;
|
||
* ERROR表示参数、存储或记录非法。
|
||
* 调用方:Connection代TcpServer查询;返回OK后,TcpServer复制RECORD事件,再经Connection调用Remove。
|
||
* 说明:只检查队首,不跳过尚未完成的旧记录;不依赖运行中的Link状态。
|
||
* 不自动释放记录;事件成功保存后才调用Remove_Confirmed_Record,尚未移除的回执仍占容量。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Peek_Confirmed_Record(
|
||
const IEC104_SendManager_t *manager, IEC104_IFrameSendRecord_t *record)
|
||
{
|
||
IEC104_IFrameSendRecord_t prepared;
|
||
IEC104_SendManagerResult_t result;
|
||
|
||
if (record == NULL) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
result = IEC104_SendManager_Get_Record_By_Offset(manager, 0U, &prepared);
|
||
if (result != IEC104_SEND_MANAGER_OK) {
|
||
return result;
|
||
}
|
||
if (prepared.local_send_completed == 0U || prepared.peer_acknowledged == 0U) {
|
||
return IEC104_SEND_MANAGER_WAIT;
|
||
}
|
||
*record = prepared;
|
||
return IEC104_SEND_MANAGER_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能:在TcpServer成功保存RECORD事件后,按frame_id释放已就绪的队首内部记录。
|
||
* 输入参数:manager——存储结构有效的发送管理器。
|
||
* frame_id——已读取并成功复制为事件的队首回执身份。
|
||
* 输出参数:manager——成功时推进record_head_index并减少record_count。
|
||
* 返回值:OK表示释放成功;ERROR表示参数、记录、frame_id非法,或队首尚未就绪/不存在。
|
||
* 调用方:Connection接到TcpServer的记录移除请求后,用Peek_Confirmed_Record返回的frame_id调用一次。
|
||
* 说明:失败不修改记录;成功只释放业务记录槽,不改变Link序号、ACK或原始ASDU存储。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Remove_Confirmed_Record(
|
||
IEC104_SendManager_t *manager, IEC104_SendFrameId_t frame_id)
|
||
{
|
||
IEC104_IFrameSendRecord_t record;
|
||
|
||
if (IEC104_SendManager_Peek_Confirmed_Record(manager, &record) != IEC104_SEND_MANAGER_OK ||
|
||
frame_id.connection_generation != record.frame_id.connection_generation || frame_id.frame_serial != record.frame_id.frame_serial) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
manager->record_head_index = Record_Index_From_Offset(manager, 1U);
|
||
manager->record_count--;
|
||
return IEC104_SEND_MANAGER_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能:终止Manager,并在自身存储结构有效时终止绑定的SendBuffer。
|
||
* 输入参数:manager——待终止对象,允许NULL。
|
||
* 输出参数:manager——非NULL时清零;AsduQueue及调用方记录数组保留。
|
||
* 返回值:无。
|
||
* 说明:先结束旧I/O并读取需要的业务记录;清零后不能再通过Manager取得这些回执。
|
||
* AsduQueue.Rebind清空HIGH并恢复NORMAL现存原文;明确全部丢弃须另调AsduQueue.Abort。
|
||
* 本函数不关闭socket、不回滚Link,不能代替旧异步操作的结束或隔离。
|
||
*/
|
||
void IEC104_SendManager_Abort(IEC104_SendManager_t *manager)
|
||
{
|
||
if (manager != NULL) {
|
||
if (Manager_Storage_Valid(manager)) {
|
||
IEC104_SendBuffer_Abort(manager->send_buffer);
|
||
}
|
||
memset(manager, 0, sizeof(*manager));
|
||
}
|
||
}
|
||
|
||
/* ==================== 子站:STARTDT_CON / STOPDT_CON ==================== */
|
||
|
||
/**
|
||
* 功能:Link已生成启动应答后提交;
|
||
* 输入参数:manager——发送管理器。
|
||
* reservation——const IEC104_SendBufferReservation_t *所指数据。
|
||
* now_ms——当前单调毫秒时刻。
|
||
* first_start——int值。
|
||
* 输出参数:manager——发送管理器的更新结果。
|
||
* 返回值:按处理分支返回IEC104_SEND_MANAGER_FATAL、Commit_Control_Frame(manager, reservation, IEC104_SEND_BUFFER_FRAME_STARTDT_CON, now_ms)。
|
||
* 说明:仅每轮首个CON清理HIGH,重复应答保留队列及公平配额。
|
||
*/
|
||
static IEC104_SendManagerResult_t Commit_Startdt_Con(
|
||
IEC104_SendManager_t *manager, const IEC104_SendBufferReservation_t *reservation,
|
||
uint64_t now_ms, int first_start)
|
||
{
|
||
if (first_start) {
|
||
if (IEC104_AsduQueue_Reset_High(manager->asdu_queue, manager->connection_generation) != IEC104_ASDU_QUEUE_OK) {
|
||
return IEC104_SEND_MANAGER_FATAL;
|
||
}
|
||
manager->high_priority_burst_count = 0U;
|
||
}
|
||
return Commit_Control_Frame(manager, reservation, IEC104_SEND_BUFFER_FRAME_STARTDT_CON, now_ms);
|
||
}
|
||
|
||
/**
|
||
* 功能:先取得控制槽再受理START;受理时立即激活并结束停止等待,CON按FIFO发送。
|
||
* 输入参数:manager——发送管理器。
|
||
* connection_generation——连接代次。
|
||
* apci——APCI控制头。
|
||
* now_ms——当前单调毫秒时刻。
|
||
* 输出参数:manager——发送管理器的更新结果。
|
||
* 返回值:按处理分支返回IEC104_SEND_MANAGER_ERROR、result、Cancel_Control_Reservation(manager, &reservation, IEC104_SEND_MANAGER_FATAL)、Commit_Startdt_Con(manager, &reservation, now_ms, first_start)。
|
||
* 说明:WAIT保留原请求、状态和期限;相反方向ACT不暂存。
|
||
* 保留本项目的队列约定:从停用状态重新启动清理HIGH,已激活时重复START保留HIGH。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Slave_Handle_Startdt_Act(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation,
|
||
const IEC104_ApciInfo_t *apci, uint64_t now_ms)
|
||
{
|
||
IEC104_SendBufferReservation_t reservation;
|
||
IEC104_SendManagerResult_t result;
|
||
int first_start;
|
||
|
||
if (apci == NULL || apci->frame_type != IEC104_FRAME_TYPE_U || apci->u_function != IEC104_U_STARTDT_ACT) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
result = Reserve_Control_Frame(manager, connection_generation, &reservation);
|
||
if (result != IEC104_SEND_MANAGER_OK) {
|
||
return result;
|
||
}
|
||
first_start = manager->link_state->dt_state == IEC104_DT_STOPPED;
|
||
if (IEC104_Link_Handle_Startdt_Act(manager->link_state, apci,
|
||
reservation.apdu, reservation.apdu_capacity) != IEC104_LINK_RESULT_OK) {
|
||
return Cancel_Control_Reservation(manager, &reservation, IEC104_SEND_MANAGER_FATAL);
|
||
}
|
||
return Commit_Startdt_Con(manager, &reservation, now_ms, first_start);
|
||
}
|
||
|
||
/**
|
||
* 功能:STOP受理立即停用并清理HIGH;当前I帧和已有控制帧仍须按原顺序完成。
|
||
* 输入参数:manager——发送管理器。
|
||
* connection_generation——连接代次。
|
||
* apci——APCI控制头。
|
||
* 输出参数:manager——发送管理器的更新结果。
|
||
* 返回值: 排空中的重复STOP返回IGNORED;
|
||
* 说明:排空中的重复STOP返回IGNORED;控制队列满也可受理STOP,不暂存相反请求。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Slave_Handle_Stopdt_Act(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation, const IEC104_ApciInfo_t *apci)
|
||
{
|
||
IEC104_LinkResult_t result;
|
||
if (apci == NULL || apci->frame_type != IEC104_FRAME_TYPE_U || apci->u_function != IEC104_U_STOPDT_ACT ||
|
||
!Manager_Session_Valid(manager, connection_generation)) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
result = IEC104_Link_Handle_Stopdt_Act(manager->link_state, apci);
|
||
if (result == IEC104_LINK_RESULT_OK) {
|
||
if (IEC104_AsduQueue_Reset_High(manager->asdu_queue, connection_generation) != IEC104_ASDU_QUEUE_OK) {
|
||
return IEC104_SEND_MANAGER_FATAL;
|
||
}
|
||
return IEC104_SEND_MANAGER_OK;
|
||
}
|
||
return result == IEC104_LINK_RESULT_IGNORED ? IEC104_SEND_MANAGER_IGNORED : IEC104_SEND_MANAGER_FATAL;
|
||
}
|
||
|
||
/**
|
||
* 功能:为STOP排队S或CON;stop_con_id仅在STOP_CON成功入队时写出,S/等待/失败不修改。
|
||
* 输入参数:manager——发送管理器。
|
||
* connection_generation——连接代次。
|
||
* now_ms——当前单调毫秒时刻。
|
||
* stop_con_id——身份编号。
|
||
* 输出参数:manager——发送管理器的更新结果。
|
||
* stop_con_id——身份编号的更新结果。
|
||
* 返回值:按处理分支返回result、IEC104_SEND_MANAGER_FATAL、Cancel_Control_Reservation(manager, &reservation, result)。
|
||
* 说明:Connection用该帧身份结束本轮STOP总计时,旧CON完成不能结束后续STOP的期限。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Slave_Queue_Stopdt_Response(
|
||
IEC104_SendManager_t *manager, uint64_t connection_generation, uint64_t now_ms,
|
||
IEC104_SendFrameId_t *stop_con_id)
|
||
{
|
||
IEC104_SendBufferReservation_t reservation;
|
||
IEC104_SendManagerResult_t result = Reserve_Control_Frame(manager, connection_generation, &reservation);
|
||
IEC104_StopdtPrepareResult_t prepared;
|
||
IEC104_StopdtTx_t tx;
|
||
|
||
if (result != IEC104_SEND_MANAGER_OK) {
|
||
return result;
|
||
}
|
||
prepared = IEC104_Link_Prepare_Stopdt_Response(manager->link_state, reservation.apdu,
|
||
reservation.apdu_capacity, &tx);
|
||
switch (prepared) {
|
||
case IEC104_STOPDT_FRAME_READY:
|
||
if (tx.frame_length != IEC104_APCI_LEN ||
|
||
(tx.frame_type != IEC104_STOPDT_FRAME_S_ACK && tx.frame_type != IEC104_STOPDT_FRAME_CON)) {
|
||
return IEC104_SEND_MANAGER_FATAL;
|
||
}
|
||
result = Commit_Control_Frame(manager, &reservation,
|
||
tx.frame_type == IEC104_STOPDT_FRAME_S_ACK ? IEC104_SEND_BUFFER_FRAME_S_ACK :
|
||
IEC104_SEND_BUFFER_FRAME_STOPDT_CON, now_ms);
|
||
if (result == IEC104_SEND_MANAGER_QUEUED && tx.frame_type == IEC104_STOPDT_FRAME_CON &&
|
||
stop_con_id != NULL) {
|
||
*stop_con_id = reservation.frame_id;
|
||
}
|
||
return result;
|
||
case IEC104_STOPDT_NOT_ACTIVE:
|
||
result = IEC104_SEND_MANAGER_EMPTY;
|
||
break;
|
||
case IEC104_STOPDT_WAIT_SEND:
|
||
case IEC104_STOPDT_WAIT_PEER_ACK:
|
||
result = IEC104_SEND_MANAGER_WAIT;
|
||
break;
|
||
default:
|
||
result = IEC104_SEND_MANAGER_ERROR;
|
||
break;
|
||
}
|
||
return Cancel_Control_Reservation(manager, &reservation, result);
|
||
}
|
||
|
||
|
||
|
||
/* ==================== 子站初始化 ==================== */
|
||
|
||
/**
|
||
* 功能:绑定子站新连接的业务队列、发送队列、链路状态和业务记录数组。
|
||
* 输入参数:asdu_queue——已初始化或Rebind的业务队列;允许非空,但不能有保留或已覆盖的待确认条目。
|
||
* send_buffer——已初始化的发送缓冲,须与业务队列同代次且无当前I帧、控制帧或预留。
|
||
* link_state——已按CONTROLLED角色State_Init的初始链路,序号为0,各过程空闲。
|
||
* records——调用方持有的固定存储记录数组;帧身份只存frame_serial,共用Manager代次。
|
||
* record_capacity——记录容量,范围1..32767。
|
||
* send_window_k——未确认I帧窗口上限,范围1..32767。
|
||
* high_priority_burst_limit——0表示严格高优先;非0限制NORMAL有未提交条目时连续HIGH交接次数。
|
||
* 输出参数:manager——仅成功时整体写入绑定结果;asdu_queue——成功时清空HIGH未提交条目,保留NORMAL;ERROR均不修改。
|
||
* 返回值:OK表示初始化成功;ERROR表示参数或初始状态非法。
|
||
* 说明:所有对象不得重叠,须持续有效且按连接串行访问;不清零records数组。
|
||
* 绑定后I帧由Prepare_Next_Send或Submit_Response统一准备,I/S接收经Handle_I_S_Frame,发送进度经Handle_Send_Progress提交。
|
||
* S/TESTFR及子站启停由本模块封装构帧入队,完成结果直接提交对应Link接口。
|
||
* 不接管运行中的连接,不创建TCP、线程或定时器。
|
||
* 发送缓冲空闲及链路初始状态由各模块查询判断;查询成功后核对Link的固定角色配置。
|
||
* 非CONTROLLED链路返回ERROR;初始化后不得改写Link角色或绑定对象。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Init(
|
||
IEC104_SendManager_t *manager, IEC104_AsduQueue_t *asdu_queue,
|
||
IEC104_SendBuffer_t *send_buffer, IEC104_LinkState_t *link_state,
|
||
IEC104_IFrameSendRecordStorage_t *records, uint16_t record_capacity,
|
||
uint16_t send_window_k, uint16_t high_priority_burst_limit)
|
||
{
|
||
IEC104_SendManager_t prepared;
|
||
IEC104_LinkStatus_t link_status;
|
||
IEC104_AsduQueueStatus_t asdu_status;
|
||
IEC104_SendBufferStatus_t buffer_status;
|
||
|
||
if (manager == NULL || records == NULL || record_capacity == 0U ||
|
||
record_capacity > IEC104_SEQUENCE_MASK || send_window_k == 0U || send_window_k > IEC104_SEQUENCE_MASK ||
|
||
IEC104_Link_Is_Initial_State(link_state) != 1 || IEC104_Link_Get_Status(link_state, &link_status) != 1 ||
|
||
link_status.role != IEC104_ROLE_CONTROLLED ||
|
||
IEC104_AsduQueue_Get_Status(asdu_queue, &asdu_status) != IEC104_ASDU_QUEUE_OK ||
|
||
IEC104_SendBuffer_Get_Status(send_buffer, &buffer_status) != IEC104_SEND_BUFFER_OK ||
|
||
asdu_status.connection_generation != buffer_status.connection_generation ||
|
||
asdu_status.retained_unacked_count[IEC104_ASDU_PRIORITY_HIGH] != 0U ||
|
||
asdu_status.retained_unacked_count[IEC104_ASDU_PRIORITY_NORMAL] != 0U ||
|
||
asdu_status.overwritten_unacked_count != 0U || buffer_status.is_idle != 1U) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
memset(&prepared, 0, sizeof(prepared));
|
||
prepared.asdu_queue = asdu_queue;
|
||
prepared.send_buffer = send_buffer;
|
||
prepared.link_state = link_state;
|
||
prepared.records = records;
|
||
prepared.record_capacity = record_capacity;
|
||
prepared.send_window_k = send_window_k;
|
||
prepared.high_priority_burst_limit = high_priority_burst_limit;
|
||
prepared.connection_generation = buffer_status.connection_generation;
|
||
prepared.is_initialized = 1U;
|
||
if (IEC104_AsduQueue_Reset_High(asdu_queue, prepared.connection_generation) != IEC104_ASDU_QUEUE_OK) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
*manager = prepared;
|
||
return IEC104_SEND_MANAGER_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能:先完成所有可失败的校验和HIGH清理,再向最终地址提交;不读取旧目标对象的未初始化内容。
|
||
* 输入参数:manager——发送管理器。
|
||
* asdu_queue——ASDU队列。
|
||
* send_buffer——发送缓冲。
|
||
* link_state——链路状态。
|
||
* control_frames——控制帧存储。
|
||
* control_capacity——控制帧容量。
|
||
* records——记录存储。
|
||
* record_capacity——发送记录容量。
|
||
* send_window_k——发送窗口K。
|
||
* high_priority_burst_limit——uint16_t值。
|
||
* connection_generation——连接代次。
|
||
* 输出参数:manager——发送管理器的更新结果。
|
||
* asdu_queue——ASDU队列的更新结果。
|
||
* send_buffer——发送缓冲的更新结果。
|
||
* link_state——链路状态的更新结果。
|
||
* 返回值:按处理分支返回IEC104_SEND_MANAGER_ERROR、IEC104_SEND_MANAGER_OK。
|
||
* 说明:绑定关系只在Manager内部建立,不提供对运行会话重新绑定指针的入口。
|
||
*/
|
||
IEC104_SendManagerResult_t IEC104_SendManager_Init_Connection(
|
||
IEC104_SendManager_t *manager, IEC104_AsduQueue_t *asdu_queue,
|
||
IEC104_SendBuffer_t *send_buffer, IEC104_LinkState_t *link_state,
|
||
IEC104_SendBufferControlFrame_t *control_frames, uint16_t control_capacity,
|
||
IEC104_IFrameSendRecordStorage_t *records, uint16_t record_capacity,
|
||
uint16_t send_window_k, uint16_t high_priority_burst_limit, uint64_t connection_generation)
|
||
{
|
||
IEC104_SendManager_t prepared;
|
||
IEC104_LinkState_t prepared_link;
|
||
IEC104_SendBuffer_t prepared_buffer;
|
||
|
||
if (manager == NULL || send_buffer == NULL || link_state == NULL ||
|
||
IEC104_Link_State_Init(&prepared_link, IEC104_ROLE_CONTROLLED) != 1 ||
|
||
IEC104_SendBuffer_Init(&prepared_buffer, control_frames, control_capacity, connection_generation) !=
|
||
IEC104_SEND_BUFFER_OK ||
|
||
IEC104_SendManager_Init(&prepared, asdu_queue, &prepared_buffer, &prepared_link, records, record_capacity,
|
||
send_window_k, high_priority_burst_limit) != IEC104_SEND_MANAGER_OK) {
|
||
return IEC104_SEND_MANAGER_ERROR;
|
||
}
|
||
*link_state = prepared_link;
|
||
*send_buffer = prepared_buffer;
|
||
prepared.link_state = link_state;
|
||
prepared.send_buffer = send_buffer;
|
||
*manager = prepared;
|
||
return IEC104_SEND_MANAGER_OK;
|
||
}
|