493 lines
28 KiB
C
493 lines
28 KiB
C
/* IEC104参数多主站示例:两个独立Slave/启动/总召/参数实例,共用设备唯一的点表与运行值数组。
|
|
* 以IEC104_TCP_SERVER_CAPACITY=2构建;全部实例调用、总召取值和参数写入在本线程串行执行。
|
|
* 默认只开标准服务,扩展全部关闭;未创建周期扫描,113的QPA=3由动作返回未知对象。
|
|
* 本例演示配置装载与读回,不实现测量算法或持久化;单个连接STOP/断开不清空共享运行值。
|
|
* 每端按统一细则配置独立完成Type70及真实全站总召,严格业务轮保证候选优先级。
|
|
* 每个实例的确认独立FIFO;已固定的旧确认不随另一个主站的写入刷新,不提供跨实例快照。
|
|
*/
|
|
#include "IEC104_Parameter.h"
|
|
#include "IEC104_GeneralInterrogation.h"
|
|
#include "IEC104_Startup.h"
|
|
#include "IEC104_Net.h"
|
|
#include "iec104_example_points.h"
|
|
#include <errno.h>
|
|
#include <signal.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#define PARAMETER_COUNT 32U
|
|
#define MEASUREMENT_COUNT 8U
|
|
#define ENDPOINT_WORK_BUDGET 32U
|
|
|
|
/* 每端独占协议状态和站点节点;相同CA并不共享连接代次、请求队列或站点注册身份。 */
|
|
typedef struct {
|
|
IEC104_Slave_t *slave;
|
|
IEC104_Station_t station;
|
|
IEC104_Parameter_t *parameter;
|
|
IEC104_Interrogation_t *gi;
|
|
IEC104_SystemCommand_t *system;
|
|
IEC104_SystemCommandStatus_t system_status; /* 同一端复用查询工作区,不保存ASDU。 */
|
|
IEC104_Startup_t startup; /* 每端拥有自己的轮次、站集合锁和放行事实。 */
|
|
IEC104_InterrogationEvent_t gi_event; /* WAIT期间保留原取数事件及其batch_index。 */
|
|
bool gi_pending; /* 尚有业务事件待应答;不表示网络已发送或主站已确认。 */
|
|
} Endpoint;
|
|
|
|
static IEC104_ParameterPoint_t points[PARAMETER_COUNT]; /* 两实例借用;初始化后只读至二者销毁。 */
|
|
/* 同一行以实际执行action的先后次序为准,不按两个连接的报文到达时间排序。
|
|
* 单线程串行调用使校验和写入之间无其他写者;若移植为多线程,须把二者作为同一临界操作。 */
|
|
static IEC104_ParameterValue_t values[PARAMETER_COUNT]; /* 与点表逐行对应;两主站和总召共用运行值。 */
|
|
static volatile sig_atomic_t stopping;
|
|
|
|
/**
|
|
* 功能:信号处理只登记退出请求;资源归还和协议清理由main在线程正常上下文中完成。
|
|
* 输入参数:signum——运行库传入的信号编号。
|
|
* 输出参数:无独立输出参数。
|
|
* 返回值:无。
|
|
* 说明:无。
|
|
*/
|
|
static void stop(int signum) { (void)signum; stopping = 1; }
|
|
|
|
/**
|
|
* 功能:在任一模块借用前初始化一次,随后仅运行值可写。
|
|
* 输入参数:无。
|
|
* 输出参数:无独立输出参数。
|
|
* 返回值:无。
|
|
* 说明:沿用公共点表的十六进制参数分区;门限、下限、上限、平滑依次各占8行,组间隔0x10。
|
|
* 实际IOA按(CA, IOA)严格升序;index % 8关联同一遥测的四类参数。
|
|
* 前四个门限及上下限用111,后四个比例门限用110,平滑时间常数用112;
|
|
* 静态数组的零初值给出门限0和不滤波,下限/上限另设为-10000/10000。
|
|
*/
|
|
static void init_values(void)
|
|
{
|
|
static const uint8_t kinds[] = {IEC60870_ASDU_KPA_THRESHOLD, IEC60870_ASDU_KPA_LOW_LIMIT,
|
|
IEC60870_ASDU_KPA_HIGH_LIMIT, IEC60870_ASDU_KPA_SMOOTHING};
|
|
size_t index;
|
|
for (index = 0U; index < PARAMETER_COUNT; ++index) {
|
|
size_t group = index / MEASUREMENT_COUNT;
|
|
size_t measurement = index % MEASUREMENT_COUNT;
|
|
points[index].common_address = 1U;
|
|
points[index].ioa = (uint32_t)(EXAMPLE_IOA_PARAMETER_BASE + group * EXAMPLE_IOA_PARAMETER_STRIDE + measurement);
|
|
points[index].kind = kinds[group];
|
|
points[index].type_id = group == 3U ? IEC60870_ASDU_P_ME_NC_1 :
|
|
(group == 0U && measurement >= 4U ? IEC60870_ASDU_P_ME_NA_1 : IEC60870_ASDU_P_ME_NB_1);
|
|
if (group == 1U) { values[index].scaled = -10000; }
|
|
if (group == 2U) { values[index].scaled = 10000; }
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 功能:同步完成业务值域检查与运行值更新,另一端动作和总召只会在本次返回后读取。
|
|
* 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求。
|
|
* 输出参数:无独立输出参数。
|
|
* 返回值:APPLIED表示运行值已应用,UNKNOWN_IOA表示请求目标不支持,REJECTED表示状态或业务值域不允许。
|
|
* 说明:110..112合法TEST由模块直接形成带运行值的确认,不进入此动作;113的TEST仍可到达,
|
|
* 本例没有周期对象,真实/TEST都返回UNKNOWN_IOA且不写状态。
|
|
* 默认模式仅接收EXECUTE;本例未提供PREPARE预留、COMMIT/ABORT收尾,不能直接开启ACK扩展。
|
|
*/
|
|
static IEC104_ParameterActionResult_t action(void *context, const IEC104_ParameterRequest_t *request)
|
|
{
|
|
Endpoint *endpoint = context;
|
|
size_t measurement = request->point_index % MEASUREMENT_COUNT;
|
|
/* 按受理时的注册编号核对原站;同CA后来重注册的站点不能接管旧请求。 */
|
|
if (IEC104_Slave_Get_Station_By_Id(endpoint->slave, request->station_id) != &endpoint->station ||
|
|
!IEC104_Station_Is_Registered(&endpoint->station) || request->phase != IEC104_PARAMETER_PHASE_EXECUTE) {
|
|
return IEC104_PARAMETER_ACTION_REJECTED;
|
|
}
|
|
if (request->operation != IEC104_PARAMETER_OP_LOAD) { return IEC104_PARAMETER_ACTION_UNKNOWN_IOA; }
|
|
if (request->point_index >= PARAMETER_COUNT) { return IEC104_PARAMETER_ACTION_REJECTED; }
|
|
switch (request->kind) {
|
|
case IEC60870_ASDU_KPA_THRESHOLD:
|
|
if ((request->type_id == IEC60870_ASDU_P_ME_NA_1 && request->value.normalized < 0) ||
|
|
(request->type_id == IEC60870_ASDU_P_ME_NB_1 && request->value.scaled < 0)) {
|
|
return IEC104_PARAMETER_ACTION_REJECTED;
|
|
}
|
|
break;
|
|
case IEC60870_ASDU_KPA_SMOOTHING:
|
|
if (request->value.short_float < 0.0f || request->value.short_float > 60.0f) {
|
|
return IEC104_PARAMETER_ACTION_REJECTED;
|
|
}
|
|
break;
|
|
/* 上下限与设备当前运行值比较,另一主站刚完成的修改也立即参与本次校验。
|
|
* 所以向上平移区间须先装上限,向下平移须先装下限;拒绝时运行值保持不变。 */
|
|
case IEC60870_ASDU_KPA_LOW_LIMIT:
|
|
if (request->value.scaled < -10000 || request->value.scaled > 10000 ||
|
|
request->value.scaled > values[2U * MEASUREMENT_COUNT + measurement].scaled) {
|
|
return IEC104_PARAMETER_ACTION_REJECTED;
|
|
}
|
|
break;
|
|
case IEC60870_ASDU_KPA_HIGH_LIMIT:
|
|
if (request->value.scaled < -10000 || request->value.scaled > 10000 ||
|
|
request->value.scaled < values[MEASUREMENT_COUNT + measurement].scaled) {
|
|
return IEC104_PARAMETER_ACTION_REJECTED;
|
|
}
|
|
break;
|
|
default: return IEC104_PARAMETER_ACTION_REJECTED;
|
|
}
|
|
/* APPLIED承诺运行值已生效;模块在返回后读取此数组形成确认,总召也读取同一份值。
|
|
* 本例未启用ACK后生效,确认丢失或随后断线都不会回滚这次写入。 */
|
|
values[request->point_index] = request->value;
|
|
return IEC104_PARAMETER_ACTION_APPLIED;
|
|
}
|
|
|
|
/**
|
|
* 功能:I帧由首个接手模块结束分派,HANDLED也包含否定或丢弃;只有IGNORED才走44兜底。
|
|
* 输入参数:endpoint——当前监听端及其业务模块;event——本轮借用的协议事件。
|
|
* 输出参数:无独立输出参数。
|
|
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
|
* 说明:生命周期按原FIFO交给协调器及全部业务模块;ERROR不可当未知类型处理。
|
|
* reset_data只清本端的应用工作事件,另一连接的参数运行值和启动进度不受影响。
|
|
*/
|
|
static bool dispatch(Endpoint *endpoint, const IEC104_SlaveEvent_t *event)
|
|
{
|
|
bool reset_data, started;
|
|
IEC104_SystemCommandEventResult_t system;
|
|
IEC104_InterrogationEventResult_t gi;
|
|
IEC104_ParameterEventResult_t parameter;
|
|
started = IEC104_Startup_Handle_Event(&endpoint->startup, endpoint->slave, event, &reset_data);
|
|
if (reset_data) { endpoint->gi_pending = false; }
|
|
if (!started) { return false; }
|
|
system = IEC104_SystemCommand_Handle_Event(endpoint->system, event);
|
|
if (system == IEC104_SYSTEM_COMMAND_EVENT_ERROR) { return false; }
|
|
if (event->transport.type == IEC104_TCP_EVENT_I_FRAME && system == IEC104_SYSTEM_COMMAND_EVENT_HANDLED) {
|
|
return true;
|
|
}
|
|
gi = IEC104_Interrogation_Handle_Event(endpoint->gi, event);
|
|
if (gi == IEC104_INTERROGATION_EVENT_ERROR) { return false; }
|
|
if (event->transport.type == IEC104_TCP_EVENT_I_FRAME && gi == IEC104_INTERROGATION_EVENT_HANDLED) {
|
|
return true;
|
|
}
|
|
parameter = IEC104_Parameter_Handle_Event(endpoint->parameter, event);
|
|
if (parameter == IEC104_PARAMETER_EVENT_ERROR) { return false; }
|
|
if (event->transport.type == IEC104_TCP_EVENT_I_FRAME && parameter == IEC104_PARAMETER_EVENT_IGNORED) {
|
|
IEC104_TcpSubmitResult_t result = IEC104_Slave_Reject_Request(endpoint->slave, event,
|
|
IEC60870_ASDU_COT_UNKNOWN_TYPE);
|
|
return result != IEC104_TCP_SUBMIT_ERROR && result != IEC104_TCP_SUBMIT_FATAL;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* 功能:按Slave原FIFO读空通知后再执行动作,避免越过未分派的STOP。
|
|
* 输入参数:endpoint——当前监听端及其业务模块;closing——是否只处理关闭收尾通知。
|
|
* 输出参数:无独立输出参数。
|
|
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
|
* 说明:closing时只分派生命周期通知,不在取消/关闭过程中重新受理残留I帧。
|
|
*/
|
|
static bool drain(Endpoint *endpoint, bool closing)
|
|
{
|
|
IEC104_SlaveEvent_t event;
|
|
IEC104_TcpEventResult_t next;
|
|
while ((next = IEC104_Slave_NextEvent(endpoint->slave, &event)) == IEC104_TCP_EVENT_READY) {
|
|
if ((!closing || event.transport.type != IEC104_TCP_EVENT_I_FRAME) && !dispatch(endpoint, &event)) {
|
|
return false;
|
|
}
|
|
}
|
|
return next == IEC104_TCP_EVENT_EMPTY;
|
|
}
|
|
|
|
/**
|
|
* 功能:每端独立推进站总召,32个参数各占一个SQ=0批次,batch_index直接用作点表下标。
|
|
* 输入参数:endpoint——当前监听端及其业务模块。
|
|
* 输出参数:endpoint——本次操作更新的实例或工作区。
|
|
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
|
* 说明:参数类型切换处也立即结束本批,不依赖Add返回FULL;跨类型Add会先返回ERROR。
|
|
* Submit_Batch成功后库才推进batch_index;WAIT保留原事件,下轮仍组该行并重读当前值。
|
|
* 运行值不做整轮快照,另一主站在批次之间成功装载后,后续批次可读到新值。
|
|
*/
|
|
static bool gi_step(Endpoint *endpoint)
|
|
{
|
|
IEC104_InterrogationEvent_t *event = &endpoint->gi_event;
|
|
IEC104_InterrogationReplyResult_t result;
|
|
if (!endpoint->gi_pending) {
|
|
IEC104_InterrogationNextResult_t next = IEC104_Interrogation_NextEvent(endpoint->gi, event);
|
|
if (next == IEC104_INTERROGATION_NEXT_ERROR) { return false; }
|
|
if (next == IEC104_INTERROGATION_NEXT_EMPTY) { return true; }
|
|
endpoint->gi_pending = true;
|
|
}
|
|
if (event->type == IEC104_INTERROGATION_FINISHED) {
|
|
IEC104_TcpSubmitResult_t observed = IEC104_Startup_Observe_General(
|
|
&endpoint->startup, endpoint->slave, event, false);
|
|
if (observed == IEC104_TCP_SUBMIT_WAIT) { return true; }
|
|
if (observed != IEC104_TCP_SUBMIT_OK) { return false; }
|
|
endpoint->gi_pending = false;
|
|
return true;
|
|
}
|
|
if (event->type == IEC104_INTERROGATION_BEGIN) {
|
|
bool accepted = event->request.qualifier == 20U;
|
|
IEC104_TcpSubmitResult_t observed = IEC104_Startup_Observe_General(
|
|
&endpoint->startup, endpoint->slave, event, accepted);
|
|
if (observed == IEC104_TCP_SUBMIT_WAIT) { return true; }
|
|
if (observed != IEC104_TCP_SUBMIT_OK) { return false; }
|
|
result = IEC104_Interrogation_Reply_Begin(endpoint->gi, event, accepted);
|
|
} else if (event->batch_index == PARAMETER_COUNT) {
|
|
result = IEC104_Interrogation_Complete_Data(endpoint->gi, event);
|
|
} else {
|
|
size_t index = event->batch_index;
|
|
IEC60870_Asdu_t batch;
|
|
IEC60870_AsduHeader_t header = {0};
|
|
IEC60870_AsduResult_t added;
|
|
uint8_t bytes[14];
|
|
if (index >= PARAMETER_COUNT) { return false; }
|
|
header.common_address = event->request.common_address;
|
|
header.originator_address = event->request.originator_address;
|
|
header.cause_of_transmission = event->request.data_cause;
|
|
header.is_test = event->request.is_test;
|
|
if (IEC60870_Asdu_Create(&batch, IEC104_Slave_Get_Application_Layer_Parameters(endpoint->slave),
|
|
bytes, sizeof(bytes), &header, 0) != IEC60870_ASDU_OK) { return false; }
|
|
/* QPM只设置KPA,示例不使用LPC/POP,均保持0;112有限值由装载校验与初值保证。 */
|
|
if (points[index].type_id == IEC60870_ASDU_P_ME_NA_1) {
|
|
IEC60870_ParameterNormalizedValue_t object;
|
|
if (IEC60870_ParameterNormalizedValue_Create(&object, points[index].ioa,
|
|
values[index].normalized, points[index].kind) != IEC60870_ASDU_OK) { return false; }
|
|
added = IEC60870_Asdu_Add_InformationObject(&batch, &object.object);
|
|
} else if (points[index].type_id == IEC60870_ASDU_P_ME_NB_1) {
|
|
IEC60870_ParameterScaledValue_t object;
|
|
if (IEC60870_ParameterScaledValue_Create(&object, points[index].ioa,
|
|
values[index].scaled, points[index].kind) != IEC60870_ASDU_OK) { return false; }
|
|
added = IEC60870_Asdu_Add_InformationObject(&batch, &object.object);
|
|
} else {
|
|
IEC60870_ParameterFloatValue_t object;
|
|
if (IEC60870_ParameterFloatValue_Create(&object, points[index].ioa,
|
|
values[index].short_float, points[index].kind) != IEC60870_ASDU_OK) { return false; }
|
|
added = IEC60870_Asdu_Add_InformationObject(&batch, &object.object);
|
|
}
|
|
if (added != IEC60870_ASDU_OK) { return false; }
|
|
result = IEC104_Interrogation_Submit_Batch(endpoint->gi, event, &batch);
|
|
}
|
|
if (result == IEC104_INTERROGATION_REPLY_ERROR) { return false; }
|
|
if (result != IEC104_INTERROGATION_REPLY_WAIT) { endpoint->gi_pending = false; }
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* 功能:两端借用同一存储但各自绑定Slave与CA=1节点;所有业务模块须早于首条通知创建。
|
|
* 输入参数:endpoint——当前监听端及其业务模块;port——TCP监听端口;number——示例端点编号。
|
|
* 输出参数:endpoint——本次操作更新的实例或工作区。
|
|
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
|
* 说明:任一步失败由main统一调用destroy_endpoint,已建立的另一端也走相同清理路径。
|
|
*/
|
|
static bool init_endpoint(Endpoint *endpoint, uint16_t port, unsigned number)
|
|
{
|
|
IEC104_SlaveConfig_t transport;
|
|
IEC104_ParameterConfig_t parameter;
|
|
IEC104_InterrogationConfig_t gi;
|
|
IEC104_SystemCommandConfig_t system;
|
|
IEC104_TcpServerStatus_t status;
|
|
endpoint->slave = IEC104_Slave_Create();
|
|
if (endpoint->slave == NULL || IEC104_Slave_Add_Station(endpoint->slave, &endpoint->station,
|
|
1U, endpoint) != IEC104_STATION_OK) { return false; }
|
|
IEC104_Parameter_Config_Default(¶meter);
|
|
parameter.points = points; parameter.point_count = PARAMETER_COUNT; parameter.values = values;
|
|
endpoint->parameter = IEC104_Parameter_Create(endpoint->slave, ¶meter);
|
|
IEC104_Startup_Config_Default(&transport, &system, &gi, NULL, NULL);
|
|
/* 本示例仅接初始化,不提供复位动作或事件清除的应用后端。 */
|
|
system.features = IEC104_SYSTEM_COMMAND_FEATURE_INIT_END;
|
|
endpoint->system = IEC104_SystemCommand_Create(endpoint->slave, &system);
|
|
IEC104_Startup_Init(&endpoint->startup);
|
|
endpoint->gi = IEC104_Interrogation_Create(endpoint->slave, &gi);
|
|
if (endpoint->parameter == NULL || endpoint->gi == NULL || endpoint->system == NULL) { return false; }
|
|
strcpy(transport.bind_address, "127.0.0.1"); transport.port = port;
|
|
if (IEC104_Slave_Init(endpoint->slave, &transport, NULL) != IEC104_TCP_OK ||
|
|
IEC104_Slave_Get_Status(endpoint->slave, &status, NULL) != IEC104_TCP_OK ||
|
|
!IEC104_SystemCommand_Set_Initialization(endpoint->system, 0U)) { return false; }
|
|
printf("LISTEN %u 127.0.0.1:%u CA=1\n", number, (unsigned)status.bound_port); fflush(stdout);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* 功能:有界准备总召候选;初始化未交接时只推进协议期限,不领取应用工作事件。
|
|
* 输入参数:endpoint——本端协议及启动状态。
|
|
* 返回值:true本轮正常(含等待),false必须统一收尾。
|
|
* 说明:预算耗尽登记未准备候选的真实等级,防止下一帧越过初始化总召;WAIT不原地重试。
|
|
*/
|
|
static bool prepare_gi(Endpoint *endpoint)
|
|
{
|
|
unsigned round;
|
|
for (round = 0U; round < ENDPOINT_WORK_BUDGET; ++round) {
|
|
IEC104_InterrogationStatus_t status;
|
|
if (!IEC104_Interrogation_Process(endpoint->gi)) { return false; }
|
|
if (!IEC104_Startup_Can_Consume_General(&endpoint->startup)) { return true; }
|
|
if (!gi_step(endpoint) || !IEC104_Interrogation_Get_Status(endpoint->gi, &status)) { return false; }
|
|
if (endpoint->gi_pending || status.waiting || status.data_send_waiting ||
|
|
(!status.need_process && status.pending_events == 0U)) { return true; }
|
|
}
|
|
{
|
|
IEC104_BusinessPriority_t priority = IEC104_Interrogation_Get_Pending_Priority(endpoint->gi);
|
|
return priority == IEC104_BUSINESS_PRIORITY_NONE ||
|
|
IEC104_Slave_Set_Pending_Business_Priority(endpoint->slave, priority) == IEC104_TCP_SUBMIT_OK;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 功能:在命令等级内准备参数回复;只在模块明确execute_ready时执行下一次设备动作。
|
|
* 输入参数:endpoint——借用共享运行值的本端参数实例。
|
|
* 返回值:true包括发送背压,false表示协议或设备执行失败。
|
|
* 说明:预算只限制本地工作量;未执行完的就绪命令登记等级3,不预约网络窗口。
|
|
*/
|
|
static bool prepare_parameter(Endpoint *endpoint)
|
|
{
|
|
unsigned round;
|
|
IEC104_ParameterStatus_t status;
|
|
for (round = 0U; round < ENDPOINT_WORK_BUDGET; ++round) {
|
|
IEC104_ParameterExecuteResult_t executed;
|
|
if (!IEC104_Parameter_Process(endpoint->parameter) ||
|
|
!IEC104_Parameter_Get_Status(endpoint->parameter, &status)) { return false; }
|
|
if (!status.execute_ready) { return true; }
|
|
executed = IEC104_Parameter_Execute_Next(endpoint->parameter, action, endpoint);
|
|
if (executed == IEC104_PARAMETER_EXECUTE_ERROR ||
|
|
!IEC104_Parameter_Process(endpoint->parameter)) { return false; }
|
|
if (executed != IEC104_PARAMETER_EXECUTE_OK) { return true; }
|
|
}
|
|
if (!IEC104_Parameter_Get_Status(endpoint->parameter, &status)) { return false; }
|
|
return !status.execute_ready || IEC104_Slave_Set_Pending_Business_Priority(
|
|
endpoint->slave, IEC104_BUSINESS_PRIORITY_COMMAND) == IEC104_TCP_SUBMIT_OK;
|
|
}
|
|
|
|
/**
|
|
* 功能:单端按已支持业务的等级1、2、3、5递增准备候选,归还业务轮由调用者保证。
|
|
* 输入参数:endpoint——本端所有业务模块。
|
|
* 返回值:false由外层结束本轮后统一收尾。
|
|
* 说明:维护先转换期限,初始化与总召完成各检查一次;不暂停另一端运行值读写。
|
|
*/
|
|
static bool business_step(Endpoint *endpoint)
|
|
{
|
|
if (!IEC104_SystemCommand_Process(endpoint->system) || !IEC104_Parameter_Process(endpoint->parameter) ||
|
|
!IEC104_Interrogation_Process(endpoint->gi)) { return false; }
|
|
if (IEC104_Slave_Set_Business_Priority(endpoint->slave, IEC104_BUSINESS_PRIORITY_INITIALIZATION) !=
|
|
IEC104_TCP_SUBMIT_OK || !IEC104_SystemCommand_Process(endpoint->system) ||
|
|
!IEC104_Startup_Process(&endpoint->startup, endpoint->slave, endpoint->system, &endpoint->system_status)) {
|
|
return false;
|
|
}
|
|
if (IEC104_Slave_Set_Business_Priority(endpoint->slave, IEC104_BUSINESS_PRIORITY_INITIAL_INTERROGATION) !=
|
|
IEC104_TCP_SUBMIT_OK || !prepare_gi(endpoint) ||
|
|
!IEC104_Startup_Process(&endpoint->startup, endpoint->slave, endpoint->system, &endpoint->system_status)) {
|
|
return false;
|
|
}
|
|
if (IEC104_Slave_Set_Business_Priority(endpoint->slave, IEC104_BUSINESS_PRIORITY_COMMAND) !=
|
|
IEC104_TCP_SUBMIT_OK || !prepare_parameter(endpoint)) { return false; }
|
|
return IEC104_Slave_Set_Business_Priority(endpoint->slave, IEC104_BUSINESS_PRIORITY_INTERROGATION) ==
|
|
IEC104_TCP_SUBMIT_OK && prepare_gi(endpoint) &&
|
|
IEC104_Startup_Process(&endpoint->startup, endpoint->slave, endpoint->system, &endpoint->system_status);
|
|
}
|
|
|
|
/**
|
|
* 功能:单端有界推进:网络/通知读空 -> 严格业务轮 -> 初始化/总召放行检查。
|
|
* 输入参数:endpoint——当前监听端及其业务模块。
|
|
* 输出参数:endpoint——本次操作更新的实例或工作区。
|
|
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
|
* 说明:使用execute_ready判断零等待;初始化前待领取GI不能造成零等待空转。
|
|
* 每端最多等待5ms并按最近期限收紧,随后把运行机会交给另一端;等待不提供跨端快照。
|
|
*/
|
|
static bool step(Endpoint *endpoint)
|
|
{
|
|
IEC104_ParameterStatus_t parameter;
|
|
IEC104_InterrogationStatus_t gi;
|
|
IEC104_TcpSubmitResult_t cycle;
|
|
bool succeeded;
|
|
uint32_t wait = 5U;
|
|
if (!IEC104_Parameter_Get_Status(endpoint->parameter, ¶meter) ||
|
|
!IEC104_Interrogation_Get_Status(endpoint->gi, &gi) ||
|
|
!IEC104_SystemCommand_Get_Status(endpoint->system, &endpoint->system_status)) { return false; }
|
|
if (parameter.events_pending || parameter.execute_ready || parameter.need_process ||
|
|
endpoint->system_status.events_pending || endpoint->system_status.need_process || gi.events_pending ||
|
|
(IEC104_Startup_Can_Consume_General(&endpoint->startup) &&
|
|
(gi.pending_events || gi.need_process || endpoint->gi_pending))) { wait = 0U; }
|
|
if (parameter.timer_active && parameter.timeout_remaining_ms < wait) { wait = parameter.timeout_remaining_ms; }
|
|
if (gi.timer_active && gi.timeout_remaining_ms < wait) { wait = gi.timeout_remaining_ms; }
|
|
if (IEC104_Slave_Poll(endpoint->slave, wait, NULL) != IEC104_TCP_OK || !drain(endpoint, false)) { return false; }
|
|
cycle = IEC104_Slave_Begin_Business_Cycle(endpoint->slave);
|
|
if (cycle == IEC104_TCP_SUBMIT_WAIT) { return true; }
|
|
if (cycle != IEC104_TCP_SUBMIT_OK) { return false; }
|
|
succeeded = business_step(endpoint);
|
|
cycle = IEC104_Slave_End_Business_Cycle(endpoint->slave);
|
|
return succeeded && cycle == IEC104_TCP_SUBMIT_OK;
|
|
}
|
|
|
|
/**
|
|
* 功能:默认模式Cancel移除全部参数任务,之后关闭、读空收尾、销毁模块,再移除站点和Slave。
|
|
* 输入参数:endpoint——当前监听端及其业务模块。
|
|
* 输出参数:endpoint——本次操作更新的实例或工作区。
|
|
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
|
* 说明:本例无ACK准备;若扩展为ACK模式,Destroy前还须Execute_Next交付全部COMMIT/ABORT。
|
|
* 清理仅作用于本端协议状态,共用数组直到两个借用实例销毁后仍保持有效。
|
|
*/
|
|
static bool destroy_endpoint(Endpoint *endpoint)
|
|
{
|
|
bool result = true;
|
|
if (endpoint->slave == NULL) { return true; }
|
|
if (!IEC104_Startup_Reset(&endpoint->startup, endpoint->slave)) { result = false; }
|
|
endpoint->gi_pending = false;
|
|
if (endpoint->system != NULL) { IEC104_SystemCommand_Cancel(endpoint->system); }
|
|
if (endpoint->parameter != NULL) { IEC104_Parameter_Cancel(endpoint->parameter); }
|
|
if (endpoint->gi != NULL) { IEC104_Interrogation_Cancel(endpoint->gi); }
|
|
if (IEC104_Slave_Close(endpoint->slave, NULL) != IEC104_TCP_OK) { result = false; }
|
|
if (endpoint->parameter != NULL && endpoint->gi != NULL && endpoint->system != NULL &&
|
|
!drain(endpoint, true)) { result = false; }
|
|
else if (endpoint->parameter == NULL || endpoint->gi == NULL || endpoint->system == NULL) {
|
|
IEC104_SlaveEvent_t event;
|
|
while (IEC104_Slave_NextEvent(endpoint->slave, &event) == IEC104_TCP_EVENT_READY) {}
|
|
}
|
|
if (endpoint->gi != NULL) {
|
|
IEC104_InterrogationNextResult_t next;
|
|
endpoint->gi_pending = false;
|
|
while ((next = IEC104_Interrogation_NextEvent(endpoint->gi, &endpoint->gi_event)) == IEC104_INTERROGATION_NEXT_READY) {}
|
|
if (next != IEC104_INTERROGATION_NEXT_EMPTY || !IEC104_Interrogation_Destroy(endpoint->gi)) { result = false; }
|
|
}
|
|
if (endpoint->parameter != NULL && !IEC104_Parameter_Destroy(endpoint->parameter)) { result = false; }
|
|
if (endpoint->system != NULL && !IEC104_SystemCommand_Destroy(endpoint->system)) { result = false; }
|
|
if (IEC104_Station_Is_Registered(&endpoint->station) &&
|
|
IEC104_Slave_Remove_Station(endpoint->slave, &endpoint->station) != IEC104_STATION_OK) { result = false; }
|
|
if (IEC104_Slave_Destroy(endpoint->slave, NULL) != IEC104_TCP_OK) { result = false; }
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* 功能:一次初始化共享参数,顺序推进两个独立监听端;不创建并发写者或跨端锁。
|
|
* 输入参数:argc——命令行参数数量;argv——命令行参数数组。
|
|
* 输出参数:无独立输出参数。
|
|
* 返回值:0表示正常退出;非0表示参数、初始化、运行或清理失败。
|
|
* 说明:任一端运行错误结束整个示例,两个端点均尝试清理,便于回环测试发现资源遗留。
|
|
*/
|
|
int main(int argc, char **argv)
|
|
{
|
|
static Endpoint endpoints[2];
|
|
uint16_t ports[] = {2404U, 2405U};
|
|
uint64_t started;
|
|
unsigned long duration = 0U;
|
|
int argument, result = EXIT_SUCCESS;
|
|
for (argument = 1; argument < argc; ++argument) {
|
|
const char *option = argv[argument];
|
|
char *end;
|
|
unsigned long value;
|
|
if (strcmp(option, "--help") == 0) {
|
|
puts("Usage: iec104_parameter_multi_master [--port 2404] [--port2 2405] [--run-ms 0]\n"
|
|
"CA=1 on both loopback listeners. Type110..112 values are shared; standard Type113 returns47.\n"
|
|
"QOI20 returns 32 independent parameter objects. No extensions, scans or persistence.");
|
|
return EXIT_SUCCESS;
|
|
}
|
|
if (++argument == argc || argv[argument][0] == '-') { return EXIT_FAILURE; }
|
|
errno = 0; value = strtoul(argv[argument], &end, 10);
|
|
if (errno != 0 || *end != '\0' || end == argv[argument] || value > UINT32_MAX) { return EXIT_FAILURE; }
|
|
if (strcmp(option, "--port") == 0 && value <= UINT16_MAX) { ports[0] = (uint16_t)value; }
|
|
else if (strcmp(option, "--port2") == 0 && value <= UINT16_MAX) { ports[1] = (uint16_t)value; }
|
|
else if (strcmp(option, "--run-ms") == 0) { duration = value; }
|
|
else { return EXIT_FAILURE; }
|
|
}
|
|
init_values();
|
|
if (!init_endpoint(&endpoints[0], ports[0], 1U) || !init_endpoint(&endpoints[1], ports[1], 2U)) {
|
|
fputs("Initialization failed; build with IEC104_TCP_SERVER_CAPACITY=2.\n", stderr);
|
|
result = EXIT_FAILURE;
|
|
} else {
|
|
(void)signal(SIGINT, stop); (void)signal(SIGTERM, stop);
|
|
started = IEC104_Net_Now_Ms();
|
|
while (!stopping && (duration == 0U || IEC104_Net_Now_Ms() - started < duration)) {
|
|
if (!step(&endpoints[0]) || !step(&endpoints[1])) { result = EXIT_FAILURE; break; }
|
|
}
|
|
}
|
|
if (!destroy_endpoint(&endpoints[0])) { result = EXIT_FAILURE; }
|
|
if (!destroy_endpoint(&endpoints[1])) { result = EXIT_FAILURE; }
|
|
puts(result == EXIT_SUCCESS ? "STOP multi_master=ok" : "STOP multi_master=failed");
|
|
return result;
|
|
}
|