359 lines
14 KiB
C
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;
|
|
}
|