ismail
a6d38327b7
Added test cases for the recently implemented `*all` and `*all_with` functions. Closes #1089.
433 lines
18 KiB
C
433 lines
18 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();
|
|
|
|
// 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);
|
|
}
|
|
|
|
// Test run command during active tilt cycle (move/pause)
|
|
TEST_CASE("run_all command during active tilt cycle stops tilt", "[relay_chn][tilt][interrupt]")
|
|
{
|
|
// Set a known sensitivity for predictable timing.
|
|
// For sensitivity=50, move_time=30ms, pause_time=270ms.
|
|
relay_chn_tilt_set_sensitivity_all_with(50);
|
|
const uint32_t move_time_ms = 30;
|
|
|
|
// --- Test interrupting during MOVE step ---
|
|
prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD);
|
|
relay_chn_tilt_forward_all();
|
|
vTaskDelay(pdMS_TO_TICKS(move_time_ms / 2)); // Wait for half of the move time
|
|
check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD);
|
|
|
|
// Interrupt with run_reverse_all while in the MOVE part of the cycle
|
|
relay_chn_run_reverse_all();
|
|
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
|
|
// Should stop tilting and go to REVERSE immediately (no inertia from TILT_FORWARD)
|
|
check_all_channels_for_state(RELAY_CHN_STATE_REVERSE);
|
|
|
|
// --- Test interrupting during PAUSE step ---
|
|
prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD);
|
|
relay_chn_tilt_forward_all();
|
|
vTaskDelay(pdMS_TO_TICKS(move_time_ms + TEST_DELAY_MARGIN_MS)); // Wait past MOVE, into PAUSE
|
|
check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD);
|
|
|
|
// Interrupt with run_forward_all while in the PAUSE part of the cycle
|
|
relay_chn_run_forward_all();
|
|
// Should stop tilting and go to FORWARD_PENDING (inertia from TILT_FORWARD)
|
|
check_all_channels_for_state(RELAY_CHN_STATE_FORWARD_PENDING);
|
|
} |