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

359 lines
14 KiB
C

/* Boundary tests for the documented host protection simulation policy. */
#include "iec104_dtu_protection.h"
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
static DtuSettings settings;
static DtuProtection state;
static DtuProtectionInput input;
static DtuProtectionOutput output;
static void set_area(unsigned area, uint32_t ioa, double value)
{
size_t index = Dtu_Settings_Index(ioa);
assert(index < DTU_SETTINGS_COUNT && area < DTU_SETTINGS_AREAS);
settings.values[area][index] = Dtu_Settings_Tag(index) == 38U ? (double)(float)value : value;
}
static void set(uint32_t ioa, double value) { set_area(0U, ioa, value); }
static bool signal(uint16_t source) { return output.digital[source - DTU_PROTECTION_SOURCE_BASE] != 0U; }
static void step(uint64_t now)
{
input.now_ms = now;
Dtu_Protection_Step(&state, &settings, &input, &output);
}
static void fixture(void)
{
unsigned index;
Dtu_Settings_Init(&settings);
Dtu_Protection_Init(&state);
memset(&input, 0, sizeof(input));
for (index = 0U; index < 3U; ++index) { input.phase_current[index] = 0.4; }
input.pt_voltage[0] = input.pt_voltage[1] = 100.0;
input.frequency = 50.0;
input.control_voltage = 24.0;
input.zero_current = 0.005;
input.zero_voltage = 0.2;
input.breaker_closed = true;
set(0x8821U, 0.0); set(0x8822U, 0.0);
}
static void enable_trip(uint32_t base, double threshold, double delay)
{
set(base, 1.0); set(base + 1U, 1.0); set(base + 2U, threshold); set(base + 3U, delay);
}
static void test_pickup_and_feedback(void)
{
fixture();
enable_trip(0x8840U, 1.0, 0.5);
input.phase_current[1] = 1.0; /* Largest phase, inclusive threshold, t=0 valid. */
step(0U); assert(!output.trip_request && !signal(0x916aU));
step(499U); assert(!output.trip_request);
step(500U); assert(output.trip_request && output.trip_reasons == DTU_TRIP_PHASE);
assert(signal(0x916aU) && signal(0x9176U) && signal(0x918bU));
step(501U); assert(!output.trip_request); /* Await feedback, never spam outputs. */
input.breaker_closed = false;
step(502U); assert(!output.close_request && !signal(0x9176U));
input.breaker_closed = true;
step(503U); assert(!output.trip_request);
step(1003U); assert(output.trip_request);
fixture();
enable_trip(0x8840U, 1.0, 0.2);
input.phase_current[0] = 2.0;
step(0U); step(199U); assert(!output.trip_request);
input.phase_current[0] = 0.4;
step(200U);
input.phase_current[0] = 2.0;
step(201U); step(400U); assert(!output.trip_request);
step(401U); assert(output.trip_request); /* binary32 0.2 -> exactly 200 ms. */
}
static void test_all_stages_and_area(void)
{
unsigned index;
fixture();
for (index = 0U; index < 5U; ++index) { enable_trip(0x8840U + index * 4U, 1.0, 0.0); }
input.phase_current[0] = input.zero_current = 1.0;
step(0U);
assert(output.trip_request && output.trip_reasons == (DTU_TRIP_PHASE | DTU_TRIP_EARTH));
for (index = 0U; index < 5U; ++index) { assert(signal((uint16_t)(0x9176U + index))); }
assert(signal(0x918cU));
fixture();
enable_trip(0x8840U, 2.0, 0.0);
input.phase_current[0] = 1.0;
step(0U); assert(!output.trip_request);
set_area(1U, 0x8841U, 1.0); set_area(1U, 0x8842U, 1.0); set_area(1U, 0x8843U, 0.1);
settings.current_area = 1U;
step(10U); step(109U); assert(!output.trip_request);
step(110U); assert(output.trip_request);
}
static void test_hold_and_reset(void)
{
fixture();
enable_trip(0x8840U, 1.0, 0.0);
set(0x8821U, 0.1); set(0x8822U, 0.2);
input.phase_current[0] = 1.0;
step(0U); assert(output.trip_request);
input.breaker_closed = false;
step(199U); assert(signal(0x9176U) && !output.trip_request);
step(200U); assert(!signal(0x9176U)); /* Hold dominates shorter auto time. */
fixture();
set(0x8820U, 0.0); set(0x8843U, 0.0);
input.phase_current[0] = 2.0;
step(0U); assert(signal(0x916aU));
input.phase_current[0] = 0.4;
step(100000U); assert(signal(0x916aU));
Dtu_Protection_Reset(&state);
step(100001U); assert(!signal(0x916aU) && !output.trip_request);
}
static void test_blocks(void)
{
fixture(); enable_trip(0x8840U, 1.0, 0.0);
set(0x8871U, 1.0); input.phase_current[0] = 1.3; input.control_voltage = 19.9;
step(0U); assert(output.trip_blocked && output.close_blocked && !output.trip_request);
input.control_voltage = 20.0;
step(1U); assert(output.trip_request);
fixture(); enable_trip(0x8840U, 1.0, 0.0);
set(0x8861U, 1.0); input.phase_current[0] = 1.5;
step(0U); assert(output.trip_blocked && signal(0x9173U) && !output.trip_request);
input.phase_current[0] = 1.49;
step(1U); assert(output.trip_request);
fixture(); enable_trip(0x8840U, 1.0, 0.0);
set(0x8876U, 1.0); set(0x8879U, 0.1);
input.phase_current[0] = 1.3; input.second_harmonic = 0.2;
step(0U); step(99U); assert(signal(0x9170U) && !output.trip_request);
step(100U); assert(!signal(0x9170U) && output.trip_request);
fixture(); set(0x8857U, 1.0); set(0x885aU, 0.1);
input.phase_angle = 359.0;
step(0U); assert(!output.close_blocked);
input.phase_angle = 31.0;
step(1U); assert(output.close_blocked && signal(0x9191U));
input.phase_angle = 0.0;
step(2U); step(101U); assert(output.close_blocked);
step(102U); assert(!output.close_blocked);
fixture(); set(0x8873U, 1.0); set(0x8878U, 0.2);
input.frequency = 46.9;
step(0U); step(199U); assert(!output.close_blocked);
step(200U); assert(output.close_blocked && !output.trip_request);
input.frequency = 47.0;
step(201U); assert(!output.close_blocked);
}
static void test_alarms_and_classification(void)
{
fixture();
set(0x8047U, 0.1); set(0x8049U, 0.1); set(0x804bU, 0.1);
set(0x8883U, 1.0); set(0x8885U, 0.1);
input.phase_current[0] = 1.0; input.negative_current = 0.2;
step(0U); step(99U); assert(!signal(0x916dU));
step(100U); assert(signal(0x916dU) && signal(0x916eU) && signal(0x916fU) && signal(0x9166U));
assert(!output.trip_request);
fixture(); set(0x8836U, 0.1);
step(0U); assert(output.voltage_state[0] == 4U && !signal(0x9141U));
step(100U); assert(output.voltage_state[0] == 3U && signal(0x914fU));
input.pt_voltage[0] = 30.0;
step(101U); step(200U); assert(output.voltage_state[0] == 3U);
step(201U); assert(output.voltage_state[0] == 1U && signal(0x9141U));
input.pt_voltage[0] = 10.0;
step(202U); step(302U); assert(output.voltage_state[0] == 0U);
input.pt_voltage[0] = 31.0;
step(303U); step(403U); assert(output.voltage_state[0] == 2U);
input.pt_voltage[0] = 80.0;
step(404U); step(504U); assert(output.voltage_state[0] == 3U);
fixture(); input.pt_voltage[0] = 80.0; input.pt_voltage[1] = 110.0;
step(0U); step(200U); assert(signal(0x9152U) && signal(0x9156U));
fixture(); set(0x8831U, 1.0); set(0x8832U, 0.1); set(0x8836U, 0.0);
input.pt_voltage[0] = 0.0;
step(0U); step(100U); assert(signal(0x918eU));
}
static void test_external_faults_and_recording(void)
{
fixture(); set(0x8855U, 0.1); set(0x8881U, 1.0); set(0x8882U, 0.2); set(0x8856U, 1.0);
input.small_earth_fault = true;
step(0U); step(100U); assert(signal(0x918dU) && signal(0x9168U) && !output.trip_request);
step(200U); assert(output.trip_request && output.trip_reasons == DTU_TRIP_SMALL_EARTH);
fixture(); set(0x8877U, 1.0); input.non_electrical_fault = true;
step(0U); assert(output.trip_request && output.trip_reasons == DTU_TRIP_EXTERNAL);
input.breaker_closed = false;
step(1U); assert(output.close_blocked && !output.close_request);
fixture();
set(0x804cU, 1.0); set(0x804dU, 1.0); set(0x804eU, 1.0); set(0x804fU, 1.0);
step(0U); assert(output.recording_reasons == 0U);
input.phase_current[0] = 2.0; input.pt_voltage[0] = 0.0;
input.zero_current += 0.5; input.zero_voltage += 20.0;
step(1U); assert(output.recording_reasons == 15U && signal(0x9186U));
step(2U); assert(output.recording_reasons == 0U);
input.phase_current[0] = 0.4; input.pt_voltage[0] = 100.0;
step(3U); assert(output.recording_reasons == 0U);
input.phase_current[0] = 2.0;
step(4U); assert(output.recording_reasons == DTU_RECORD_OVERCURRENT);
}
static void reclose_fixture(void)
{
fixture();
enable_trip(0x8840U, 1.0, 0.0);
set(0x8863U, 1.0); set(0x8864U, 3.0);
set(0x8865U, 0.1); set(0x8866U, 0.2); set(0x8867U, 0.3);
set(0x887eU, 0.0); /* Test maximum attempts independently of open-count lock. */
input.phase_current[0] = 1.3;
}
static void test_reclosing(void)
{
uint64_t now = 0U;
unsigned attempt;
reclose_fixture();
for (attempt = 0U; attempt < 3U; ++attempt) {
uint64_t wait = (uint64_t)(attempt + 1U) * 100U;
input.breaker_closed = true;
step(now); assert(output.trip_request && !output.close_request);
input.breaker_closed = false;
step(++now); assert(!output.close_request);
step(now + wait - 1U); assert(!output.close_request);
now += wait;
step(now); assert(output.close_request && !output.trip_request && output.reclose_attempts == attempt + 1U);
step(++now); assert(!output.close_request); /* One pulse while awaiting feedback. */
}
input.breaker_closed = true;
step(++now); assert(output.trip_request);
input.breaker_closed = false;
step(++now); assert(output.close_blocked && signal(0x9174U));
step(now + 1000000U); assert(!output.close_request && output.reclose_attempts == 3U);
Dtu_Protection_Reset(&state);
step(now + 1000001U); assert(!output.close_blocked && output.reclose_attempts == 0U);
reclose_fixture(); set(0x886dU, 1.0); set(0x886eU, 1.2);
step(0U); assert(output.trip_request && output.close_blocked && signal(0x9175U));
input.breaker_closed = false; input.phase_current[0] = 0.0;
step(1U); step(10000U); assert(!output.close_request && output.close_blocked);
reclose_fixture(); set(0x887eU, 1.0);
step(0U); input.breaker_closed = false;
step(1U); assert(output.close_blocked);
reclose_fixture(); set(0x887bU, 1.0); set(0x887cU, 0.2); set(0x8836U, 0.0);
step(0U); input.breaker_closed = false;
step(1U); step(200U); assert(!output.close_request);
step(201U); assert(output.close_request);
reclose_fixture();
step(0U); assert(output.trip_request);
input.breaker_closed = false; input.external_close_blocked = true;
step(1U); step(1000U);
assert(output.close_blocked && !output.close_request && output.reclose_attempts == 0U);
input.external_close_blocked = false;
step(1001U); assert(output.close_request && output.reclose_attempts == 1U);
step(1002U); assert(!output.close_request && output.reclose_attempts == 1U);
}
static void test_acceleration_and_group_reset(void)
{
reclose_fixture();
set(0x885bU, 1.0); set(0x885cU, 0.5); set(0x885dU, 0.1);
step(0U); input.breaker_closed = false;
step(1U); step(101U); assert(output.close_request);
input.breaker_closed = true; input.phase_current[0] = 0.6;
step(102U); step(201U); assert(!output.trip_request);
step(202U); assert(output.trip_request &&
output.trip_reasons == (DTU_TRIP_PHASE | DTU_TRIP_ACCELERATED) && signal(0x9181U));
reclose_fixture(); set(0x886fU, 0.2);
step(0U); input.breaker_closed = false;
step(1U); step(101U); assert(output.close_request);
input.breaker_closed = true; input.phase_current[0] = 0.4;
step(102U); step(301U); assert(output.reclose_attempts == 1U);
step(302U); assert(output.reclose_attempts == 0U);
}
static void test_operator_cancels_reclose(void)
{
fixture();
/* Ordinary manual opening must not require a protection reset to reclose. */
step(0U); assert(!output.close_blocked);
Dtu_Protection_Cancel_Reclose(&state, 1U);
assert(!state.locked);
input.breaker_closed = false;
step(2U); assert(!output.close_blocked && !output.close_request);
input.breaker_closed = true;
step(3U); assert(!output.close_blocked && !output.trip_request);
reclose_fixture(); set(0x8820U, 0.0); set(0x886fU, 0.1); set(0x8870U, 0.1);
step(0U); assert(output.trip_request && signal(0x9176U));
/* Cancel even before the protection receives opening feedback. */
Dtu_Protection_Cancel_Reclose(&state, 1U);
input.breaker_closed = false;
step(2U); step(100000U);
assert(output.close_blocked && !output.close_request && signal(0x9176U));
assert(output.reclose_attempts == 0U);
/* A later operator close with a healthy interval starts an independent group. */
input.breaker_closed = true; input.phase_current[0] = 0.4;
step(100001U); step(100101U); assert(!output.close_blocked);
input.phase_current[0] = 1.3;
step(100102U); assert(output.trip_request);
input.breaker_closed = false;
step(100103U); step(100203U); assert(output.close_request);
reclose_fixture(); step(0U); input.breaker_closed = false; step(1U);
assert(state.pending_reclose);
Dtu_Protection_Cancel_Reclose(&state, 50U);
step(5000U); assert(!output.close_request && output.close_blocked);
Dtu_Protection_Reset(&state);
step(5001U); assert(!output.close_blocked);
}
static void test_invalid_and_clock(void)
{
fixture(); enable_trip(0x8840U, 1.0, 0.1); input.phase_current[0] = 1.3;
step(100U); step(199U); assert(!output.trip_request);
step(99U); assert(!output.input_valid && !output.trip_request && output.close_blocked);
step(100U); step(199U); assert(!output.trip_request);
step(200U); assert(output.trip_request);
input.phase_current[0] = NAN;
step(201U); assert(!output.input_valid && !output.trip_request && !output.close_request);
input.phase_current[0] = 0.4;
step(202U); assert(output.input_valid && output.close_blocked);
assert(Dtu_Protection_Manages_Source(0x9176U));
assert(Dtu_Protection_Indicator_Source(0x916aU));
assert(Dtu_Protection_Indicator_Source(0x9176U));
assert(Dtu_Protection_Manages_Source(0x914fU));
assert(!Dtu_Protection_Indicator_Source(0x914fU));
assert(!Dtu_Protection_Indicator_Source(0xffffU));
assert(!Dtu_Protection_Manages_Source(0x918aU));
assert(!Dtu_Protection_Manages_Source(0xffffU));
assert(sizeof(DtuProtection) < 1500U);
}
int main(void)
{
test_pickup_and_feedback();
test_all_stages_and_area();
test_hold_and_reset();
test_blocks();
test_alarms_and_classification();
test_external_faults_and_recording();
test_reclosing();
test_acceleration_and_group_reset();
test_operator_cancels_reclose();
test_invalid_and_clock();
puts("DTU protection state-machine tests passed");
return 0;
}