ismail
9a6b8c9f80
The tilt sensitivity values were passed to the NVS module without the boundaries being checked, even though the maximum percent value is 100. This commit fixes this issue. Also test cases are added to cover the upper boundary checks for the tilt sensitivity settings. Fixes #1086
401 lines
17 KiB
C
401 lines
17 KiB
C
#include "test_common.h"
|
|
|
|
|
|
// ### Tilt Functionality Tests (Conditional)
|
|
|
|
// This section will only be compiled if **`CONFIG_RELAY_CHN_ENABLE_TILTING`** is defined as **`1`** in `sdkconfig`.
|
|
|
|
#ifndef CONFIG_RELAY_CHN_ENABLE_TILTING
|
|
#error "This test requires CONFIG_RELAY_CHN_ENABLE_TILTING"
|
|
#endif
|
|
|
|
#define RELAY_CHN_CMD_FORWARD 1
|
|
#define RELAY_CHN_CMD_REVERSE 2
|
|
|
|
void check_all_channels_for_state(relay_chn_state_t state)
|
|
{
|
|
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
|
|
TEST_ASSERT_EQUAL(state, relay_chn_get_state(i));
|
|
}
|
|
}
|
|
|
|
// Helper function to prepare channel for tilt tests
|
|
void prepare_channels_for_tilt_with_mixed_runs() {
|
|
// Ensure the channel reset tilt control
|
|
relay_chn_tilt_stop_all();
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
|
|
|
|
// Ensure the channel has had a 'last_run_cmd'
|
|
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
|
|
if (i % 2 == 0) {
|
|
relay_chn_run_forward(i);
|
|
} else { // Assuming initial_cmd is RELAY_CHN_CMD_REVERSE
|
|
relay_chn_run_reverse(i);
|
|
}
|
|
}
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); // Allow command to process
|
|
relay_chn_stop_all(); // Stop it to set last_run_cmd but return to FREE for next test
|
|
vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
|
|
check_all_channels_for_state(RELAY_CHN_STATE_IDLE);
|
|
}
|
|
|
|
// Helper function to prepare channel for tilt tests
|
|
void prepare_all_channels_for_tilt(int initial_cmd) {
|
|
// Ensure the channel reset tilt control
|
|
relay_chn_tilt_stop_all();
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
|
|
|
|
// If the channels are not IDLE yet, wait more
|
|
bool not_idle = false;
|
|
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
|
|
if (relay_chn_get_state(i) != RELAY_CHN_STATE_IDLE) {
|
|
not_idle = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (not_idle) {
|
|
vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS));
|
|
}
|
|
|
|
// Ensure the channel has had a 'last_run_cmd'
|
|
if (initial_cmd == RELAY_CHN_CMD_FORWARD) {
|
|
relay_chn_run_forward_all();
|
|
} else { // Assuming initial_cmd is RELAY_CHN_CMD_REVERSE
|
|
relay_chn_run_reverse_all();
|
|
}
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); // Allow command to process
|
|
relay_chn_stop_all(); // Stop all to set last_run_cmd but return to FREE for next test
|
|
vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
|
|
|
|
check_all_channels_for_state(RELAY_CHN_STATE_IDLE);
|
|
}
|
|
|
|
// TEST_CASE: Test transition from running forward to tilt forward
|
|
// Scenario: RELAY_CHN_STATE_FORWARD -> (relay_chn_tilt_forward) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_TILT_FORWARD
|
|
TEST_CASE("Run Forward to Tilt Forward transition with inertia", "[relay_chn][tilt][inertia]")
|
|
{
|
|
// Prepare channel by running forward first to set last_run_cmd
|
|
prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD);
|
|
|
|
// 1. Start in forward direction
|
|
relay_chn_run_forward_all();
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
|
|
check_all_channels_for_state(RELAY_CHN_STATE_FORWARD);
|
|
|
|
// 2. Issue tilt forward command
|
|
relay_chn_tilt_forward_all();
|
|
// After tilt command, it should immediately stop and then trigger inertia.
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
|
|
check_all_channels_for_state(RELAY_CHN_STATE_STOPPED);
|
|
|
|
// Wait for the inertia period (after which the tilt command will be dispatched)
|
|
vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS));
|
|
check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD);
|
|
}
|
|
|
|
// TEST_CASE: Test transition from running reverse to tilt reverse
|
|
// Scenario: RELAY_CHN_STATE_REVERSE -> (relay_chn_tilt_reverse) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_TILT_REVERSE
|
|
TEST_CASE("Run Reverse to Tilt Reverse transition with inertia", "[relay_chn][tilt][inertia]")
|
|
{
|
|
// Prepare channel by running reverse first to set last_run_cmd
|
|
prepare_all_channels_for_tilt(RELAY_CHN_CMD_REVERSE);
|
|
|
|
// 1. Start in reverse direction
|
|
relay_chn_run_reverse_all();
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
|
|
check_all_channels_for_state(RELAY_CHN_STATE_REVERSE);
|
|
|
|
// 2. Issue tilt reverse command
|
|
relay_chn_tilt_reverse_all();
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
|
|
check_all_channels_for_state(RELAY_CHN_STATE_STOPPED);
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
|
|
check_all_channels_for_state(RELAY_CHN_STATE_TILT_REVERSE);
|
|
}
|
|
|
|
// TEST_CASE: Test transition from FREE state to tilt forward (now with preparation)
|
|
// Scenario: RELAY_CHN_STATE_IDLE -> (prepare) -> RELAY_CHN_STATE_IDLE -> (relay_chn_tilt_forward) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_TILT_FORWARD
|
|
TEST_CASE("FREE to Tilt Forward transition with inertia (prepared)", "[relay_chn][tilt][inertia]")
|
|
{
|
|
// Prepare channel by running forward first to set last_run_cmd
|
|
prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD);
|
|
|
|
// Issue tilt forward command
|
|
relay_chn_tilt_forward_all();
|
|
// From FREE state, tilt command should still incur the inertia due to the internal timer logic
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
|
|
check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD);
|
|
}
|
|
|
|
// TEST_CASE: Test transition from FREE state to tilt reverse (now with preparation)
|
|
// Scenario: RELAY_CHN_STATE_IDLE -> (prepare) -> RELAY_CHN_STATE_IDLE -> (relay_chn_tilt_reverse) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_TILT_REVERSE
|
|
TEST_CASE("FREE to Tilt Reverse transition with inertia (prepared)", "[relay_chn][tilt][inertia]")
|
|
{
|
|
// Prepare channel by running reverse first to set last_run_cmd
|
|
prepare_all_channels_for_tilt(RELAY_CHN_CMD_REVERSE);
|
|
|
|
// Issue tilt reverse command
|
|
relay_chn_tilt_reverse_all();
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
|
|
check_all_channels_for_state(RELAY_CHN_STATE_TILT_REVERSE);
|
|
}
|
|
|
|
// TEST_CASE: Test transition from tilt forward to run forward (inertia expected for run)
|
|
// Scenario: RELAY_CHN_STATE_TILT_FORWARD -> (relay_chn_run_forward) -> RELAY_CHN_STATE_FORWARD
|
|
TEST_CASE("Tilt Forward to Run Forward transition with inertia", "[relay_chn][tilt][inertia]")
|
|
{
|
|
// Prepare channel by running forward first to set last_run_cmd, then tilt
|
|
prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD);
|
|
relay_chn_tilt_forward_all(); // Go to tilt state
|
|
vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
|
|
check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD);
|
|
|
|
// 2. Issue run forward command
|
|
relay_chn_run_forward_all();
|
|
// From Tilt to Run in the same logical name but in the opposite direction, inertia is expected.
|
|
check_all_channels_for_state(RELAY_CHN_STATE_FORWARD_PENDING);
|
|
vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
|
|
check_all_channels_for_state(RELAY_CHN_STATE_FORWARD);
|
|
}
|
|
|
|
// TEST_CASE: Test transition from tilt reverse to run reverse (no inertia expected for run)
|
|
// Scenario: RELAY_CHN_STATE_TILT_REVERSE -> (relay_chn_run_reverse) -> RELAY_CHN_STATE_REVERSE
|
|
TEST_CASE("Tilt Reverse to Run Reverse transition with inertia", "[relay_chn][tilt][inertia]")
|
|
{
|
|
// Prepare channel by running reverse first to set last_run_cmd, then tilt
|
|
prepare_all_channels_for_tilt(RELAY_CHN_CMD_REVERSE);
|
|
relay_chn_tilt_reverse_all(); // Go to tilt state
|
|
vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
|
|
check_all_channels_for_state(RELAY_CHN_STATE_TILT_REVERSE);
|
|
|
|
// 2. Issue run reverse command
|
|
relay_chn_run_reverse_all();
|
|
check_all_channels_for_state(RELAY_CHN_STATE_REVERSE_PENDING);
|
|
vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
|
|
check_all_channels_for_state(RELAY_CHN_STATE_REVERSE);
|
|
}
|
|
|
|
// TEST_CASE: Test transition from tilt forward to run reverse (without inertia)
|
|
// Scenario: RELAY_CHN_STATE_TILT_FORWARD -> (relay_chn_run_reverse) -> RELAY_CHN_STATE_REVERSE
|
|
TEST_CASE("Tilt Forward to Run Reverse transition without inertia", "[relay_chn][tilt][inertia]")
|
|
{
|
|
// Prepare channel by running forward first to set last_run_cmd, then tilt
|
|
prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD);
|
|
relay_chn_tilt_forward_all(); // Go to tilt state
|
|
vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
|
|
check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD);
|
|
|
|
// 2. Issue run reverse command (opposite direction)
|
|
relay_chn_run_reverse_all();
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
|
|
check_all_channels_for_state(RELAY_CHN_STATE_REVERSE);
|
|
}
|
|
|
|
// TEST_CASE: Test stopping from a tilt state (no inertia for stop command itself)
|
|
// Scenario: RELAY_CHN_STATE_TILT_FORWARD -> (relay_chn_tilt_stop) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_IDLE
|
|
TEST_CASE("Tilt to Stop transition without immediate inertia for stop", "[relay_chn][tilt][inertia]")
|
|
{
|
|
// Prepare all channels by running forward first to set last_run_cmd, then tilt
|
|
prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD);
|
|
relay_chn_tilt_forward_all(); // Go to tilt state
|
|
vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
|
|
// Verify all channels are tilting forward
|
|
check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD);
|
|
|
|
// 2. Issue stop command
|
|
relay_chn_tilt_stop_all();
|
|
// Stop command should apply immediately, setting state to FREE since last state was tilt.
|
|
vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
|
|
// Verify all channels are IDLE
|
|
check_all_channels_for_state(RELAY_CHN_STATE_IDLE);
|
|
}
|
|
|
|
// ### Batch Tilt Control Tests
|
|
|
|
TEST_CASE("tilt_forward_all sets all channels to TILT_FORWARD", "[relay_chn][tilt][batch]")
|
|
{
|
|
// 1. Prepare all channels.
|
|
prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD);
|
|
|
|
// 2. Issue tilt forward to all channels
|
|
relay_chn_tilt_forward_all();
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); // Tilt from FREE doesn't have stop-inertia
|
|
|
|
// 3. Verify all channels are tilting forward
|
|
check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD);
|
|
}
|
|
|
|
TEST_CASE("tilt_reverse_all sets all channels to TILT_REVERSE", "[relay_chn][tilt][batch]")
|
|
{
|
|
// 1. Prepare all channels.
|
|
prepare_all_channels_for_tilt(RELAY_CHN_CMD_REVERSE);
|
|
|
|
// 2. Issue tilt reverse to all channels
|
|
relay_chn_tilt_reverse_all();
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
|
|
|
|
// 3. Verify all channels are tilting reverse
|
|
check_all_channels_for_state(RELAY_CHN_STATE_TILT_REVERSE);
|
|
}
|
|
|
|
TEST_CASE("tilt_stop_all stops all tilting channels", "[relay_chn][tilt][batch]")
|
|
{
|
|
// 1. Prepare and start all channels tilting forward
|
|
prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD);
|
|
|
|
relay_chn_tilt_forward_all();
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
|
|
|
|
// 2. Stop tilting on all channels
|
|
relay_chn_tilt_stop_all();
|
|
vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
|
|
|
|
// 3. Verify all channels are free
|
|
check_all_channels_for_state(RELAY_CHN_STATE_IDLE);
|
|
}
|
|
|
|
TEST_CASE("tilt_auto_all tilts channels based on last run direction", "[relay_chn][tilt][batch]")
|
|
{
|
|
// This test requires at least 2 channels to demonstrate different behaviors
|
|
TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(2, CONFIG_RELAY_CHN_COUNT, "Test requires at least 2 channels");
|
|
|
|
// 1. Prepare channel 0 with last run FORWARD and channel 1 with last run REVERSE
|
|
prepare_channels_for_tilt_with_mixed_runs(0, RELAY_CHN_CMD_FORWARD);
|
|
|
|
// 2. Issue auto tilt command to all channels
|
|
relay_chn_tilt_auto_all();
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); // Tilt from FREE state is dispatched immediately
|
|
|
|
// 3. Verify even channels tilt forward (last run was forward) and odd channels tilt reverse (last run was reverse)
|
|
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
|
|
relay_chn_state_t state = i % 2 == 0 ?
|
|
RELAY_CHN_STATE_TILT_FORWARD : RELAY_CHN_STATE_TILT_REVERSE;
|
|
|
|
TEST_ASSERT_EQUAL(state, relay_chn_get_state(i));
|
|
}
|
|
}
|
|
|
|
// Test relay_chn_tilt_auto() chooses correct tilt direction
|
|
TEST_CASE("relay_chn_tilt_auto chooses correct direction", "[relay_chn][tilt][auto]")
|
|
{
|
|
// Prepare FORWARD
|
|
prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD);
|
|
relay_chn_tilt_auto_all();
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
|
|
// Verify all tilt forward
|
|
check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD);
|
|
|
|
relay_chn_tilt_stop_all();
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
|
|
|
|
// Prepare REVERSE
|
|
prepare_all_channels_for_tilt(RELAY_CHN_CMD_REVERSE);
|
|
relay_chn_tilt_auto_all();
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
|
|
// Verify all tilt reverse
|
|
check_all_channels_for_state(RELAY_CHN_STATE_TILT_REVERSE);
|
|
}
|
|
|
|
// Test sensitivity set/get
|
|
TEST_CASE("relay_chn_tilt_set_sensitivity and get", "[relay_chn][tilt][sensitivity]")
|
|
{
|
|
uint8_t ch = 0;
|
|
relay_chn_tilt_set_sensitivity(ch, 0);
|
|
TEST_ASSERT_EQUAL_UINT8(0, relay_chn_tilt_get_sensitivity(ch));
|
|
|
|
relay_chn_tilt_set_sensitivity(ch, 50);
|
|
TEST_ASSERT_EQUAL_UINT8(50, relay_chn_tilt_get_sensitivity(ch));
|
|
|
|
relay_chn_tilt_set_sensitivity(ch, 100);
|
|
TEST_ASSERT_EQUAL_UINT8(100, relay_chn_tilt_get_sensitivity(ch));
|
|
// Set all channels
|
|
relay_chn_tilt_set_sensitivity_all_with(42);
|
|
|
|
uint8_t vals[CONFIG_RELAY_CHN_COUNT] = {0};
|
|
uint8_t expect[CONFIG_RELAY_CHN_COUNT];
|
|
memset(expect, 42, CONFIG_RELAY_CHN_COUNT);
|
|
|
|
TEST_ESP_OK(relay_chn_tilt_get_sensitivity_all(vals));
|
|
TEST_ASSERT_EQUAL_UINT8_ARRAY(expect, vals, CONFIG_RELAY_CHN_COUNT);
|
|
}
|
|
|
|
// Test sensitivity upper boundary for all set functions
|
|
TEST_CASE("relay_chn_tilt_set_sensitivity functions handle upper boundary", "[relay_chn][tilt][sensitivity]")
|
|
{
|
|
// 1. Test relay_chn_tilt_set_sensitivity() for each channel
|
|
for (uint8_t ch = 0; ch < CONFIG_RELAY_CHN_COUNT; ch++) {
|
|
relay_chn_tilt_set_sensitivity(ch, 101);
|
|
TEST_ASSERT_EQUAL_UINT8(100, relay_chn_tilt_get_sensitivity(ch));
|
|
|
|
relay_chn_tilt_set_sensitivity(ch, 255);
|
|
TEST_ASSERT_EQUAL_UINT8(100, relay_chn_tilt_get_sensitivity(ch));
|
|
}
|
|
|
|
// 2. Test relay_chn_tilt_set_sensitivity_all_with()
|
|
relay_chn_tilt_set_sensitivity_all_with(150);
|
|
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
|
|
TEST_ASSERT_EQUAL_UINT8(100, relay_chn_tilt_get_sensitivity(i));
|
|
}
|
|
|
|
// 3. Test relay_chn_tilt_set_sensitivity_all()
|
|
uint8_t sensitivities[CONFIG_RELAY_CHN_COUNT];
|
|
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
|
|
sensitivities[i] = 100 + i * 10; // Values like 100, 110, 120...
|
|
}
|
|
TEST_ESP_OK(relay_chn_tilt_set_sensitivity_all(sensitivities));
|
|
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
|
|
TEST_ASSERT_EQUAL_UINT8(100, relay_chn_tilt_get_sensitivity(i));
|
|
}
|
|
}
|
|
|
|
// Test tilt counter logic: forward x3, reverse x3, extra reverse fails
|
|
TEST_CASE("tilt counter logic: forward and reverse consumption", "[relay_chn][tilt][counter]")
|
|
{
|
|
|
|
// Tilt execution time at 100% sensitivity in milliseconds (10 + 90)
|
|
#define TEST_TILT_EXECUTION_TIME_MS 100
|
|
|
|
prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD);
|
|
relay_chn_tilt_set_sensitivity_all_with(100); // Set sentivity to max for fastest execution
|
|
|
|
// Tilt forward 3 times
|
|
for (int i = 0; i < 3; ++i) {
|
|
relay_chn_tilt_forward_all();
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_TILT_EXECUTION_TIME_MS));
|
|
check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD);
|
|
relay_chn_tilt_stop_all();
|
|
}
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
|
|
|
|
// Now tilt reverse 3 times (should succeed)
|
|
for (int i = 0; i < 3; ++i) {
|
|
relay_chn_tilt_reverse_all();
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_TILT_EXECUTION_TIME_MS));
|
|
check_all_channels_for_state(RELAY_CHN_STATE_TILT_REVERSE);
|
|
relay_chn_tilt_stop_all();
|
|
}
|
|
|
|
// Extra reverse tilt should fail (counter exhausted)
|
|
relay_chn_tilt_reverse_all();
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
|
|
// Should not enter TILT_REVERSE, should remain IDLE
|
|
check_all_channels_for_state(RELAY_CHN_STATE_IDLE);
|
|
}
|
|
|
|
// Test run command during TILT state
|
|
TEST_CASE("run command during TILT state transitions correctly", "[relay_chn][tilt][run-during-tilt]")
|
|
{
|
|
prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD);
|
|
relay_chn_tilt_forward_all();
|
|
vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
|
|
check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD);
|
|
|
|
// Issue run reverse while in TILT_FORWARD
|
|
relay_chn_run_reverse_all();
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
|
|
// Should transition to REVERSE
|
|
check_all_channels_for_state(RELAY_CHN_STATE_REVERSE);
|
|
} |