Files
STM32F4-Base/IEC60870-Slave/test/iec104_parameter_test.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

1344 lines
65 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/* 参数模块状态机测试:请求经过真实 Slave/TCP 层,仅网络收发和单调时钟由夹具控制。
* 报文按原始字节构造和核对,避免用被测参数编解码器生成同源的期望结果。
* 导航:夹具与注入 -> 默认协议/确认取值 -> ACK 准备与收尾 -> 跨实例共享与预留。
* 构建矩阵为 TCP 容量 1/2 × 任务槽 1/4;容量不足的场景明确输出 SKIP。
* 本文件验证可控边界与计数;独立协议栈的互操作由 parameter_lib60870_client.c 验证。 */
#include "iec104_test_config.h"
#include "iec104_tcp_fixture.h"
#include "IEC104_Parameter.h"
#ifndef IEC104_PARAMETER_TASK_CAPACITY
#define IEC104_PARAMETER_TASK_CAPACITY 4U
#endif
#define P_APPLIED IEC104_PARAMETER_ACTION_APPLIED
#define P_REJECTED IEC104_PARAMETER_ACTION_REJECTED
#define P_STAGED IEC104_PARAMETER_ACTION_STAGED
#define P_UNKNOWN IEC104_PARAMETER_ACTION_UNKNOWN_IOA
#define P_ACK IEC104_PARAMETER_EXT_APPLY_ON_ACK
static const IEC104_ParameterPoint_t points[] = {
{1, 110, 1, 5001}, {1, 111, 1, 5002}, {1, 112, 2, 5003},
{1, 111, 3, 5004}, {1, 111, 4, 5005}
};
static const IEC104_ParameterPoint_t shared_points[] = {
{1, 111, 1, 5001}, {1, 112, 2, 5001}, {1, 111, 3, 5001}, {1, 110, 1, 5002}
};
/* 两个实例故意借用同一份运行值;切换网络夹具不能切换或复制业务数据。 */
static IEC104_ParameterValue_t values[5];
typedef struct {
IEC104_Slave_t *slave;
IEC104_Parameter_t *module;
IEC104_Station_t station;
IEC104_ParameterConfig_t config;
IEC104_ParameterStatus_t status;
IEC104_SlaveEvent_t input;
IEC104_ParameterEventResult_t handled;
IEC104_ParameterRequest_t last, prepared;
IEC104_ParameterActionResult_t result;
unsigned ns, nr, calls, commits, aborts, prepares, tests;
unsigned action_advance_ms;
int send_fault, ack_error, round_value, reenter, check_station;
bool timeout_abort, staged_valid;
IEC104_ParameterValue_t staged_value;
unsigned char net[sizeof(fake)];
} ParameterFixture;
static ParameterFixture one;
#if IEC104_TCP_SERVER_CAPACITY > 1
static ParameterFixture two;
#endif
static ParameterFixture *current;
static unsigned groups;
/**
* 功能:多个服务沿用同一套模拟 socket 编号,只切换各连接的网络后端快照。
* 输入参数:f——测试夹具。
* 输出参数:无。
* 返回值:无。
* 说明:Slave、模块、站点和共享运行值的地址不变,仍遵守借用存储的寿命约束。
*/
static void select_fixture(ParameterFixture *f)
{
if (current == f) { return; }
if (current != NULL) { memcpy(current->net, &fake, sizeof(fake)); }
current = f;
memcpy(&fake, current->net, sizeof(fake));
}
/**
* 功能:刷新当前夹具的参数状态快照。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:查询失败直接报告断言,不保留旧值继续判断。
*/
static void status(void)
{
CHECK(IEC104_Parameter_Get_Status(current->module, &current->status));
}
#ifdef IEC104_PARAMETER_TEST_HOOKS
/**
* 功能:1/2/3 分别强制提交 WAIT/ERROR/FATAL。
* 输入参数:slave——被测 Slave 实例。
* 输出参数:无。
* 返回值:发送提交结果,区分接收成功、WAIT、ERROR 与 FATAL。
* 说明:4 先让真实链路消费 STOPDT,
* 暂不分派通知,再返回 ERROR,以覆盖“正常 STOP 待通知”的让出分支。
* 未注入时转调真实接口,会话查询和 ACK 观察槽分配也保持真实实现。
*/
static IEC104_TcpSubmitResult_t submit_fault(IEC104_Slave_t *slave)
{
if (current->send_fault == 1) { return IEC104_TCP_SUBMIT_WAIT; }
if (current->send_fault == 2) { return IEC104_TCP_SUBMIT_ERROR; }
if (current->send_fault == 3) { return IEC104_TCP_SUBMIT_FATAL; }
if (current->send_fault == 4) {
push(stop_act, sizeof(stop_act));
CHECK(IEC104_Slave_Poll(slave, 0, NULL) == IEC104_TCP_OK);
return IEC104_TCP_SUBMIT_ERROR;
}
return IEC104_TCP_SUBMIT_OK;
}
/**
* 功能:在普通确认提交前应用发送故障注入。
* 输入参数:slave——被测 Slave 实例;identity——请求所属的 Slave、实例及连接代次身份(只读);response——响应 ASDU(只读)。
* 输出参数:无。
* 返回值:发送提交结果,区分接收成功、WAIT、ERROR 与 FATAL。
* 说明:未注入时仍走真实Slave发送链。
*/
IEC104_TcpSubmitResult_t IEC104_Parameter_Test_Send_Response(IEC104_Slave_t *slave,
const IEC104_SlaveEventIdentity_t *identity, const IEC60870_Asdu_t *response)
{
IEC104_TcpSubmitResult_t result = submit_fault(slave);
return result == IEC104_TCP_SUBMIT_OK ? IEC104_Slave_Send_Response(slave, identity, response) : result;
}
/**
* 功能:为带ACK观察的确认应用同一发送注入。
* 输入参数:slave——被测 Slave 实例;identity——请求所属的 Slave、实例及连接代次身份(只读);response——响应 ASDU(只读);receipt——带连接身份的 ACK 回执。
* 输出参数:receipt——提交成功时返回的 ACK 回执。
* 返回值:发送提交结果,区分接收成功、WAIT、ERROR 与 FATAL。
* 说明:正常路径由真实Slave分配和返回回执。
*/
IEC104_TcpSubmitResult_t IEC104_Parameter_Test_Send_Response_Acked(IEC104_Slave_t *slave,
const IEC104_SlaveEventIdentity_t *identity, const IEC60870_Asdu_t *response,
IEC104_SlaveAckReceipt_t *receipt)
{
IEC104_TcpSubmitResult_t result = submit_fault(slave);
return result == IEC104_TCP_SUBMIT_OK ? IEC104_Slave_Send_Response_Acked(slave, identity, response, receipt) : result;
}
/**
* 功能:按夹具开关强制ACK查询错误,否则保持真实活动连接回执查询及确认时刻输出。
* 输入参数:slave——被测 Slave 实例(只读);receipt——带连接身份的 ACK 回执(只读);acked_at_ms——ACK 时刻(毫秒)的存储。
* 输出参数:acked_at_ms——已 ACK 时写入的确认时刻(毫秒)。
* 返回值:ACK 生命周期状态,区分排队、已发送、已确认及无效回执。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
IEC104_SlaveAckState_t IEC104_Parameter_Test_Get_Active_Ack_State(const IEC104_Slave_t *slave,
const IEC104_SlaveAckReceipt_t *receipt, uint64_t *acked_at_ms)
{
if (current->ack_error) { return IEC104_SLAVE_ACK_ERROR; }
return IEC104_Slave_Get_Active_Ack_State(slave, receipt, acked_at_ms);
}
#endif
/**
* 功能:将 Slave 生命周期和 I 帧通知逐条分派给参数模块。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:生命周期通知也必须逐条分派;暂存清理是应用职责,不由参数模块代管。
* 保存的 I 帧副本用于重入/旧代次测试,不能保留 NextEvent 的临时视图。
*/
static void read_events(void)
{
IEC104_SlaveEvent_t event;
IEC104_TcpEventResult_t result;
while ((result = IEC104_Slave_NextEvent(current->slave, &event)) == IEC104_TCP_EVENT_READY) {
IEC104_ParameterEventResult_t handled = IEC104_Parameter_Handle_Event(current->module, &event);
CHECK(handled != IEC104_PARAMETER_EVENT_ERROR);
if (event.transport.type == IEC104_TCP_EVENT_I_FRAME) {
CHECK(IEC104_Slave_Copy_Event(&current->input, &event));
current->handled = handled;
}
if (event.transport.type == IEC104_TCP_EVENT_DEACTIVATED ||
event.transport.type == IEC104_TCP_EVENT_DISCONNECTED) { current->staged_valid = false; }
}
CHECK(result == IEC104_TCP_EVENT_EMPTY);
}
/**
* 功能:非阻塞推进Slave并排空通知。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:轮询失败时先打印当前用例和序号便于定位。
*/
static void poll_parameter(void)
{
IEC104_TcpResult_t result = IEC104_Slave_Poll(current->slave, 0, NULL);
if (result != IEC104_TCP_OK) { fprintf(stderr, "poll: group=%u ns=%u result=%d\n", groups, current->ns, (int)result); }
CHECK(result == IEC104_TCP_OK);
read_events();
}
/**
* 功能:只推进传输和确认,不隐式 Execute_Next。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:这样测试可分别观测动作与发送。
*/
static void flush(void)
{
unsigned i;
for (i = 0; i < 8; ++i) { poll_parameter(); CHECK(IEC104_Parameter_Process(current->module)); }
status();
}
/**
* 功能:恢复共享运行值的测试基线,显式设置浮点参数及下限,供各用例独立起步。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static void initial_values(void)
{
unsigned i;
memset(values, 0, sizeof(values));
for (i = 0; i < 5; ++i) { values[i].scaled = 100; }
values[2].short_float = 1.0f;
values[3].scaled = 0;
}
/**
* 功能:链路期限放宽,避免参数期限测试被 t1/t3 抢先结束。
* 输入参数:f——测试夹具;extensions——参数服务扩展功能位;timeout——等待或执行期限(毫秒);prepare_timeout——参数准备期限(毫秒);type_mask——允许的协议类型掩码。
* 输出参数:f——操作后的测试夹具和队列状态。
* 返回值:无。
* 说明:fake.now 从 1000 起算,
* 既可测试到期相等边界,也可回退到受理时刻之前。Create 早于首条通知消费。
*/
static void open_fixture_config(ParameterFixture *f, uint8_t extensions, uint32_t timeout,
uint32_t prepare_timeout, uint8_t type_mask)
{
IEC104_SlaveConfig_t config;
if (current != NULL) { memcpy(current->net, &fake, sizeof(fake)); }
memset(f, 0, sizeof(*f));
current = f;
memset(&fake, 0, sizeof(fake));
fake.now = 1000;
f->result = P_APPLIED;
f->slave = IEC104_Slave_Create();
CHECK(f->slave != NULL);
test_transport_config(&config);
config.protocol.link.k = 32;
config.protocol.link.t1_ms = 600000;
config.protocol.link.t3_ms = 600000;
config.protocol.local_send_timeout_ms = 600000;
CHECK(IEC104_Slave_Init(f->slave, &config, NULL) == IEC104_TCP_OK);
CHECK(IEC104_Slave_Add_Station(f->slave, &f->station, 1, f) == IEC104_STATION_OK);
IEC104_Parameter_Config_Default(&f->config);
f->config.points = points;
f->config.point_count = sizeof(points) / sizeof(points[0]);
f->config.values = values;
f->config.extensions = extensions;
f->config.execute_timeout_ms = timeout;
f->config.prepare_timeout_ms = prepare_timeout;
f->config.type_mask = type_mask;
if ((extensions & IEC104_PARAMETER_EXT_SHARED_IOA) != 0U) {
f->config.points = shared_points;
f->config.point_count = sizeof(shared_points) / sizeof(shared_points[0]);
}
f->module = IEC104_Parameter_Create(f->slave, &f->config);
CHECK(f->module != NULL);
fake.accept_pending = 1;
poll_parameter();
push(start_act, sizeof(start_act));
poll_parameter();
status();
CHECK(f->status.active);
}
/**
* 功能:使用全部参数类型和10ms准备期限建立夹具,扩展开关及执行期限由调用者指定。
* 输入参数:f——测试夹具;extensions——参数服务扩展功能位;timeout——等待或执行期限(毫秒)。
* 输出参数:f——操作后的测试夹具和队列状态。
* 返回值:无。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static void open_fixture(ParameterFixture *f, uint8_t extensions, uint32_t timeout)
{
open_fixture_config(f, extensions, timeout, 10, 15);
}
/**
* 功能:可编排的同步动作:EXECUTE 写运行值,PREPARE 只保存请求,收尾才提交或放弃。
* 输入参数:context——业务回调的测试上下文;request——当前业务请求(只读)。
* 输出参数:无。
* 返回值:业务动作结果,保留应用成功、业务拒绝及未知对象等协议区别。
* 说明:逐字段比较准备与收尾身份/原值,专门捕获“确认带旧值却覆盖请求原文”的错误。
* 回调内同时验证状态快照与重入屏障;TEST 提前返回,绝不写运行值或暂存。
*/
static IEC104_ParameterActionResult_t action(void *context, const IEC104_ParameterRequest_t *request)
{
ParameterFixture *f = context;
CHECK(f == current);
status();
f->last = *request;
++f->calls;
CHECK(request->station_id == IEC104_Station_Get_Id(&f->station));
CHECK(request->common_address == 1 && request->originator_address == 0x5A);
if (request->phase == IEC104_PARAMETER_PHASE_COMMIT || request->phase == IEC104_PARAMETER_PHASE_ABORT) {
if (!f->timeout_abort) { CHECK(!f->status.confirm_pending); }
CHECK(request->accepted_ms == f->prepared.accepted_ms);
CHECK(request->receive_serial == f->prepared.receive_serial && request->generation == f->prepared.generation);
CHECK(request->instance_id == f->prepared.instance_id && request->type_id == f->prepared.type_id);
CHECK(memcmp(&request->value, &f->prepared.value, sizeof(request->value)) == 0);
if (request->phase == IEC104_PARAMETER_PHASE_ABORT) {
++f->aborts;
if (f->timeout_abort) { CHECK(f->status.confirm_pending); }
} else {
++f->commits;
if (request->operation == IEC104_PARAMETER_OP_LOAD) {
if (request->prepared == P_STAGED) {
f->staged_value = request->value;
f->staged_valid = true;
} else { values[request->point_index] = request->value; }
}
}
return P_REJECTED; /* 故意返回拒绝,验证 COMMIT/ABORT 的返回值不再生成确认。 */
}
CHECK(f->status.confirm_pending);
if (f->reenter) {
IEC104_ParameterStatus_t before = f->status;
CHECK(IEC104_Parameter_Execute_Next(f->module, action, f) == IEC104_PARAMETER_EXECUTE_ERROR);
CHECK(!IEC104_Parameter_Process(f->module));
CHECK(IEC104_Parameter_Handle_Event(f->module, &f->input) == IEC104_PARAMETER_EVENT_ERROR);
CHECK(!IEC104_Parameter_Destroy(f->module));
IEC104_Parameter_Cancel(f->module);
status();
CHECK(memcmp(&before, &f->status, sizeof(before)) == 0);
}
if (request->test) { ++f->tests; CHECK(request->phase == IEC104_PARAMETER_PHASE_EXECUTE); return f->result; }
if (f->check_station && !IEC104_Station_Is_Registered(&f->station)) { return P_REJECTED; }
if (request->phase == IEC104_PARAMETER_PHASE_PREPARE) {
++f->prepares;
f->prepared = *request;
fake.now += f->action_advance_ms;
return f->result;
}
if (request->operation == IEC104_PARAMETER_OP_LOAD) {
CHECK(request->point_span == 1 && request->kind == f->config.points[request->point_index].kind);
if (f->result == P_APPLIED) {
values[request->point_index] = request->value;
if (f->round_value && request->type_id == 111) {
values[request->point_index].scaled = (int16_t)(request->value.scaled / 10 * 10);
}
} else if (f->result == P_STAGED) { f->staged_valid = true; f->staged_value = request->value; }
}
return f->result;
}
/**
* 功能:将当前夹具及动作回调交给一次Execute_Next,原样返回是否执行、等待或失败。
* 输入参数:无。
* 输出参数:无。
* 返回值:单步执行结果,区分已执行、无任务、等待及错误。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static IEC104_ParameterExecuteResult_t execute(void)
{
return IEC104_Parameter_Execute_Next(current->module, action, current);
}
/**
* 功能:先 Cancel 固定 ACK 收尾决定并释放回执,再关闭 Slave。
* 输入参数:f——测试夹具。
* 输出参数:f——操作后的测试夹具和队列状态。
* 返回值:无。
* 说明:动作上下文、站点和
* 借用数组一直保留到全部收尾交付。Destroy 成功后才释放站点与服务对象。
*/
static void close_fixture(ParameterFixture *f)
{
unsigned guard = 0;
select_fixture(f);
f->send_fault = f->ack_error = 0;
IEC104_Parameter_Cancel(f->module);
CHECK(IEC104_Slave_Close(f->slave, NULL) == IEC104_TCP_OK);
read_events();
status();
while (f->status.finish_pending) {
CHECK(++guard < 8);
CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK);
status();
}
CHECK(IEC104_Parameter_Destroy(f->module));
if (IEC104_Station_Is_Registered(&f->station)) {
CHECK(IEC104_Slave_Remove_Station(f->slave, &f->station) == IEC104_STATION_OK);
}
CHECK(IEC104_Station_Is_Reusable(&f->station));
CHECK(IEC104_Slave_Destroy(f->slave, NULL) == IEC104_TCP_OK);
current = NULL;
}
/**
* 功能:按当前N(S)/N(R)包装原始ASDU并入接收队列,仅递增发送序号,不推进Slave。
* 输入参数:bytes——报文字节缓冲区(只读);length——字节长度。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void queue_bytes(const uint8_t *bytes, size_t length)
{
uint8_t frame[255] = {0x68};
CHECK(length <= 249);
frame[1] = (uint8_t)(length + 4);
frame[2] = (uint8_t)(current->ns << 1); frame[3] = (uint8_t)(current->ns >> 7);
frame[4] = (uint8_t)(current->nr << 1); frame[5] = (uint8_t)(current->nr >> 7);
++current->ns;
memcpy(frame + 6, bytes, length);
push(frame, length + 6);
}
/**
* 功能:独立线格式构造器:value 是字段原始位模式,浮点用例无需先经过宿主 float。
* 输入参数:bytes——报文字节缓冲区;type——协议类型或期望事件类型;cot——完整传送原因字节;ca——公共地址;ioa——信息对象地址;value——测试对象值或原始位模式;qualifier——原始限定词。
* 输出参数:bytes——写入或读出的数据字节。
* 返回值:生成报文或结果数据的实际字节长度。
* 说明:cot 含 TEST/P/N 位,qualifier 保留整字节,便于核对错误镜像和限定词回显。
*/
static size_t request_bytes(uint8_t *bytes, unsigned type, unsigned cot, unsigned ca,
unsigned ioa, uint32_t value, unsigned qualifier)
{
size_t length = type == 113 ? 10U : type == 112 ? 14U : 12U;
memset(bytes, 0, 32);
bytes[0] = (uint8_t)type; bytes[1] = 1; bytes[2] = (uint8_t)cot; bytes[3] = 0x5A;
bytes[4] = (uint8_t)ca; bytes[5] = (uint8_t)(ca >> 8);
bytes[6] = (uint8_t)ioa; bytes[7] = (uint8_t)(ioa >> 8); bytes[8] = (uint8_t)(ioa >> 16);
bytes[9] = (uint8_t)value; bytes[10] = (uint8_t)(value >> 8);
bytes[11] = (uint8_t)(value >> 16); bytes[12] = (uint8_t)(value >> 24);
bytes[length - 1U] = (uint8_t)qualifier;
return length;
}
/**
* 功能:构造CA=1的参数请求并立即轮询分派,应用动作与确认处理仍由用例显式推进。
* 输入参数:type——协议类型或期望事件类型;cot——完整传送原因字节;ioa——信息对象地址;value——测试对象值或原始位模式;qualifier——原始限定词。
* 输出参数:无。
* 返回值:无。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static void send_request(unsigned type, unsigned cot, unsigned ioa, uint32_t value, unsigned qualifier)
{
uint8_t bytes[32];
size_t length = request_bytes(bytes, type, cot, 1, ioa, value, qualifier);
queue_bytes(bytes, length); poll_parameter();
}
/**
* 功能:从累计输出提取Type110..113的ASDU借用视图及长度。
* 输入参数:frames——按线上顺序排列的 ASDU 视图数组;lengths——各 ASDU 的长度数组。
* 输出参数:frames——按线上顺序排列的 ASDU 视图数组;lengths——各 ASDU 的长度数组。
* 返回值:本次收集或统计到的有效业务帧数量。
* 说明:调用者须提供64项结果数组。
*/
static unsigned collect(const uint8_t **frames, size_t *lengths)
{
unsigned count = 0;
size_t offset = 0;
while (offset < fake.sent_bytes) {
const uint8_t *frame = fake.output + offset;
size_t length = (size_t)frame[1] + 2;
CHECK(length >= 6 && offset + length <= fake.sent_bytes);
if ((frame[2] & 1U) == 0 && frame[6] >= 110 && frame[6] <= 113) {
CHECK(count < 64);
frames[count] = frame + 6; lengths[count++] = length - 6;
}
offset += length;
}
return count;
}
/**
* 功能:独立构造预期参数ASDU并逐字节核对指定确认,失败时打印每字节实际值和期望值。
* 输入参数:index——待访问或核对的条目下标;type——协议类型或期望事件类型;cot——完整传送原因字节;ca——公共地址;ioa——信息对象地址;value——测试对象值或原始位模式;qualifier——原始限定词。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void expect_reply(unsigned index, unsigned type, unsigned cot, unsigned ca,
unsigned ioa, uint32_t value, unsigned qualifier)
{
const uint8_t *frames[64];
size_t lengths[64], length;
uint8_t expected[32];
length = request_bytes(expected, type, cot, ca, ioa, value, qualifier);
CHECK(collect(frames, lengths) > index);
CHECK(lengths[index] == length);
if (memcmp(frames[index], expected, length) != 0) {
size_t i;
fprintf(stderr, "group %u reply %u actual/expected:", groups, index);
for (i = 0; i < length; ++i) { fprintf(stderr, " %02X/%02X", frames[index][i], expected[i]); }
fputc('\n', stderr);
CHECK(0);
}
}
/**
* 功能:只确认已经出现在输出线上的 I 帧。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:正常请求不自动推进 nr,ACK 时机由用例决定。
*/
static void ack_all(void)
{
size_t offset = 0;
unsigned nr = current->nr;
while (offset < fake.sent_bytes) {
const uint8_t *frame = fake.output + offset;
if ((frame[2] & 1U) == 0) { nr = (((unsigned)frame[3] << 7) | (frame[2] >> 1)) + 1U; }
offset += (size_t)frame[1] + 2;
}
current->nr = nr;
push_ack(nr); poll_parameter(); CHECK(IEC104_Parameter_Process(current->module)); status();
}
/**
* 功能:验证以下场景与约束:[默认配置] 穷举 KPA 字节并检查表排序、借用指针和扩展约束。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:只启用 113
* 可以没有运行值,但启用 QPA=2 时仍必须提供用于寻址的点表。
*/
static void test_configuration(void)
{
IEC104_Slave_t *slave = IEC104_Slave_Create();
IEC104_ParameterConfig_t config, bad;
IEC104_ParameterPoint_t rows[2] = {{1, 111, 1, 1}, {1, 112, 2, 2}};
IEC104_Parameter_t *module;
unsigned kind;
CHECK(slave != NULL);
IEC104_Parameter_Config_Default(NULL);
IEC104_Parameter_Config_Default(&config);
CHECK(config.type_mask == 15 && config.extensions == 0 && config.execute_timeout_ms == 15000 &&
config.prepare_timeout_ms == 15000 && config.points == NULL && config.values == NULL);
CHECK(IEC104_Parameter_Create(slave, &config) == NULL);
CHECK(IEC104_Parameter_Create(NULL, &config) == NULL && IEC104_Parameter_Create(slave, NULL) == NULL);
config.points = rows; config.point_count = 2; config.values = values;
#define BAD_CONFIG(field, value) do { bad = config; bad.field = (value); CHECK(IEC104_Parameter_Create(slave, &bad) == NULL); } while (0)
BAD_CONFIG(type_mask, 0); BAD_CONFIG(type_mask, 0x10); BAD_CONFIG(extensions, 0x20);
BAD_CONFIG(points, NULL); BAD_CONFIG(point_count, 0); BAD_CONFIG(values, NULL);
BAD_CONFIG(point_count, SIZE_MAX / sizeof(rows[0]) + 1U);
for (kind = 0; kind < 256; ++kind) {
rows[0].kind = (uint8_t)kind;
module = IEC104_Parameter_Create(slave, &config);
CHECK((module != NULL) == ((kind >= 1 && kind <= 4) || (kind >= 32 && kind <= 63)));
if (module != NULL) { CHECK(IEC104_Parameter_Destroy(module)); }
}
rows[0].kind = 1;
rows[0].common_address = 0; CHECK(IEC104_Parameter_Create(slave, &config) == NULL);
rows[0].common_address = 65535; CHECK(IEC104_Parameter_Create(slave, &config) == NULL);
rows[0].common_address = 1;
rows[0].ioa = 0; CHECK(IEC104_Parameter_Create(slave, &config) == NULL);
rows[0].ioa = 0x1000000; CHECK(IEC104_Parameter_Create(slave, &config) == NULL);
rows[0].ioa = 1;
rows[0].type_id = 113; CHECK(IEC104_Parameter_Create(slave, &config) == NULL);
rows[0].type_id = 111;
rows[1].ioa = 1; CHECK(IEC104_Parameter_Create(slave, &config) == NULL);
config.extensions = IEC104_PARAMETER_EXT_SHARED_IOA;
module = IEC104_Parameter_Create(slave, &config); CHECK(module != NULL); CHECK(IEC104_Parameter_Destroy(module));
rows[1].kind = 1; CHECK(IEC104_Parameter_Create(slave, &config) == NULL);
rows[1].kind = 2; rows[1].ioa = 2; config.extensions = 0;
config.type_mask = IEC104_PARAMETER_TYPE_BIT(113);
config.values = NULL;
module = IEC104_Parameter_Create(slave, &config); CHECK(module != NULL); CHECK(IEC104_Parameter_Destroy(module));
config.points = NULL; config.point_count = 0;
BAD_CONFIG(extensions, IEC104_PARAMETER_EXT_QPA_OBJECT);
module = IEC104_Parameter_Create(slave, &config); CHECK(module != NULL);
CHECK(IEC104_Parameter_Create(slave, &config) == NULL);
CHECK(IEC104_Parameter_Destroy(module));
CHECK(IEC104_Slave_Destroy(slave, NULL) == IEC104_TCP_OK);
CHECK(!IEC104_Parameter_Destroy(NULL) && !IEC104_Parameter_Process(NULL));
CHECK(IEC104_PARAMETER_TYPE_BIT(109) == 0 && IEC104_PARAMETER_TYPE_BIT(114) == 0);
++groups;
#undef BAD_CONFIG
}
/**
* 功能:验证以下场景与约束:[运行值确认] 三种类型分别核对 APPLIED 新值、REJECTED 旧值、UNKNOWN 镜像。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:另用 205 -> 200 的应用取整证明肯定确认取实际运行值,而非固定回显请求。
*/
static void test_load_results(void)
{
unsigned type, result;
for (type = 110; type <= 112; ++type) {
for (result = 0; result < 4; ++result) {
uint32_t sent = type == 112 ? 0x40000000U : 205;
uint32_t old = type == 112 ? 0x3F800000U : 100;
unsigned ioa = 5001 + type - 110, kind = type == 112 ? 2 : 1;
initial_values(); open_fixture(&one, 0, 15000);
one.result = result == 3 ? (IEC104_ParameterActionResult_t)99 : (IEC104_ParameterActionResult_t)result;
send_request(type, 6, ioa, sent, kind | 0xC0);
CHECK(one.calls == 0 && one.handled == IEC104_PARAMETER_EVENT_HANDLED);
CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush();
expect_reply(0, type, result == 1 ? 7 : result == 2 ? 0x6F : 0x47,
1, ioa, result == 1 || result == 2 ? sent : old, kind | 0xC0);
CHECK(one.last.local_change && one.last.not_in_operation && one.status.executed == 1);
CHECK(one.status.applied == (result == 1) && one.status.unknown_ioa == (result == 2));
close_fixture(&one);
}
}
initial_values(); open_fixture(&one, 0, 15000); one.round_value = 1;
send_request(111, 6, 5002, 205, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush();
expect_reply(0, 111, 7, 1, 5002, 200, 1); close_fixture(&one);
++groups;
}
/**
* 功能:验证COT/CA/IOA/内容的拒绝优先级、对象数量异常及全部QPA字节的处理结果。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_validation(void)
{
/* 同时制造多项错误,核对 COT -> CA -> IOA -> 内容的判定优先级。 */
static const struct { unsigned type, cot, ca, ioa, qualifier, vsq, tail, reply; uint32_t value; } cases[] = {
{111, 8, 65535, 999, 0, 0x81, 1, 0x6D, 200},
{111, 6, 65535, 999, 0, 0x81, 1, 0x6E, 200},
{111, 6, 2, 5002, 1, 1, 0, 0x6E, 200},
{111, 6, 1, 999, 0, 0x81, 1, 0x6F, 200},
{110, 6, 1, 5002, 1, 1, 0, 0x47, 200},
{111, 6, 1, 5002, 2, 1, 0, 0x47, 200},
{111, 6, 1, 5002, 1, 0x81, 0, 0x47, 100},
{111, 6, 1, 5002, 1, 1, 1, 0x47, 100},
{111, 0x46, 1, 5002, 1, 1, 0, 0x47, 100},
{111, 0xC6, 1, 5002, 1, 1, 0, 0xC7, 100},
{113, 8, 1, 1, 0, 1, 0, 0x49, 0}
};
unsigned i;
for (i = 0; i < sizeof(cases) / sizeof(cases[0]); ++i) {
uint8_t bytes[32]; size_t n;
initial_values(); open_fixture(&one, 0, 15000);
n = request_bytes(bytes, cases[i].type, cases[i].cot, cases[i].ca, cases[i].ioa, 200, cases[i].qualifier);
bytes[1] = (uint8_t)cases[i].vsq;
queue_bytes(bytes, n + cases[i].tail); poll_parameter(); flush();
expect_reply(0, cases[i].type, cases[i].reply, cases[i].ca, cases[i].ioa, cases[i].value, cases[i].qualifier);
CHECK(one.calls == 0 && one.status.rejected == 1 && one.status.accepted == 0);
close_fixture(&one);
}
for (i = 0; i < 3; ++i) {
uint8_t bytes[32]; size_t n;
initial_values(); open_fixture(&one, 0, 15000);
n = request_bytes(bytes, 111, 6, 1, 5002, 200, 1);
bytes[1] = i == 0 ? 0 : 2;
if (i == 2) { memcpy(bytes + n, bytes + 6, 6); n += 6; }
queue_bytes(bytes, n); poll_parameter(); flush();
/* 声明两个对象却只带一个载荷时由 Receiver 断链,不计模块 rejected。
* VSQ=0 和完整双对象帧能到模块,由模块丢弃且不发送确认。 */
CHECK(one.status.rejected == (i != 1) && one.status.submitted == 0 && one.status.pending_requests == 0);
if (i == 1) { CHECK(!one.status.active); }
close_fixture(&one);
}
for (i = 0; i < 256; ++i) {
initial_values(); open_fixture(&one, 0, 15000);
send_request(113, 6, 999, 0, i);
if (i == 3) { one.result = P_UNKNOWN; CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); }
flush(); expect_reply(0, 113, i == 3 ? 0x6F : 0x47, 1, 999, 0, i);
close_fixture(&one);
}
++groups;
}
/**
* 功能:验证以下场景与约束:[浮点原文] 正负 Inf、静默/信号 NaN 均拒绝。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:负零、最小非规格化数和最大
* 有限数均受理,确保判断只看 IEEE 754 指数位,不受浮点优化选项影响。
*/
static void test_float_bits(void)
{
static const uint32_t bits[] = {0x7F800000U, 0xFF800000U, 0x7FC12345U, 0x7F800001U,
0x80000000U, 1U, 0x7F7FFFFFU};
unsigned i;
for (i = 0; i < sizeof(bits) / sizeof(bits[0]); ++i) {
initial_values(); open_fixture(&one, 0, 15000);
send_request(112, 6, 5003, bits[i], 2);
if (i >= 4) { CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); }
flush(); expect_reply(0, 112, i < 4 ? 0x47 : 7, 1, 5003, i < 4 ? 0x3F800000U : bits[i], 2);
CHECK(one.status.rejected == (i < 4)); close_fixture(&one);
}
++groups;
}
/**
* 功能:验证以下场景与约束:[TEST] 即使动作预设为拒绝,110..112 也只验证协议并返回当前值。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:113 仍需
* 只读动作判断地址。开启 ACK 扩展也不得把 TEST 变成 PREPARE 或等待 ACK。
*/
static void test_test_bit(void)
{
unsigned type, result;
for (type = 110; type <= 112; ++type) {
initial_values(); open_fixture(&one, P_ACK, 15000); one.result = P_REJECTED;
send_request(type, 0x86, 5001 + type - 110, type == 112 ? 0xBF800000U : 0xFFFFU, type == 112 ? 2 : 1);
CHECK(execute() == IEC104_PARAMETER_EXECUTE_EMPTY); flush();
expect_reply(0, type, 0x87, 1, 5001 + type - 110, type == 112 ? 0x3F800000U : 100, type == 112 ? 2 : 1);
CHECK(one.calls == 0 && one.status.accepted == 1 && one.status.executed == 0 && !one.status.ack_pending);
close_fixture(&one);
}
for (result = 0; result < 3; ++result) {
initial_values(); open_fixture(&one, P_ACK, 15000); one.result = (IEC104_ParameterActionResult_t)result;
send_request(113, 0x88, 2001, 0, 3); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush();
expect_reply(0, 113, result == 0 ? 0xC9 : result == 1 ? 0x89 : 0xEF, 1, 2001, 0, 3);
CHECK(one.tests == 1 && one.prepares == 0 && one.status.executed == 0 && one.status.applied == 0 &&
one.status.unknown_ioa == 0 && !one.status.ack_pending);
close_fixture(&one);
}
++groups;
}
/**
* 功能:验证以下场景与约束:[执行期限/重试] 覆盖截止前、恰好截止、时钟倒退和禁用期限。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:确认第一次
* WAIT 后再改运行值,最终字节仍须保持首次快照,且动作不能重复调用。
*/
static void test_deadlines_and_retry(void)
{
unsigned mode;
for (mode = 0; mode < 4; ++mode) {
initial_values(); open_fixture(&one, 0, mode == 3 ? 0 : 10);
send_request(111, 6, 5002, 200, 1);
status(); CHECK(one.status.timer_active == (mode != 3));
fake.now = mode == 2 ? 999 : mode == 0 ? 1009 : 1010;
CHECK(execute() == (mode == 0 || mode == 3 ? IEC104_PARAMETER_EXECUTE_OK : IEC104_PARAMETER_EXECUTE_EMPTY));
if (fake.now < 1000) { fake.now = 1000; }
flush(); expect_reply(0, 111, mode == 0 || mode == 3 ? 7 : 0x47, 1, 5002, mode == 0 || mode == 3 ? 200 : 100, 1);
CHECK(one.status.timeouts == (mode == 1 || mode == 2)); close_fixture(&one);
}
initial_values(); open_fixture(&one, 0, 15000); one.send_fault = 1;
send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK);
values[1].scaled = 300; CHECK(IEC104_Parameter_Process(one.module));
one.send_fault = 0; flush(); expect_reply(0, 111, 7, 1, 5002, 200, 1);
CHECK(one.calls == 1 && one.status.waits >= 2 && one.status.executed == 1); close_fixture(&one);
++groups;
}
/**
* 功能:验证以下场景与约束:[FIFO 取值] A 装载 1、B TEST、C 装载 2、D 装载 3。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:连续执行可越过待发确认,
* B 必须在 C 动作前取值,四份确认恒为 1/1/2/3;有无发送 WAIT 都要成立。
*/
static void test_fifo(void)
{
#if IEC104_PARAMETER_TASK_CAPACITY >= 4
unsigned wait;
for (wait = 0; wait < 2; ++wait) {
initial_values(); open_fixture(&one, 0, 15000);
send_request(111, 6, 5002, 1, 1);
send_request(111, 0x86, 5002, 99, 1);
send_request(111, 6, 5002, 2, 1);
send_request(111, 6, 5002, 3, 1);
one.send_fault = (int)wait;
CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK);
CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK);
CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK);
CHECK(execute() == IEC104_PARAMETER_EXECUTE_EMPTY);
one.send_fault = 0; flush();
expect_reply(0, 111, 7, 1, 5002, 1, 1); expect_reply(1, 111, 0x87, 1, 5002, 1, 1);
expect_reply(2, 111, 7, 1, 5002, 2, 1); expect_reply(3, 111, 7, 1, 5002, 3, 1);
CHECK(one.status.accepted == 4 && one.status.executed == 3); close_fixture(&one);
}
#else
puts("SKIP FIFO four-request snapshot: task capacity < 4");
#endif
++groups;
}
/**
* 功能:验证以下场景与约束:[取消与过载] 合法请求和错误确认共用容量。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:槽满只丢新。动作已生效后发送
* 失败不回滚;站点删除后引用仍保留到任务移除,由动作决定拒绝旧站请求。
*/
static void test_overload_and_lifetime(void)
{
unsigned i, fault;
initial_values(); open_fixture(&one, 0, 15000);
for (i = 0; i < IEC104_PARAMETER_TASK_CAPACITY; ++i) { send_request(111, 6, 5002, 200, 1); }
send_request(111, 6, 5002, 200, 1); send_request(111, 8, 5002, 200, 1); status();
CHECK(one.status.accepted == IEC104_PARAMETER_TASK_CAPACITY && one.status.dropped_requests == 2 &&
one.status.rejected == 1 && one.status.pending_requests == IEC104_PARAMETER_TASK_CAPACITY);
CHECK(!IEC104_Parameter_Destroy(one.module));
IEC104_Parameter_Cancel(one.module); status(); CHECK(one.status.cancelled == IEC104_PARAMETER_TASK_CAPACITY);
close_fixture(&one);
for (fault = 2; fault <= 4; ++fault) {
initial_values(); open_fixture(&one, 0, 15000); one.send_fault = (int)fault;
send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK);
read_events(); status(); CHECK(one.status.pending_requests == 0 && one.status.cancelled == 1);
CHECK(values[1].scaled == 200); close_fixture(&one);
}
initial_values(); open_fixture(&one, 0, 15000); one.reenter = 1;
send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); close_fixture(&one);
initial_values(); open_fixture(&one, 0, 15000); one.check_station = 1;
send_request(111, 6, 5002, 200, 1);
CHECK(IEC104_Slave_Remove_Station(one.slave, &one.station) == IEC104_STATION_OK);
CHECK(!IEC104_Station_Is_Reusable(&one.station));
CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); expect_reply(0, 111, 0x47, 1, 5002, 100, 1);
close_fixture(&one);
++groups;
}
/**
* 功能:验证以下场景与约束:[扩展开关] 穷举全部 32 种组合。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:用 TEST 隔离 QPA 受理规则与 ACK 收尾。
* 后半段验证 STAGED 合法范围、QPA=1/2 地址、专用 QPA 和同址 KPA 定位。
*/
static void test_extensions(void)
{
unsigned ext, qpa;
for (ext = 0; ext <= IEC104_PARAMETER_EXT_ALL; ++ext) {
for (qpa = 1; qpa <= 3; ++qpa) {
bool accepted = qpa == 3 || (qpa == 1 && (ext & IEC104_PARAMETER_EXT_QPA_LOADED)) ||
(qpa == 2 && (ext & IEC104_PARAMETER_EXT_QPA_OBJECT));
initial_values(); open_fixture(&one, (uint8_t)ext, 15000);
send_request(113, 0x86, qpa == 1 ? 0 : 5001, 0, qpa);
CHECK(execute() == (accepted ? IEC104_PARAMETER_EXECUTE_OK : IEC104_PARAMETER_EXECUTE_EMPTY));
flush(); expect_reply(0, 113, accepted ? 0x87 : 0xC7, 1, qpa == 1 ? 0 : 5001, 0, qpa);
if (accepted && qpa == 2) {
CHECK(one.last.point_index == 0 && one.last.point_span == ((ext & IEC104_PARAMETER_EXT_SHARED_IOA) ? 3U : 1U));
}
close_fixture(&one);
}
}
for (qpa = 128; qpa <= 255; qpa += 127) {
initial_values(); open_fixture(&one, IEC104_PARAMETER_EXT_PRIVATE_QPA, 15000);
send_request(113, 8, 0xFFFFFF, 0, qpa); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush();
expect_reply(0, 113, 9, 1, 0xFFFFFF, 0, qpa); CHECK(one.last.point_index == SIZE_MAX); close_fixture(&one);
}
for (ext = 0; ext < 3; ++ext) {
initial_values(); open_fixture(&one, (uint8_t)ext, 15000); one.result = P_STAGED;
send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush();
expect_reply(0, 111, ext ? 7 : 0x47, 1, 5002, 100, 1); CHECK(one.status.staged == (ext != 0));
close_fixture(&one);
}
initial_values(); open_fixture(&one, IEC104_PARAMETER_EXT_QPA_LOADED | IEC104_PARAMETER_EXT_QPA_OBJECT, 15000);
send_request(113, 6, 1, 0, 1); flush(); expect_reply(0, 113, 0x6F, 1, 1, 0, 1);
send_request(113, 6, 999, 0, 2); flush(); expect_reply(1, 113, 0x6F, 1, 999, 0, 2);
one.result = P_STAGED; send_request(113, 6, 0, 0, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK);
flush(); expect_reply(2, 113, 0x47, 1, 0, 0, 1); CHECK(one.status.staged == 0); close_fixture(&one);
initial_values(); open_fixture(&one, IEC104_PARAMETER_EXT_SHARED_IOA, 15000); values[1].short_float = 1.0f;
send_request(112, 6, 5001, 0x40000000, 2); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush();
CHECK(one.last.point_index == 1); expect_reply(0, 112, 7, 1, 5001, 0x40000000, 2);
send_request(111, 6, 5001, 200, 4); flush(); expect_reply(1, 111, 0x47, 1, 5001, 200, 4);
send_request(111, 6, 5001, 200, 2); flush(); expect_reply(2, 111, 0x47, 1, 5001, 200, 2); close_fixture(&one);
++groups;
}
/**
* 功能:验证以下场景与约束:[ACK 两阶段] 后续请求不自动确认前帧,准备、网络 ACK 和应用收尾可独立观测。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:ACK 后再 STOP:APPLIED 仍提交,STAGED 必须放弃;未 ACK 或观察失败均放弃。
* 健康连接 Cancel 后的迟到 ACK 也不能把已放弃的准备重新提交。
*/
static void test_ack_success_and_loss(void)
{
unsigned staged, ending;
for (staged = 0; staged < 2; ++staged) {
for (ending = 0; ending < 4; ++ending) {
initial_values(); open_fixture(&one, P_ACK | IEC104_PARAMETER_EXT_QPA_LOADED, 15000);
one.result = staged ? P_STAGED : P_APPLIED;
send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush();
expect_reply(0, 111, 7, 1, 5002, staged ? 100 : 200, 1);
CHECK(values[1].scaled == 100 && one.prepares == 1 && one.status.ack_pending);
CHECK(!one.status.confirm_pending && !one.status.execute_ready && !one.status.need_process);
CHECK(!IEC104_Parameter_Destroy(one.module));
if (ending == 0 || ending == 1) { ack_all(); CHECK(one.status.finish_pending); }
if (ending == 1 || ending == 2) { push(stop_act, sizeof(stop_act)); poll_parameter(); }
if (ending == 3) { one.ack_error = 1; CHECK(IEC104_Parameter_Process(one.module)); }
CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); status();
CHECK(one.commits == ((ending == 0 || ending == 1) && !(staged && ending == 1)));
CHECK(one.aborts == (1U - one.commits)); CHECK(one.last.value.scaled == 200);
CHECK(execute() == IEC104_PARAMETER_EXECUTE_EMPTY);
CHECK(values[1].scaled == ((!staged && one.commits) ? 200 : 100));
CHECK(one.status.ack_errors == (ending == 3)); close_fixture(&one);
}
}
initial_values(); open_fixture(&one, P_ACK, 15000);
send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush();
IEC104_Parameter_Cancel(one.module); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); ack_all();
CHECK(execute() == IEC104_PARAMETER_EXECUTE_EMPTY && one.aborts == 1 && one.commits == 0);
close_fixture(&one);
++groups;
}
/**
* 功能:验证以下场景与约束:[准备超时] 持续 WAIT 使肯定确认从未交出。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:到期只排入 ABORT,Process 不调用
* 动作。ABORT 后才生成否定确认;在其前/后 Cancel 都只取消一次确认义务。
*/
static void test_prepare_timeout(void)
{
unsigned cancel_mode, rollback;
for (cancel_mode = 0; cancel_mode < 3; ++cancel_mode) {
for (rollback = 0; rollback < 2; ++rollback) {
initial_values(); open_fixture(&one, P_ACK, 15000); one.send_fault = 1;
send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); status();
CHECK(one.status.timer_active && one.status.timeout_remaining_ms == 10);
fake.now = rollback ? 999 : 1010;
CHECK(IEC104_Parameter_Process(one.module)); status();
CHECK(one.status.prepare_timeouts == 1 && one.status.finish_pending && one.status.execute_ready);
CHECK(one.aborts == 0 && one.status.pending_requests == 1);
if (cancel_mode == 1) { IEC104_Parameter_Cancel(one.module); }
one.timeout_abort = cancel_mode != 1;
CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); status();
CHECK(one.aborts == 1 && one.status.pending_requests == (cancel_mode != 1));
if (cancel_mode == 2) { IEC104_Parameter_Cancel(one.module); }
one.send_fault = 0; fake.now = 1010; flush();
CHECK(one.status.cancelled == (cancel_mode != 0));
CHECK(one.status.submitted == (cancel_mode == 0));
if (cancel_mode == 0) { expect_reply(0, 111, 0x47, 1, 5002, 100, 1); }
CHECK(execute() == IEC104_PARAMETER_EXECUTE_EMPTY && one.aborts == 1); close_fixture(&one);
}
}
++groups;
}
/**
* 功能:验证以下场景与约束:[两个期限起点] 动作内推进时钟,证明 prepared_ms 从返回时起算,原 accepted_ms
* 仍交给收尾。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:执行已开始后不再按执行期限中断,准备期限为 0 时也不判倒退。
*/
static void test_prepare_clock_and_disabled_deadline(void)
{
unsigned disabled;
for (disabled = 0; disabled < 2; ++disabled) {
initial_values(); open_fixture_config(&one, P_ACK, 1, disabled ? 0 : 10, 15);
one.action_advance_ms = 7;
one.send_fault = 1;
send_request(111, 6, 5002, 200, 1);
CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); status();
CHECK(one.prepared.accepted_ms == 1000 && fake.now == 1007);
CHECK(one.status.timer_active == !disabled && one.status.timeout_remaining_ms == (disabled ? 0U : 10U));
CHECK(one.status.timeouts == 0); /* 动作已开始,即使返回时越过执行期限也不超时。 */
fake.now = disabled ? 999 : 1016;
CHECK(IEC104_Parameter_Process(one.module)); status();
CHECK(one.status.prepare_timeouts == 0 && !one.status.finish_pending);
CHECK(one.status.timeout_remaining_ms == (disabled ? 0U : 1U));
fake.now = disabled ? 20000 : 1017;
CHECK(IEC104_Parameter_Process(one.module)); status();
CHECK(one.status.prepare_timeouts == !disabled);
if (!disabled) { one.timeout_abort = true; CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); }
one.send_fault = 0; flush();
if (disabled) { ack_all(); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); CHECK(one.commits == 1); }
else { CHECK(one.aborts == 1); }
CHECK(one.last.accepted_ms == 1000);
close_fixture(&one);
}
++groups;
}
/**
* 功能:验证以下场景与约束:[提交故障] 肯定准备尚未成功交出就遇 ERROR/FATAL/STOP,任务必须保留到 ABORT,
* 不得因取消普通任务的路径提前释放。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:运行值保持旧值。
*/
static void test_ack_submission_faults(void)
{
unsigned fault;
for (fault = 2; fault <= 4; ++fault) {
initial_values(); open_fixture(&one, P_ACK, 15000); one.send_fault = (int)fault;
send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK);
read_events(); status(); CHECK(one.status.finish_pending && one.status.pending_requests == 1);
CHECK(!IEC104_Parameter_Destroy(one.module)); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK);
CHECK(one.aborts == 1 && one.commits == 0 && values[1].scaled == 100); close_fixture(&one);
}
++groups;
}
/**
* 功能:验证以下场景与约束:[ACK 串行与调度] 前序准备未收尾时,后续动作和带运行值确认都被阻挡。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:后续执行期限仍照常到期。等待期间 execute_ready/need_process 不制造忙循环。
*/
static void test_ack_blocking(void)
{
#if IEC104_PARAMETER_TASK_CAPACITY >= 4
unsigned commit, test;
for (commit = 0; commit < 2; ++commit) for (test = 0; test < 2; ++test) {
initial_values(); open_fixture(&one, P_ACK, 10);
send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush();
send_request(111, test ? 0x86 : 6, 5002, 300, 1); status();
CHECK(one.status.execute_pending == !test && !one.status.execute_ready);
CHECK(!one.status.need_process && one.status.ack_pending);
CHECK(execute() == IEC104_PARAMETER_EXECUTE_EMPTY && one.calls == 1);
if (!test) { fake.now = 1010; CHECK(IEC104_Parameter_Process(one.module)); status(); CHECK(one.status.timeouts == 1); }
if (commit) { ack_all(); } else { one.ack_error = 1; CHECK(IEC104_Parameter_Process(one.module)); }
CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush();
expect_reply(1, 111, test ? 0x87 : 0x47, 1, 5002, commit ? 200 : 100, 1);
CHECK(one.calls == 2); close_fixture(&one);
}
/* 镜像确认不等候选值生效,但不能越过更早一份等待取运行值的确认。 */
initial_values(); open_fixture(&one, P_ACK, 15000);
send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush();
send_request(111, 8, 5002, 333, 1); flush();
expect_reply(1, 111, 0x6D, 1, 5002, 333, 1);
CHECK(one.status.ack_pending && one.calls == 1);
send_request(111, 0x86, 5002, 444, 1);
send_request(111, 6, 999, 555, 1); flush();
CHECK(one.status.submitted == 2 && !one.status.need_process);
ack_all(); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush();
expect_reply(2, 111, 0x87, 1, 5002, 200, 1);
expect_reply(3, 111, 0x6F, 1, 999, 555, 1);
close_fixture(&one);
#else
puts("SKIP ACK blocked successor: task capacity < 4");
#endif
++groups;
}
/**
* 功能:验证以下场景与约束:[STAGED 提交门槛] 先 ACK,再制造尚未分派的 STOP/STOP+START、删站/同 CA
* 重注册或 Cancel。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:旧暂存均须 ABORT;只看最终 active 或 CA 会漏掉这些边界。
*/
static void test_staged_commit_gate(void)
{
unsigned mode;
for (mode = 0; mode < 5; ++mode) {
IEC104_Station_t replacement = {0};
initial_values(); open_fixture(&one, P_ACK | IEC104_PARAMETER_EXT_QPA_LOADED, 15000); one.result = P_STAGED;
send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); ack_all();
CHECK(one.status.finish_pending);
if (mode < 2) {
push(stop_act, sizeof(stop_act));
if (mode == 1) { push(start_act, sizeof(start_act)); }
CHECK(IEC104_Slave_Poll(one.slave, 0, NULL) == IEC104_TCP_OK);
CHECK(execute() == IEC104_PARAMETER_EXECUTE_WAIT && one.commits == 0);
read_events();
} else if (mode == 2 || mode == 4) {
CHECK(IEC104_Slave_Remove_Station(one.slave, &one.station) == IEC104_STATION_OK);
if (mode == 4) {
CHECK(IEC104_Slave_Add_Station(one.slave, &replacement, 1, &one) == IEC104_STATION_OK);
CHECK(IEC104_Station_Get_Id(&replacement) != one.prepared.station_id);
}
} else { IEC104_Parameter_Cancel(one.module); }
CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK && one.aborts == 1 && one.commits == 0);
if (mode == 4) { CHECK(IEC104_Slave_Remove_Station(one.slave, &replacement) == IEC104_STATION_OK); }
close_fixture(&one);
}
/* APPLIED 已被 ACK 的提交不依赖会话,未读 STOP 不能阻止它兑现运行值。 */
initial_values(); open_fixture(&one, P_ACK, 15000);
send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); ack_all();
push(stop_act, sizeof(stop_act)); CHECK(IEC104_Slave_Poll(one.slave, 0, NULL) == IEC104_TCP_OK);
CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK && one.commits == 1); read_events(); close_fixture(&one);
++groups;
}
/**
* 功能:验证以下场景与约束:[会话寿命] 断线清除会话暂存,重连改变 generation 而保留模块 instance_id。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:旧事件不得重新受理。Destroy 失败时对象还在使用,应用不能提前清掉暂存。
*/
static void test_session_identity_and_destroy(void)
{
unsigned mode;
for (mode = 0; mode < 3; ++mode) {
IEC104_SlaveEvent_t original;
uint64_t generation, instance_id = 0;
initial_values(); open_fixture(&one, (uint8_t)(IEC104_PARAMETER_EXT_QPA_LOADED | (mode == 1 ? P_ACK : 0)), 15000);
send_request(111, 6, 5002, 200, 1);
CHECK(IEC104_Slave_Copy_Event(&original, &one.input)); status(); generation = one.status.generation;
if (mode != 0) {
one.result = mode == 2 ? P_STAGED : P_APPLIED;
CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); instance_id = one.last.instance_id;
}
if (mode == 2) {
CHECK(one.staged_valid);
send_request(113, 6, 0, 0, 1);
CHECK(!IEC104_Parameter_Destroy(one.module) && one.staged_valid);
}
fake.recv_eof = 1; poll_parameter(); fake.recv_eof = 0; status();
CHECK(one.status.generation == 0 && !one.status.active && !one.staged_valid);
if (mode == 1) { CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK && one.aborts == 1); }
status(); CHECK(one.status.pending_requests == 0 && one.status.cancelled == (mode != 1));
one.ns = one.nr = 0; fake.sent_bytes = 0;
fake.accept_pending = 1; poll_parameter(); push(start_act, sizeof(start_act)); poll_parameter(); status();
CHECK(one.status.active && one.status.generation != generation);
CHECK(IEC104_Parameter_Handle_Event(one.module, &original) == IEC104_PARAMETER_EVENT_IGNORED);
one.result = P_APPLIED;
send_request(113, 0x86, 5001, 0, 3); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush();
if (instance_id != 0) { CHECK(one.last.instance_id == instance_id); }
CHECK(one.last.generation == one.status.generation);
close_fixture(&one);
}
++groups;
}
/**
* 功能:验证以下场景与约束:[分派边界] 未知/关闭的类型和不可用视图保持 IGNORED。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:已知类型的截短帧由
* Receiver 终止链路,模块没有收到请求,不能误增自身 rejected 计数。
*/
static void test_filters_and_truncation(void)
{
IEC104_SlaveEvent_t copy;
uint8_t bytes[32]; size_t n;
initial_values(); open_fixture(&one, 0, 15000);
n = request_bytes(bytes, 200, 6, 1, 5002, 200, 1);
queue_bytes(bytes, n); poll_parameter(); status();
CHECK(one.handled == IEC104_PARAMETER_EVENT_IGNORED && one.status.accepted == 0);
send_request(111, 6, 5002, 200, 1);
CHECK(IEC104_Slave_Copy_Event(&copy, &one.input));
copy.asdu_result = IEC60870_ASDU_ERROR;
CHECK(IEC104_Parameter_Handle_Event(one.module, &copy) == IEC104_PARAMETER_EVENT_IGNORED);
IEC104_Parameter_Cancel(one.module);
n = request_bytes(bytes, 112, 6, 1, 5003, 0x40000000, 2);
queue_bytes(bytes, n - 1U);
/* 在 I_FRAME 交付之前断链,随后只分派生命周期通知。 */
(void)IEC104_Slave_Poll(one.slave, 0, NULL); read_events(); status();
CHECK(one.status.accepted == 1 && one.status.rejected == 0 && !one.status.active);
close_fixture(&one);
initial_values(); open_fixture_config(&one, 0, 15000, 10, IEC104_PARAMETER_TYPE_BIT(113));
send_request(111, 6, 5002, 200, 1); status();
CHECK(one.handled == IEC104_PARAMETER_EVENT_IGNORED && one.status.accepted == 0);
CHECK(IEC104_Slave_Copy_Event(&copy, &one.input));
push(stop_act, sizeof(stop_act)); poll_parameter();
CHECK(IEC104_Parameter_Handle_Event(one.module, &copy) == IEC104_PARAMETER_EVENT_IGNORED);
close_fixture(&one);
++groups;
}
/**
* 功能:验证以下场景与约束:[真实观察槽背压] 直接占满 Slave 的 ACK 观察槽,不用故障钩子伪造 WAIT。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:释放后同一准备重试成功,再经真实 S 帧 ACK 完成一次 COMMIT。
*/
static void test_real_ack_capacity(void)
{
IEC104_SlaveAckReceipt_t receipts[IEC104_TCP_ACK_WATCH_CAPACITY];
IEC104_SlaveEventIdentity_t identity;
IEC60870_Asdu_t response;
uint8_t bytes[32]; size_t n;
unsigned i;
initial_values(); open_fixture(&one, P_ACK, 15000);
send_request(111, 6, 5002, 200, 1);
CHECK(IEC104_Slave_Get_Event_Identity(one.slave, &one.input, &identity));
n = request_bytes(bytes, 111, 7, 1, 5002, 100, 1);
CHECK(IEC60870_Asdu_Create_From_Buffer(&response, IEC104_Slave_Get_Application_Layer_Parameters(one.slave),
bytes, (uint16_t)n) == IEC60870_ASDU_OK);
for (i = 0; i < IEC104_TCP_ACK_WATCH_CAPACITY; ++i) {
CHECK(IEC104_Slave_Send_Response_Acked(one.slave, &identity, &response, &receipts[i]) == IEC104_TCP_SUBMIT_OK);
poll_parameter();
}
CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); status();
CHECK(one.status.waits == 1 && !one.status.ack_pending && one.status.confirm_pending);
for (i = 0; i < IEC104_TCP_ACK_WATCH_CAPACITY; ++i) { IEC104_Slave_Release_Ack(one.slave, &receipts[i]); }
flush(); CHECK(one.status.ack_pending); ack_all(); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK);
CHECK(one.commits == 1 && values[1].scaled == 200); close_fixture(&one);
++groups;
}
#if IEC104_TCP_SERVER_CAPACITY > 1
/* [应用预留] owners 独立于模块存储。A/B 是两个约束组,上下限共用 B;
* QPA=1 场景只演练同时取得 A/B 的预留,激活快照的实际应用另在 edge 测试覆盖。
* 肯定 PREPARE 持有预留到收尾;否定 PREPARE 没有 ABORT,须在返回前自行释放。 */
static uint64_t owners[2];
/**
* 功能:按约束组预留准备资源并检查上下限。
* 输入参数:context——业务回调的测试上下文;request——当前业务请求(只读)。
* 输出参数:无。
* 返回值:业务动作结果,保留应用成功、业务拒绝及未知对象等协议区别。
* 说明:冲突释放本次部分预留,COMMIT/ABORT释放全部持有项。
*/
static IEC104_ParameterActionResult_t reserved_action(void *context, const IEC104_ParameterRequest_t *request)
{
ParameterFixture *f = context;
IEC104_ParameterActionResult_t result;
unsigned first = request->operation == IEC104_PARAMETER_OP_LOAD && request->point_index >= 3 ? 1U : 0U;
unsigned last = request->operation == IEC104_PARAMETER_OP_LOAD ? first : 1U;
unsigned group;
if (request->phase == IEC104_PARAMETER_PHASE_COMMIT || request->phase == IEC104_PARAMETER_PHASE_ABORT) {
result = action(context, request);
for (group = first; group <= last; ++group) {
CHECK(owners[group] == request->instance_id); owners[group] = 0;
}
return result;
}
f->result = P_APPLIED;
for (group = first; group <= last; ++group) {
if (owners[group] != 0 && owners[group] != request->instance_id) {
/* 取得 A 后在 B 冲突,释放本次取得的 A;不能动另一实例持有的 B。 */
unsigned acquired;
for (acquired = first; acquired < group; ++acquired) {
CHECK(owners[acquired] == request->instance_id); owners[acquired] = 0;
}
f->result = P_REJECTED;
break;
}
if (request->phase == IEC104_PARAMETER_PHASE_PREPARE) { owners[group] = request->instance_id; }
}
if (f->result == P_APPLIED && request->operation == IEC104_PARAMETER_OP_LOAD &&
((request->point_index == 3 && request->value.scaled > values[4].scaled) ||
(request->point_index == 4 && request->value.scaled < values[3].scaled))) {
if (request->phase == IEC104_PARAMETER_PHASE_PREPARE) { owners[first] = 0; }
f->result = P_REJECTED;
}
return action(context, request);
}
/**
* 功能:使用带约束组预留的动作执行一次任务,并断言本次已完成动作或收尾交付。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void reserve_execute(void)
{
CHECK(IEC104_Parameter_Execute_Next(current->module, reserved_action, current) == IEC104_PARAMETER_EXECUTE_OK);
}
#endif
/**
* 功能:验证以下场景与约束:[跨实例取值] 两个实例串行共享数组,只保证读取时一致。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:A 已固定的旧确认
* 不因 B 写入而刷新,A 随后新形成的确认才应读到 B 的新值。
*/
static void test_cross_instance_values(void)
{
#if IEC104_TCP_SERVER_CAPACITY > 1
initial_values(); open_fixture(&one, 0, 15000); open_fixture(&two, 0, 15000);
select_fixture(&one); one.send_fault = 1;
send_request(111, 0x86, 5002, 999, 1); CHECK(IEC104_Parameter_Process(one.module));
select_fixture(&two); send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush();
select_fixture(&one); one.send_fault = 0; flush(); expect_reply(0, 111, 0x87, 1, 5002, 100, 1);
send_request(111, 0x86, 5002, 999, 1); flush(); expect_reply(1, 111, 0x87, 1, 5002, 200, 1);
close_fixture(&one); close_fixture(&two);
#else
puts("SKIP cross-instance confirmation values: TCP capacity < 2");
#endif
++groups;
}
/**
* 功能:验证以下场景与约束:[跨实例约束] A 准备上限 200 时 B 的下限 150 被预留阻挡。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:A 提交/放弃后 B
* 重试分别通过/拒绝。B 使用 ACK 和默认模式都须遵守同一应用预留。
*/
static void test_cross_instance_reservations(void)
{
#if IEC104_TCP_SERVER_CAPACITY > 1
unsigned commit, normal;
for (normal = 0; normal < 2; ++normal) for (commit = 0; commit < 2; ++commit) {
memset(owners, 0, sizeof(owners)); initial_values();
open_fixture(&one, P_ACK, 15000); open_fixture(&two, normal ? 0 : P_ACK, 15000);
select_fixture(&one); send_request(111, 6, 5005, 200, 4); reserve_execute(); flush(); CHECK(owners[1] != 0);
select_fixture(&two); send_request(111, 6, 5004, 150, 3); reserve_execute(); flush();
expect_reply(0, 111, 0x47, 1, 5004, 0, 3); CHECK(values[3].scaled == 0);
select_fixture(&one);
if (commit) { ack_all(); } else { IEC104_Parameter_Cancel(one.module); }
reserve_execute(); CHECK(owners[1] == 0);
select_fixture(&two); send_request(111, 6, 5004, 150, 3); reserve_execute(); flush();
expect_reply(1, 111, commit ? 7 : 0x47, 1, 5004, commit ? 150 : 0, 3);
if (commit && !normal) { ack_all(); reserve_execute(); }
CHECK(values[3].scaled <= values[4].scaled && owners[1] == 0);
close_fixture(&two); close_fixture(&one);
}
/* 多组准备在 B 冲突返回否定后,另一实例仍能取得 A,证明部分预留已释放。
* 先完成该实例原先 B 的收尾,再发新请求,避免被实例内串行屏障掩盖结果。 */
memset(owners, 0, sizeof(owners)); initial_values();
open_fixture(&one, P_ACK | IEC104_PARAMETER_EXT_QPA_LOADED, 15000);
open_fixture(&two, P_ACK | IEC104_PARAMETER_EXT_QPA_LOADED, 15000);
send_request(111, 6, 5005, 200, 4); reserve_execute(); flush();
select_fixture(&one); send_request(113, 6, 0, 0, 1); reserve_execute(); flush();
expect_reply(0, 113, 0x47, 1, 0, 0, 1); CHECK(owners[0] == 0 && owners[1] != 0);
CHECK(one.commits == 0 && one.aborts == 0 && execute() == IEC104_PARAMETER_EXECUTE_EMPTY);
select_fixture(&two); ack_all(); reserve_execute();
send_request(111, 6, 5002, 200, 1); reserve_execute(); flush();
expect_reply(1, 111, 7, 1, 5002, 200, 1); ack_all(); reserve_execute();
CHECK(owners[0] == 0 && owners[1] == 0); close_fixture(&two); close_fixture(&one);
#else
puts("SKIP D-40/D-44 reservations: TCP capacity < 2");
#endif
++groups;
}
/**
* 功能:运行参数编解码、执行/ACK期限、收尾和跨实例共享用例,并报告容量矩阵与结构尺寸。
* 输入参数:无。
* 输出参数:无。
* 返回值:正常完成返回 0;参数、运行或断言失败以非零状态结束进程。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
int main(void)
{
test_configuration(); test_load_results(); test_validation(); test_float_bits();
test_test_bit(); test_deadlines_and_retry(); test_fifo(); test_overload_and_lifetime();
test_extensions(); test_ack_success_and_loss(); test_prepare_timeout(); test_prepare_clock_and_disabled_deadline();
test_ack_submission_faults(); test_ack_blocking(); test_staged_commit_gate(); test_session_identity_and_destroy();
test_filters_and_truncation(); test_real_ack_capacity(); test_cross_instance_values();
test_cross_instance_reservations();
printf("Parameter: %u groups passed; TCP=%u tasks=%u request=%zu status=%zu point=%zu value=%zu\n",
groups, (unsigned)IEC104_TCP_SERVER_CAPACITY, (unsigned)IEC104_PARAMETER_TASK_CAPACITY,
sizeof(IEC104_ParameterRequest_t), sizeof(IEC104_ParameterStatus_t), sizeof(IEC104_ParameterPoint_t),
sizeof(IEC104_ParameterValue_t));
return 0;
}