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

359 lines
20 KiB
C

/* 参数互操作测试子站:真实 TCP,启用 QPA=1/2、专用 QPA 和同址参数,ACK 模式可选。
* 参数依次为监听端口、ACK 模式 0/1、运行毫秒数;仅绑定本机回环,端口 0 自动分配。
* 导航:应用值/暂存/准备快照 -> 显式动作 -> 总召取值 -> 调度与退出收尾。
* 本程序只链接本项目协议栈;外部主站独立链接 lib60870-C。正式用法见 examples。 */
#include "iec104_test_config.h"
#include "IEC104_Parameter.h"
#include "IEC104_GeneralInterrogation.h"
#include "IEC104_PeriodicScan.h"
#include "IEC104_Net.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define VERIFY(x) do { if (!(x)) { fprintf(stderr, "%s:%d: %s\n", __func__, __LINE__, #x); exit(1); } } while (0)
#define POINT_COUNT 6U
/* 1001..1003 立即生效,2001/2002 装载后暂存;2001 两行按 KPA 区分。
* 3001 是周期遥测,4001 是专用 QPA=128 的测试对象,不在参数点表中。 */
static const IEC104_ParameterPoint_t points[POINT_COUNT] = {
{1,110,1,1001}, {1,111,1,1002}, {1,112,2,1003},
{1,111,1,2001}, {1,111,3,2001}, {1,112,2,2002}
};
static const IEC104_PeriodicScanPoint_t scan_points[] = {{1,11,1,3001}};
typedef struct {
IEC104_Slave_t *slave;
IEC104_Parameter_t *parameter;
IEC104_Interrogation_t *gi;
IEC104_PeriodicScan_t *scan;
IEC104_Station_t station;
/* 三份数组分别是已生效值、会话暂存和PREPARE冻结值;等待ACK时不能用暂存替代快照。 */
IEC104_ParameterValue_t values[POINT_COUNT], staged[POINT_COUNT], snapshot[POINT_COUNT];
uint64_t staged_instance, staged_generation, staged_station;
/* 位号对应点表行号;同一IOA的不同KPA仍各占一位,不能按IOA合并。 */
unsigned staged_mask, snapshot_mask, reserved_mask;
bool prepared, private_enabled, gi_pending;
IEC104_ParameterRequest_t preparation;
IEC104_InterrogationEvent_t gi_event;
uint32_t periods[1];
uint8_t retry[1];
} Interop;
/**
* 功能:暂存归属是模块实例、连接代次和站点注册身份。
* 输入参数:app——互操作子站应用状态(只读);r——当前参数请求(只读)。
* 输出参数:无。
* 返回值:true 表示暂存数据与请求的实例、连接代次和站点身份全部一致;否则 false。
* 说明:CA 相同不能证明仍是同一会话。
*/
static bool same_owner(const Interop *app, const IEC104_ParameterRequest_t *r)
{
return app->staged_instance == r->instance_id && app->staged_generation == r->generation &&
app->staged_station == r->station_id;
}
/**
* 功能:同一归属重复装载覆盖该行。
* 输入参数:app——互操作子站应用状态;r——当前参数请求(只读)。
* 输出参数:app——推进后的互操作应用状态。
* 返回值:无。
* 说明:新归属先废弃旧暂存,运行值不受影响。
*/
static void stage(Interop *app, const IEC104_ParameterRequest_t *r)
{
if (!same_owner(app, r)) app->staged_mask = 0;
app->staged_instance = r->instance_id;
app->staged_generation = r->generation;
app->staged_station = r->station_id;
app->staged[r->point_index] = r->value;
app->staged_mask |= 1U << r->point_index;
}
/**
* 功能:按参数类型校验互操作夹具值域:归一化非负、浮点0..60,下限参数允许负有标度值。
* 输入参数:r——当前参数请求(只读)。
* 输出参数:无。
* 返回值:true 表示当前类型、KPA 与数值组合符合测试业务约束;否则 false。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static bool valid_value(const IEC104_ParameterRequest_t *r)
{
/* 这里只验证互操作夹具约定的独立值域;不实现主示例的上下限配对或测量算法。 */
if (r->type_id == 110U) return r->value.normalized >= 0;
if (r->type_id == 112U) return r->value.short_float >= 0.0f && r->value.short_float <= 60.0f;
return r->kind == IEC60870_ASDU_KPA_LOW_LIMIT || r->value.scaled >= 0;
}
/**
* 功能:执行参数装载、准备、提交和撤销动作,维护运行值与周期扫描配置。
* 输入参数:context——业务回调的测试上下文;r——当前参数请求(只读)。
* 输出参数:无。
* 返回值:业务动作结果,保留应用成功、业务拒绝及未知对象等协议区别。
* 说明:测试子站单线程,每个值是独立约束组;所有写入均经过本动作,没有旁路写者。
* PREPARE 只固定候选和预留,运行值/周期设置到 COMMIT 才改变;ABORT 释放准备资源。
* QPA=1/2 的激活快照独立于会话暂存,STOP 清暂存不能删除已 ACK 准备的输入。
* 扫描表、恢复周期和组配置在此程序运行期间固定,满足 QPA=3 提交不能失败的契约。
*/
static IEC104_ParameterActionResult_t action(void *context, const IEC104_ParameterRequest_t *r)
{
Interop *app = context;
IEC104_ParameterActionResult_t result = IEC104_PARAMETER_ACTION_APPLIED;
unsigned mask = 0, i;
bool activate = r->operation == IEC104_PARAMETER_OP_ACTIVATE;
/* 已准备事务先按原身份收尾;会话结束或原站点删除后,仍不能跳过准备资源的释放。 */
if (r->phase == IEC104_PARAMETER_PHASE_COMMIT || r->phase == IEC104_PARAMETER_PHASE_ABORT) {
VERIFY(app->prepared && app->preparation.instance_id == r->instance_id &&
app->preparation.generation == r->generation && app->preparation.receive_serial == r->receive_serial);
if (r->phase == IEC104_PARAMETER_PHASE_COMMIT) {
if (r->operation == IEC104_PARAMETER_OP_LOAD) {
if (r->prepared == IEC104_PARAMETER_ACTION_STAGED) stage(app, r);
else app->values[r->point_index] = r->value;
} else if (r->qpa == IEC60870_ASDU_QPA_CYCLIC_TRANSMISSION) {
VERIFY(IEC104_PeriodicScan_Set_Point_Period(app->scan, 0U, activate ? 200U : 0U));
} else if (r->qpa >= 128U) app->private_enabled = activate;
else {
for (i = 0; i < POINT_COUNT; ++i) {
if (activate && (app->snapshot_mask & (1U << i))) app->values[i] = app->snapshot[i];
}
/* 只清原归属的暂存,不能误清后续连接建立的另一份暂存。 */
if (same_owner(app, r)) app->staged_mask &= ~app->snapshot_mask;
}
}
app->prepared = false;
app->snapshot_mask = app->reserved_mask = 0;
return IEC104_PARAMETER_ACTION_APPLIED;
}
if (!IEC104_Station_Is_Registered(IEC104_Slave_Get_Station_By_Id(app->slave, r->station_id)))
return IEC104_PARAMETER_ACTION_REJECTED;
if (r->operation == IEC104_PARAMETER_OP_LOAD) {
if (!valid_value(r)) return IEC104_PARAMETER_ACTION_REJECTED;
if (r->ioa >= 2000U) result = IEC104_PARAMETER_ACTION_STAGED;
else mask = 1U << r->point_index;
} else if (r->qpa == IEC60870_ASDU_QPA_CYCLIC_TRANSMISSION) {
IEC104_PeriodicScanGroupStatus_t group;
if (r->ioa != 3001U) return IEC104_PARAMETER_ACTION_UNKNOWN_IOA;
if (!IEC104_PeriodicScan_Get_Group_Status(app->scan, 0U, &group) ||
!group.point_period || (activate && (group.period_ms == 0U || 200U % group.period_ms != 0U)))
return IEC104_PARAMETER_ACTION_REJECTED;
} else if (r->qpa >= 128U) {
if (r->qpa != 128U || r->ioa != 4001U) return IEC104_PARAMETER_ACTION_UNKNOWN_IOA;
} else {
if (!same_owner(app, r)) return IEC104_PARAMETER_ACTION_REJECTED;
mask = app->staged_mask;
if (r->qpa == IEC60870_ASDU_QPA_ADDRESSED_OBJECT) {
unsigned addressed = 0;
for (i = 0; i < r->point_span; ++i) addressed |= 1U << (r->point_index + i);
mask &= addressed;
}
if (mask == 0U) return IEC104_PARAMETER_ACTION_REJECTED;
}
if (mask & app->reserved_mask) return IEC104_PARAMETER_ACTION_REJECTED;
/* 所有可拒绝条件都在取得准备资源之前检查,TEST 也在此返回且不预留。
* 否定 PREPARE 没有后续 ABORT;若以后把预留拆成多步,失败时须自行释放。 */
if (r->test) return result;
if (r->phase == IEC104_PARAMETER_PHASE_PREPARE) {
VERIFY(!app->prepared);
app->prepared = true;
app->preparation = *r;
/* STAGED 装载只进会话暂存,mask 为 0;真正激活时才预留所选行并固定快照。 */
app->reserved_mask = mask;
app->snapshot_mask = mask;
for (i = 0; i < POINT_COUNT; ++i) if (mask & (1U << i)) app->snapshot[i] = app->staged[i];
} else if (r->operation == IEC104_PARAMETER_OP_LOAD) {
if (result == IEC104_PARAMETER_ACTION_STAGED) stage(app, r);
else app->values[r->point_index] = r->value;
} else if (r->qpa == IEC60870_ASDU_QPA_CYCLIC_TRANSMISSION) {
if (!IEC104_PeriodicScan_Set_Point_Period(app->scan, 0U, activate ? 200U : 0U))
return IEC104_PARAMETER_ACTION_REJECTED;
} else if (r->qpa >= 128U) app->private_enabled = activate;
else {
for (i = 0; i < POINT_COUNT; ++i) if (activate && (mask & (1U << i))) app->values[i] = app->staged[i];
app->staged_mask &= ~mask;
}
return result;
}
/**
* 功能:向当前扫描ASDU追加请求IOA的固定有标度值123,构造或追加失败返回LOOKUP_ERROR。
* 输入参数:context——业务回调的测试上下文;request——当前业务请求(只读);asdu——ASDU 容器。
* 输出参数:asdu——构造、解析或追加完成的对象/ASDU。
* 返回值:查值结果,区分追加成功、结束/跳过、容量不足及失败。
* 说明:接口保留参数仍按回调签名传入,未使用的参数不参与本辅助函数的处理。
*/
static IEC104_PeriodicScanLookupResult_t lookup(void *context,
const IEC104_PeriodicScanRequest_t *request, IEC60870_Asdu_t *asdu)
{
IEC60870_MeasuredValueScaled_t object;
(void)context;
if (IEC60870_MeasuredValueScaled_Create(&object, request->ioa, 123, 0) != IEC60870_ASDU_OK ||
IEC60870_Asdu_Add_InformationObject(asdu, &object.object) != IEC60870_ASDU_OK)
return IEC104_PERIODIC_SCAN_LOOKUP_ERROR;
return IEC104_PERIODIC_SCAN_LOOKUP_ADDED;
}
/**
* 功能:生命周期通知广播给全部模块。
* 输入参数:app——互操作子站应用状态。
* 输出参数:app——推进后的互操作应用状态。
* 返回值:无。
* 说明:应用只清会话暂存,准备快照和预留留到收尾;
* 只有所有请求模块都返回 IGNORED 才使用 44 兜底,错误不能当作未接手。
*/
static void drain(Interop *app)
{
IEC104_SlaveEvent_t event;
IEC104_TcpEventResult_t next;
while ((next = IEC104_Slave_NextEvent(app->slave, &event)) == IEC104_TCP_EVENT_READY) {
IEC104_ParameterEventResult_t handled;
IEC104_InterrogationEventResult_t gi_handled;
if (event.transport.type == IEC104_TCP_EVENT_CONNECTED ||
event.transport.type == IEC104_TCP_EVENT_DEACTIVATED ||
event.transport.type == IEC104_TCP_EVENT_DISCONNECTED) app->staged_mask = 0;
handled = IEC104_Parameter_Handle_Event(app->parameter, &event);
VERIFY(handled != IEC104_PARAMETER_EVENT_ERROR);
gi_handled = IEC104_Interrogation_Handle_Event(app->gi, &event);
VERIFY(gi_handled != IEC104_INTERROGATION_EVENT_ERROR);
VERIFY(IEC104_PeriodicScan_Handle_Event(app->scan, &event) != IEC104_PERIODIC_SCAN_EVENT_ERROR);
if (event.transport.type == IEC104_TCP_EVENT_I_FRAME && handled == IEC104_PARAMETER_EVENT_IGNORED &&
gi_handled == IEC104_INTERROGATION_EVENT_IGNORED)
(void)IEC104_Slave_Reject_Request(app->slave, &event, IEC60870_ASDU_COT_UNKNOWN_TYPE);
}
VERIFY(next == IEC104_TCP_EVENT_EMPTY);
}
/**
* 功能:每次总召事件提交一行参数,混合类型和同址 KPA 都各自单帧。
* 输入参数:app——互操作子站应用状态。
* 输出参数:app——推进后的互操作应用状态。
* 返回值:无。
* 说明:WAIT 保留同一事件/批次下标,下一轮按当前运行值重新组包;只有提交成功才推进。
*/
static void gi_step(Interop *app)
{
IEC104_InterrogationNextResult_t next;
IEC104_InterrogationReplyResult_t result;
IEC104_InterrogationEvent_t *event = &app->gi_event;
if (!app->gi_pending) {
next = IEC104_Interrogation_NextEvent(app->gi, event);
VERIFY(next != IEC104_INTERROGATION_NEXT_ERROR);
if (next == IEC104_INTERROGATION_NEXT_EMPTY) return;
app->gi_pending = true;
}
if (event->type == IEC104_INTERROGATION_FINISHED) { app->gi_pending = false; return; }
if (event->type == IEC104_INTERROGATION_BEGIN) {
result = IEC104_Interrogation_Reply_Begin(app->gi, event, event->request.qualifier == 20U);
} else if (event->batch_index >= POINT_COUNT) {
result = IEC104_Interrogation_Complete_Data(app->gi, event);
} else {
size_t index = event->batch_index;
IEC60870_Asdu_t asdu;
IEC60870_AsduHeader_t header = {0};
uint8_t bytes[14];
IEC60870_AsduResult_t added;
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;
VERIFY(IEC60870_Asdu_Create(&asdu, IEC104_Slave_Get_Application_Layer_Parameters(app->slave),
bytes, sizeof(bytes), &header, 0) == IEC60870_ASDU_OK);
if (points[index].type_id == 110U) {
IEC60870_ParameterNormalizedValue_t object;
VERIFY(IEC60870_ParameterNormalizedValue_Create(&object, points[index].ioa,
app->values[index].normalized, points[index].kind) == IEC60870_ASDU_OK);
added = IEC60870_Asdu_Add_InformationObject(&asdu, &object.object);
} else if (points[index].type_id == 111U) {
IEC60870_ParameterScaledValue_t object;
VERIFY(IEC60870_ParameterScaledValue_Create(&object, points[index].ioa,
app->values[index].scaled, points[index].kind) == IEC60870_ASDU_OK);
added = IEC60870_Asdu_Add_InformationObject(&asdu, &object.object);
} else {
IEC60870_ParameterFloatValue_t object;
VERIFY(IEC60870_ParameterFloatValue_Create(&object, points[index].ioa,
app->values[index].short_float, points[index].kind) == IEC60870_ASDU_OK);
added = IEC60870_Asdu_Add_InformationObject(&asdu, &object.object);
}
VERIFY(added == IEC60870_ASDU_OK);
result = IEC104_Interrogation_Submit_Batch(app->gi, event, &asdu);
}
VERIFY(result != IEC104_INTERROGATION_REPLY_ERROR);
if (result != IEC104_INTERROGATION_REPLY_WAIT) app->gi_pending = false;
}
/**
* 功能:按端口、ACK模式及运行时长启动回环子站,串行驱动参数/总召/周期扫描并完成退出收尾。
* 输入参数:argc——命令行参数数量;argv——命令行参数数组。
* 输出参数:无。
* 返回值:正常完成返回 0;参数、运行或断言失败以非零状态结束进程。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
int main(int argc, char **argv)
{
static Interop app;
IEC104_SlaveConfig_t transport;
IEC104_ParameterConfig_t parameter;
IEC104_InterrogationConfig_t gi;
IEC104_PeriodicScanConfig_t scan;
IEC104_PeriodicScanGroupConfig_t group = {200,200,1,0,1};
IEC104_TcpServerStatus_t tcp;
IEC104_ParameterStatus_t status;
uint64_t started, duration = argc > 3 ? strtoull(argv[3], NULL, 10) : 30000U;
int ack = argc > 2 ? atoi(argv[2]) : 1;
VERIFY(argc >= 2 && (ack == 0 || ack == 1));
test_transport_config(&transport);
strcpy(transport.bind_address, "127.0.0.1"); transport.port = (uint16_t)strtoul(argv[1], NULL, 10);
app.slave = IEC104_Slave_Create(); VERIFY(app.slave != NULL);
VERIFY(IEC104_Slave_Add_Station(app.slave, &app.station, 1U, &app) == IEC104_STATION_OK);
app.values[0].normalized = 8192; app.values[1].scaled = 100; app.values[2].short_float = 1.0f;
app.values[3].scaled = 100; app.values[4].scaled = -100; app.values[5].short_float = 0.5f;
IEC104_Parameter_Config_Default(&parameter);
parameter.points = points; parameter.point_count = POINT_COUNT; parameter.values = app.values;
parameter.extensions = (uint8_t)(ack ? IEC104_PARAMETER_EXT_ALL :
IEC104_PARAMETER_EXT_ALL & ~IEC104_PARAMETER_EXT_APPLY_ON_ACK);
app.parameter = IEC104_Parameter_Create(app.slave, &parameter); VERIFY(app.parameter != NULL);
test_interrogation_config(&gi); gi.station = &app.station;
app.gi = IEC104_Interrogation_Create(app.slave, &gi); VERIFY(app.gi != NULL);
IEC104_PeriodicScan_Config_Default(&scan);
app.periods[0] = 200;
scan.points = scan_points; scan.point_count = 1; scan.groups = &group; scan.group_count = 1;
scan.point_period_ms = app.periods; scan.point_retry_pending = app.retry; scan.point_retry_pending_size = sizeof(app.retry);
app.scan = IEC104_PeriodicScan_Create(app.slave, &scan); VERIFY(app.scan != NULL);
VERIFY(IEC104_Slave_Init(app.slave, &transport, NULL) == IEC104_TCP_OK);
VERIFY(IEC104_Slave_Get_Status(app.slave, &tcp, NULL) == IEC104_TCP_OK);
printf("PORT %u ACK %d\n", (unsigned)tcp.bound_port, ack); fflush(stdout);
started = IEC104_Net_Now_Ms();
/* 等待 ACK 不等于可执行;只用 execute_ready 决定零等待,同时收紧两类期限。
* Process 每轮观察 ACK,收尾先于本轮总召取值,使读回反映已经提交的运行值。 */
while (IEC104_Net_Now_Ms() - started < duration) {
IEC104_InterrogationStatus_t gi_status;
IEC104_PeriodicScanStatus_t scan_status;
uint32_t wait = 20U;
VERIFY(IEC104_Parameter_Get_Status(app.parameter, &status));
if (status.events_pending || status.execute_ready || status.need_process) wait = 0;
if (status.timer_active && status.timeout_remaining_ms < wait) wait = status.timeout_remaining_ms;
VERIFY(IEC104_Interrogation_Get_Status(app.gi, &gi_status));
if (gi_status.events_pending || gi_status.pending_events || gi_status.need_process || app.gi_pending) wait = 0;
if (gi_status.timer_active && gi_status.timeout_remaining_ms < wait) wait = gi_status.timeout_remaining_ms;
VERIFY(IEC104_PeriodicScan_Get_Status(app.scan, &scan_status));
if (scan_status.events_pending || scan_status.need_process) wait = 0;
if (scan_status.timer_active && scan_status.timeout_remaining_ms < wait) wait = scan_status.timeout_remaining_ms;
VERIFY(IEC104_Slave_Poll(app.slave, wait, NULL) == IEC104_TCP_OK);
drain(&app);
VERIFY(IEC104_Parameter_Process(app.parameter));
VERIFY(IEC104_Parameter_Execute_Next(app.parameter, action, &app) != IEC104_PARAMETER_EXECUTE_ERROR);
VERIFY(IEC104_Parameter_Process(app.parameter));
VERIFY(IEC104_Interrogation_Process(app.gi)); gi_step(&app);
VERIFY(IEC104_PeriodicScan_Step(app.scan, lookup, &app) != IEC104_PERIODIC_SCAN_STEP_ERROR);
}
/* Cancel 必须早于 Slave_Close:先确定 ACK 结果并归还观察槽,再断开传输。
* 退出时仍保留 app/扫描实例/快照,直到 COMMIT/ABORT 全交付才允许销毁。 */
IEC104_Parameter_Cancel(app.parameter); app.staged_mask = 0;
IEC104_Interrogation_Cancel(app.gi); IEC104_PeriodicScan_Cancel(app.scan);
VERIFY(IEC104_Slave_Close(app.slave, NULL) == IEC104_TCP_OK); drain(&app);
do {
VERIFY(IEC104_Parameter_Get_Status(app.parameter, &status));
if (status.finish_pending) VERIFY(IEC104_Parameter_Execute_Next(app.parameter, action, &app) == IEC104_PARAMETER_EXECUTE_OK);
} while (status.finish_pending);
app.gi_pending = false;
while (IEC104_Interrogation_NextEvent(app.gi, &app.gi_event) == IEC104_INTERROGATION_NEXT_READY) {}
printf("PARAMETER committed=%lu aborted=%lu applied=%lu staged=%lu\n",
status.committed, status.aborted, status.applied, status.staged);
VERIFY(!app.prepared && app.reserved_mask == 0U);
VERIFY(IEC104_Parameter_Destroy(app.parameter)); VERIFY(IEC104_Interrogation_Destroy(app.gi));
VERIFY(IEC104_PeriodicScan_Destroy(app.scan));
VERIFY(IEC104_Slave_Remove_Station(app.slave, &app.station) == IEC104_STATION_OK);
VERIFY(IEC104_Slave_Destroy(app.slave, NULL) == IEC104_TCP_OK);
return 0;
}