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

405 lines
18 KiB
C

/* 参数协作边界测试:使用真实 Slave、参数模块和总召引擎,网络由可控夹具提供。
* 导航:公共夹具 -> 110..112 总召批次 -> STOP 后激活快照 -> 否定准备无需收尾。
* 补充主状态机测试,重点核对跨模块提交契约和应用资源寿命。 */
#include "iec104_test_config.h"
#include "iec104_tcp_fixture.h"
#include "IEC104_Parameter.h"
#include "IEC104_GeneralInterrogation.h"
static const IEC104_ParameterPoint_t edge_points[] = {
{1, 110, 1, 5001}, {1, 111, 1, 5002}, {1, 112, 2, 5003}
};
static struct {
IEC104_Slave_t *slave;
IEC104_Parameter_t *parameter;
IEC104_Interrogation_t *gi;
IEC104_Station_t station;
IEC104_ParameterValue_t values[3];
IEC104_ParameterActionResult_t result;
IEC104_ParameterRequest_t preparation;
unsigned ns, nr, calls, commits, aborts;
bool staged_valid, snapshot_valid, activation;
int16_t staged, snapshot;
} edge;
static unsigned edge_groups;
/**
* 功能:读取当前参数模块状态,查询失败立即终止用例,成功返回独立值副本。
* 输入参数:无。
* 输出参数:无。
* 返回值:按值返回的当前状态或信息快照。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static IEC104_ParameterStatus_t parameter_status(void)
{
IEC104_ParameterStatus_t result;
CHECK(IEC104_Parameter_Get_Status(edge.parameter, &result));
return result;
}
/**
* 功能:STOP/断线清除会话暂存,但不能清除已经交给肯定准备持有的激活快照。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:快照是否提交由 ACK 收尾决定,寿命不再依附当前连接。
*/
static void edge_events(void)
{
IEC104_SlaveEvent_t event;
IEC104_TcpEventResult_t next;
while ((next = IEC104_Slave_NextEvent(edge.slave, &event)) == IEC104_TCP_EVENT_READY) {
CHECK(IEC104_Parameter_Handle_Event(edge.parameter, &event) != IEC104_PARAMETER_EVENT_ERROR);
if (edge.gi != NULL)
CHECK(IEC104_Interrogation_Handle_Event(edge.gi, &event) != IEC104_INTERROGATION_EVENT_ERROR);
if (event.transport.type == IEC104_TCP_EVENT_CONNECTED ||
event.transport.type == IEC104_TCP_EVENT_DEACTIVATED ||
event.transport.type == IEC104_TCP_EVENT_DISCONNECTED) edge.staged_valid = false;
}
CHECK(next == IEC104_TCP_EVENT_EMPTY);
}
/**
* 功能:非阻塞推进一次真实Slave,并按FIFO向参数模块和可选总召模块分派全部通知。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void edge_poll(void)
{
CHECK(IEC104_Slave_Poll(edge.slave, 0, NULL) == IEC104_TCP_OK);
edge_events();
}
/**
* 功能:固定推进八轮传输和参数确认,不执行应用动作,也不代主站确认I帧。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void edge_flush(void)
{
unsigned i;
for (i = 0; i < 8U; ++i) {
edge_poll();
CHECK(IEC104_Parameter_Process(edge.parameter));
}
}
/**
* 功能:准备固定激活输入,COMMIT 按快照更新运行值,ABORT 仅释放快照。
* 输入参数:context——业务回调的测试上下文;request——当前业务请求(只读)。
* 输出参数:无。
* 返回值:业务动作结果,保留应用成功、业务拒绝及未知对象等协议区别。
* 说明:同时检查收尾保留原请求身份和 accepted_ms;普通收尾本身不再产生确认。
*/
static IEC104_ParameterActionResult_t edge_action(void *context, const IEC104_ParameterRequest_t *request)
{
IEC104_ParameterStatus_t status = parameter_status();
CHECK(context == &edge);
++edge.calls;
if (request->phase == IEC104_PARAMETER_PHASE_PREPARE) {
CHECK(status.confirm_pending);
edge.preparation = *request;
if (edge.activation) {
CHECK(request->operation == IEC104_PARAMETER_OP_ACTIVATE && request->qpa == 1U);
CHECK(edge.staged_valid && !edge.snapshot_valid);
edge.snapshot = edge.staged;
edge.snapshot_valid = true;
}
return edge.result;
}
CHECK(request->phase == IEC104_PARAMETER_PHASE_COMMIT || request->phase == IEC104_PARAMETER_PHASE_ABORT);
CHECK(!status.confirm_pending);
CHECK(request->instance_id == edge.preparation.instance_id &&
request->generation == edge.preparation.generation &&
request->receive_serial == edge.preparation.receive_serial &&
request->accepted_ms == edge.preparation.accepted_ms);
CHECK(request->prepared == IEC104_PARAMETER_ACTION_APPLIED);
if (request->phase == IEC104_PARAMETER_PHASE_COMMIT) {
++edge.commits;
CHECK(edge.snapshot_valid);
edge.values[1].scaled = edge.snapshot;
} else ++edge.aborts;
edge.snapshot_valid = false;
return IEC104_PARAMETER_ACTION_REJECTED; /* 收尾返回值不影响已完成的协议确认。 */
}
/**
* 功能:重置网络和业务夹具,绑定三种参数点及可选总召实例,再建立已STARTDT的连接。
* 输入参数:extensions——参数服务扩展功能位;interrogation——是否建立总召模块。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void edge_open(uint8_t extensions, bool interrogation)
{
IEC104_SlaveConfig_t transport;
IEC104_ParameterConfig_t parameter;
IEC104_InterrogationConfig_t gi;
memset(&fake, 0, sizeof(fake));
memset(&edge, 0, sizeof(edge));
fake.now = 1000;
edge.values[0].normalized = 100;
edge.values[1].scaled = 100;
edge.values[2].short_float = 1.0f;
edge.slave = IEC104_Slave_Create(); CHECK(edge.slave != NULL);
CHECK(IEC104_Slave_Add_Station(edge.slave, &edge.station, 1, &edge) == IEC104_STATION_OK);
IEC104_Parameter_Config_Default(&parameter);
parameter.points = edge_points; parameter.point_count = 3; parameter.values = edge.values;
parameter.extensions = extensions;
edge.parameter = IEC104_Parameter_Create(edge.slave, &parameter); CHECK(edge.parameter != NULL);
if (interrogation) {
test_interrogation_config(&gi); gi.station = &edge.station;
edge.gi = IEC104_Interrogation_Create(edge.slave, &gi); CHECK(edge.gi != NULL);
}
test_transport_config(&transport); transport.protocol.link.k = 32;
CHECK(IEC104_Slave_Init(edge.slave, &transport, NULL) == IEC104_TCP_OK);
fake.accept_pending = 1; edge_poll();
push(start_act, sizeof(start_act)); edge_poll();
CHECK(parameter_status().active);
}
/**
* 功能:关闭前取消观察并清理会话暂存。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:关闭后仍交付已确定的收尾,再销毁模块。
* 快照和 action context 在收尾完成前保持有效,总召事件也须消费后再 Destroy。
*/
static void edge_close(void)
{
IEC104_InterrogationEvent_t event;
IEC104_Parameter_Cancel(edge.parameter); edge.staged_valid = false;
if (edge.gi != NULL) IEC104_Interrogation_Cancel(edge.gi);
CHECK(IEC104_Slave_Close(edge.slave, NULL) == IEC104_TCP_OK); edge_events();
while (parameter_status().finish_pending)
CHECK(IEC104_Parameter_Execute_Next(edge.parameter, edge_action, &edge) == IEC104_PARAMETER_EXECUTE_OK);
CHECK(IEC104_Parameter_Destroy(edge.parameter));
if (edge.gi != NULL) {
while (IEC104_Interrogation_NextEvent(edge.gi, &event) == IEC104_INTERROGATION_NEXT_READY) {}
CHECK(IEC104_Interrogation_Destroy(edge.gi));
}
CHECK(IEC104_Slave_Remove_Station(edge.slave, &edge.station) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Destroy(edge.slave, NULL) == IEC104_TCP_OK);
}
/**
* 功能:将ASDU按当前收发序号装入I帧并立即分派。
* 输入参数:bytes——报文字节缓冲区(只读);size——数据长度或文件大小。
* 输出参数:无。
* 返回值:无。
* 说明:只递增主站发送序号,不自动追加ACK。
*/
static void edge_send(const uint8_t *bytes, size_t size)
{
uint8_t frame[64] = {0x68};
CHECK(size + 6 <= sizeof(frame));
frame[1] = (uint8_t)(size + 4);
frame[2] = (uint8_t)(edge.ns << 1); frame[3] = (uint8_t)(edge.ns >> 7);
frame[4] = (uint8_t)(edge.nr << 1); frame[5] = (uint8_t)(edge.nr >> 7); ++edge.ns;
memcpy(frame + 6, bytes, size); push(frame, size + 6); edge_poll();
}
/**
* 功能:扫描累计输出,确认其中最后一条I帧后推进参数处理。
* 输入参数:无。
* 输出参数:无。
* 返回值:本次收集或统计到的有效业务帧数量。
* 说明:返回输出中I帧总数。
*/
static unsigned edge_ack_all(void)
{
size_t offset = 0;
unsigned count = 0;
while (offset < fake.sent_bytes) {
const uint8_t *frame = fake.output + offset;
CHECK(offset + frame[1] + 2U <= fake.sent_bytes);
if ((frame[2] & 1U) == 0U) {
edge.nr = (((unsigned)frame[2] >> 1) | ((unsigned)frame[3] << 7)) + 1U;
++count;
}
offset += frame[1] + 2U;
}
push_ack(edge.nr); edge_poll(); CHECK(IEC104_Parameter_Process(edge.parameter));
return count;
}
/**
* 功能:最多推进八轮等待下一条总召事件,并断言其类型。
* 输入参数:type——协议类型或期望事件类型。
* 输出参数:无。
* 返回值:已构造或取出的事件值副本。
* 说明:超出轮数或顺序错误即失败。
*/
static IEC104_InterrogationEvent_t gi_next(IEC104_InterrogationEventType_t type)
{
IEC104_InterrogationEvent_t event;
unsigned i;
for (i = 0; i < 8U; ++i) {
CHECK(IEC104_Interrogation_Process(edge.gi));
if (IEC104_Interrogation_NextEvent(edge.gi, &event) == IEC104_INTERROGATION_NEXT_READY) {
CHECK(event.type == type); return event;
}
edge_poll();
}
CHECK(false);
memset(&event, 0, sizeof(event));
return event;
}
/**
* 功能:验证以下场景与约束:[总召批次] 遍历 COT 20..36 和三种参数类型,验证真实 Submit_Batch 路径。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:原始字节包装可构造公共 Add 接口禁止的 SQ=1/多对象批次,避免只测白名单。
*/
static void test_interrogation_parameter_batches(void)
{
unsigned qoi, type;
for (qoi = 20; qoi <= 36; ++qoi) {
uint8_t request[] = {100, 1, 6, 0x5A, 1, 0, 0, 0, 0, 20};
IEC104_InterrogationEvent_t event;
size_t offset;
unsigned observed = 0;
edge_open(0, true); request[9] = (uint8_t)qoi; edge_send(request, sizeof(request));
event = gi_next(IEC104_INTERROGATION_BEGIN);
CHECK(IEC104_Interrogation_Reply_Begin(edge.gi, &event, true) == IEC104_INTERROGATION_REPLY_OK);
for (type = 110; type <= 112; ++type) {
uint8_t bytes[32] = {0};
uint16_t length = type == 112 ? 14U : 12U;
unsigned ioa = 5001U + type - 110U;
IEC60870_Asdu_t batch;
const IEC60870_AppLayerParameters_t *parameters = IEC104_Slave_Get_Application_Layer_Parameters(edge.slave);
event = gi_next(IEC104_INTERROGATION_NEED_DATA);
CHECK(event.request.data_cause == qoi && event.batch_index == type - 110U);
bytes[0] = (uint8_t)type; bytes[1] = 1; bytes[2] = (uint8_t)qoi;
bytes[3] = 0x5A; bytes[4] = 1; bytes[6] = (uint8_t)ioa; bytes[7] = (uint8_t)(ioa >> 8);
bytes[9] = 100; bytes[length - 1U] = (uint8_t)(type == 112 ? 2 : 1);
if (type == 112) { bytes[9] = 0; bytes[11] = 0x80; bytes[12] = 0x3F; }
/* 格式 ERROR 不消费 NEED_DATA;修正为单对象后仍用同一事件成功提交。 */
bytes[1] = 0x81;
CHECK(IEC60870_Asdu_Create_From_Buffer(&batch, parameters, bytes, length) == IEC60870_ASDU_OK);
CHECK(IEC104_Interrogation_Submit_Batch(edge.gi, &event, &batch) == IEC104_INTERROGATION_REPLY_ERROR);
bytes[1] = 2; memcpy(bytes + length, bytes + 6, length - 6U);
CHECK(IEC60870_Asdu_Create_From_Buffer(&batch, parameters, bytes, (uint16_t)(2U * length - 6U)) == IEC60870_ASDU_OK);
CHECK(IEC104_Interrogation_Submit_Batch(edge.gi, &event, &batch) == IEC104_INTERROGATION_REPLY_ERROR);
bytes[1] = 1;
CHECK(IEC60870_Asdu_Create_From_Buffer(&batch, parameters, bytes, length) == IEC60870_ASDU_OK);
CHECK(IEC104_Interrogation_Submit_Batch(edge.gi, &event, &batch) == IEC104_INTERROGATION_REPLY_OK);
}
event = gi_next(IEC104_INTERROGATION_NEED_DATA);
CHECK(event.batch_index == 3 && event.objects_submitted == 3);
CHECK(IEC104_Interrogation_Complete_Data(edge.gi, &event) == IEC104_INTERROGATION_REPLY_OK);
event = gi_next(IEC104_INTERROGATION_FINISHED);
CHECK(event.reason == IEC104_INTERROGATION_FINISH_COMPLETED);
edge_flush();
for (offset = 0; offset < fake.sent_bytes; offset += fake.output[offset + 1U] + 2U) {
const uint8_t *frame = fake.output + offset;
if ((frame[2] & 1U) == 0U && frame[6] >= 110U && frame[6] <= 112U) {
CHECK(frame[7] == 1 && frame[8] == qoi && frame[9] == 0x5A);
observed |= 1U << (frame[6] - 110U);
}
}
CHECK(observed == 7); edge_close();
}
++edge_groups;
}
/**
* 功能:验证以下场景与约束:[激活快照] 暂存 345、运行值 100,准备 QPA=1 后在 ACK 前/后分别 STOP。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:两条路径都会清暂存,但已 ACK 的 APPLIED 仍从快照提交 345,未 ACK 的只放弃。
*/
static void test_activation_snapshot(void)
{
const uint8_t request[] = {113, 1, 6, 0x5A, 1, 0, 0, 0, 0, 1};
unsigned commit;
for (commit = 0; commit < 2; ++commit) {
edge_open(IEC104_PARAMETER_EXT_APPLY_ON_ACK | IEC104_PARAMETER_EXT_QPA_LOADED, false);
edge.staged_valid = true; edge.staged = 345; edge.activation = true;
edge.result = IEC104_PARAMETER_ACTION_APPLIED;
edge_send(request, sizeof(request));
CHECK(IEC104_Parameter_Execute_Next(edge.parameter, edge_action, &edge) == IEC104_PARAMETER_EXECUTE_OK);
edge_flush(); CHECK(edge.snapshot_valid && edge.values[1].scaled == 100);
if (commit) { CHECK(edge_ack_all() == 1); CHECK(parameter_status().finish_pending); }
push(stop_act, sizeof(stop_act)); edge_poll();
CHECK(!edge.staged_valid && edge.snapshot_valid);
CHECK(IEC104_Parameter_Execute_Next(edge.parameter, edge_action, &edge) == IEC104_PARAMETER_EXECUTE_OK);
CHECK(edge.commits == commit && edge.aborts == 1U - commit && !edge.snapshot_valid);
CHECK(edge.values[1].scaled == (commit ? 345 : 100));
CHECK(IEC104_Parameter_Execute_Next(edge.parameter, edge_action, &edge) == IEC104_PARAMETER_EXECUTE_EMPTY);
edge_close();
}
++edge_groups;
}
/**
* 功能:验证以下场景与约束:[否定准备] REJECTED、UNKNOWN、非法枚举和不合法 STAGED 均只调用一次动作。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:即使否定确认随后被 ACK,也没有 COMMIT/ABORT;动作不得把临时资源留给收尾。
* 同时核对 UNKNOWN 保留请求值,其余装载否定确认报告运行值。
*/
static void test_negative_prepare_has_no_finish(void)
{
static const IEC104_ParameterActionResult_t results[] = {
IEC104_PARAMETER_ACTION_REJECTED, IEC104_PARAMETER_ACTION_UNKNOWN_IOA,
(IEC104_ParameterActionResult_t)99, IEC104_PARAMETER_ACTION_STAGED,
IEC104_PARAMETER_ACTION_STAGED
};
unsigned i;
for (i = 0; i < sizeof(results) / sizeof(results[0]); ++i) {
uint8_t request[] = {111, 1, 6, 0x5A, 1, 0, 0x8A, 0x13, 0, 200, 0, 1};
IEC104_ParameterStatus_t status;
size_t offset;
unsigned observed = 0;
edge_open((uint8_t)(IEC104_PARAMETER_EXT_APPLY_ON_ACK |
(i == 4U ? IEC104_PARAMETER_EXT_QPA_LOADED : 0)), false);
edge.result = results[i];
if (i == 4U) { request[0] = 113; request[6] = request[7] = 0; request[9] = 1; }
edge_send(request, i == 4U ? 10U : sizeof(request));
CHECK(IEC104_Parameter_Execute_Next(edge.parameter, edge_action, &edge) == IEC104_PARAMETER_EXECUTE_OK);
edge_flush(); status = parameter_status();
CHECK(status.executed == 1 && status.applied == 0 && status.staged == 0);
CHECK(status.negative_submitted == 1 && status.pending_requests == 0);
CHECK(!status.ack_pending && !status.finish_pending && edge.calls == 1);
CHECK(IEC104_Parameter_Execute_Next(edge.parameter, edge_action, &edge) == IEC104_PARAMETER_EXECUTE_EMPTY);
for (offset = 0; offset < fake.sent_bytes; offset += fake.output[offset + 1U] + 2U) {
const uint8_t *frame = fake.output + offset;
if ((frame[2] & 1U) == 0U) {
CHECK(frame[8] == (i == 1U ? 0x6F : 0x47));
if (i != 4U) CHECK(frame[15] == (i == 1U ? 200 : 100) && frame[16] == 0);
++observed;
}
}
CHECK(observed == 1); CHECK(edge_ack_all() == 1);
CHECK(IEC104_Parameter_Execute_Next(edge.parameter, edge_action, &edge) == IEC104_PARAMETER_EXECUTE_EMPTY);
CHECK(edge.calls == 1 && edge.commits == 0 && edge.aborts == 0); edge_close();
}
++edge_groups;
}
/**
* 功能:依次验证参数总召批次、STOP前后的激活快照寿命及否定准备无需收尾。
* 输入参数:无。
* 输出参数:无。
* 返回值:正常完成返回 0;参数、运行或断言失败以非零状态结束进程。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
int main(void)
{
test_interrogation_parameter_batches();
test_activation_snapshot();
test_negative_prepare_has_no_finish();
printf("Parameter edges: %u groups passed\n", edge_groups);
return 0;
}