Refactor and improve for batch operations

Refactor tilt test functions to use batch operations for all channels and improve state checks.

Refs #1085

src/relay_chn_tilt.c

@@ -93,6 +93,16 @@ static uint32_t relay_chn_tilt_get_required_timing_before_tilting(relay_chn_tilt
 // Issue a tilt command to a specific relay channel.
 static void relay_chn_tilt_issue_cmd(relay_chn_tilt_ctl_t *tilt_ctl, relay_chn_tilt_cmd_t cmd)
 {
+    // TILT_STOP is safe and high priority
+    if (cmd == RELAY_CHN_TILT_CMD_STOP) {
+        if (tilt_ctl->chn_ctl->state == RELAY_CHN_STATE_STOPPED) {
+            return; // Do nothing if already stopped
+        }
+        // If the command is TILT_STOP, issue it immediately
+        relay_chn_tilt_dispatch_cmd(tilt_ctl, cmd);
+        return;
+    }
+    
     if (relay_chn_run_info_get_last_run_cmd(tilt_ctl->chn_ctl->run_info) == RELAY_CHN_CMD_NONE) {
         // Do not tilt if the channel hasn't been run before
         ESP_LOGD(TAG, "relay_chn_tilt_issue_cmd: Tilt will not be executed since the channel hasn't been run yet");
@@ -106,7 +116,6 @@ static void relay_chn_tilt_issue_cmd(relay_chn_tilt_ctl_t *tilt_ctl, relay_chn_t
 
     // Set the command that will be processed
     tilt_ctl->cmd = cmd;
-    ESP_LOGI(TAG, "relay_chn_tilt_issue_cmd: Command-chn: %d-%d", cmd, tilt_ctl->chn_ctl->id); // TODO delete
     switch (tilt_ctl->chn_ctl->state) {
         case RELAY_CHN_STATE_IDLE:
             // Relay channel is free, tilt can be issued immediately
@@ -183,7 +192,6 @@ static void relay_chn_tilt_issue_cmd_on_all_channels(relay_chn_tilt_cmd_t cmd)
 {
     for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
         relay_chn_tilt_ctl_t* tilt_ctl = &tilt_ctls[i];
-        ESP_LOGI(TAG, "issue_cmd_on_all_channels: Command|chn|ctl.id: %d|%d|%d", cmd, i, tilt_ctl->chn_ctl->id); // TODO delete
         relay_chn_tilt_issue_cmd(tilt_ctl, cmd);
     }
 }
@@ -490,7 +498,7 @@ static void relay_chn_tilt_execute_stop(relay_chn_tilt_ctl_t *tilt_ctl)
     if (relay_chn_output_stop(tilt_ctl->chn_ctl->output) != ESP_OK) {
         ESP_LOGE(TAG, "relay_chn_tilt_execute_stop: Failed to output stop for relay channel #%d!", tilt_ctl->chn_ctl->id);
     }
-    relay_chn_dispatch_cmd(tilt_ctl->chn_ctl, RELAY_CHN_CMD_STOP);
+    relay_chn_dispatch_cmd(tilt_ctl->chn_ctl, RELAY_CHN_CMD_IDLE);
 
 #if CONFIG_RELAY_CHN_ENABLE_NVS
     // Start the flush debounce timer
@@ -553,7 +561,6 @@ static void relay_chn_tilt_execute_pause(relay_chn_tilt_ctl_t *tilt_ctl)
 esp_err_t relay_chn_tilt_dispatch_cmd(relay_chn_tilt_ctl_t *tilt_ctl, relay_chn_tilt_cmd_t cmd)
 {
     ESP_LOGD(TAG, "relay_chn_tilt_dispatch_cmd: Command: %d", cmd);
-    ESP_LOGI(TAG, "tilt_dispatch_cmd: Command-chn: %d-%d", cmd, tilt_ctl->chn_ctl->id); // TODO delete
 
     switch(cmd) {
         case RELAY_CHN_TILT_CMD_STOP:

test_apps/.vscode/c_cpp_properties.json

@@ -0,0 +1,23 @@
+{
+  "configurations": [
+    {
+      "name": "ESP-IDF",
+      "compilerPath": "${config:idf.toolsPath}/tools/xtensa-esp-elf/esp-14.2.0_20241119/xtensa-esp-elf/bin/xtensa-esp32-elf-gcc",
+      "compileCommands": "${config:idf.buildPath}/compile_commands.json",
+      "includePath": [
+        "${config:idf.espIdfPath}/components/**",
+        "${config:idf.espIdfPathWin}/components/**",
+        "${workspaceFolder}/**"
+      ],
+      "browse": {
+        "path": [
+          "${config:idf.espIdfPath}/components",
+          "${config:idf.espIdfPathWin}/components",
+          "${workspaceFolder}"
+        ],
+        "limitSymbolsToIncludedHeaders": true
+      }
+    }
+  ],
+  "version": 4
+}

test_apps/.vscode/launch.json

@@ -0,0 +1,15 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "gdbtarget",
+      "request": "attach",
+      "name": "Eclipse CDT GDB Adapter"
+    },
+    {
+      "type": "espidf",
+      "name": "Launch",
+      "request": "launch"
+    }
+  ]
+}

test_apps/main/test_relay_chn_tilt_multi.c

@@ -12,171 +12,197 @@
 #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_channel_for_tilt(uint8_t chn_id, int initial_cmd) {
+void prepare_channels_for_tilt_with_mixed_runs() {
     // Ensure the channel reset tilt control
-    relay_chn_tilt_stop(chn_id);
+    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(chn_id);
+        relay_chn_run_forward_all();
     } else { // Assuming initial_cmd is RELAY_CHN_CMD_REVERSE
-        relay_chn_run_reverse(chn_id);
+        relay_chn_run_reverse_all();
     }
     vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); // Allow command to process
-    relay_chn_stop(chn_id); // Stop it to set last_run_cmd but return to FREE for next test
+    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));
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state(chn_id));
+    
+    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]") {
-    uint8_t ch = 0;
-
     // Prepare channel by running forward first to set last_run_cmd
-    prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
+    prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD);
 
     // 1. Start in forward direction
-    relay_chn_run_forward(ch); 
+    relay_chn_run_forward_all(); 
     vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch));
+    check_all_channels_for_state(RELAY_CHN_STATE_FORWARD);
 
     // 2. Issue tilt forward command
-    relay_chn_tilt_forward(ch); 
+    relay_chn_tilt_forward_all(); 
     // After tilt command, it should immediately stop and then trigger inertia.
     vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); 
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state(ch)); 
+    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 + TEST_DELAY_MARGIN_MS));
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
+    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]") {
-    uint8_t ch = 0;
-
     // Prepare channel by running reverse first to set last_run_cmd
-    prepare_channel_for_tilt(ch, RELAY_CHN_CMD_REVERSE);
+    prepare_all_channels_for_tilt(RELAY_CHN_CMD_REVERSE);
 
     // 1. Start in reverse direction
-    relay_chn_run_reverse(ch); 
+    relay_chn_run_reverse_all(); 
     vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(ch));
+    check_all_channels_for_state(RELAY_CHN_STATE_REVERSE);
 
     // 2. Issue tilt reverse command
-    relay_chn_tilt_reverse(ch); 
+    relay_chn_tilt_reverse_all(); 
     vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state(ch));
+    check_all_channels_for_state(RELAY_CHN_STATE_STOPPED);
 
     vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch));
+    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]") {
-    uint8_t ch = 0;
-
     // Prepare channel by running forward first to set last_run_cmd
-    prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state(ch)); // Ensure we are back to FREE
+    prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD);
 
     // Issue tilt forward command
-    relay_chn_tilt_forward(ch); 
+    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)); 
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
+    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]") {
-    uint8_t ch = 0;
-
     // Prepare channel by running reverse first to set last_run_cmd
-    prepare_channel_for_tilt(ch, RELAY_CHN_CMD_REVERSE);
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state(ch)); // Ensure we are back to FREE
+    prepare_all_channels_for_tilt(RELAY_CHN_CMD_REVERSE);
 
     // Issue tilt reverse command
-    relay_chn_tilt_reverse(ch); 
+    relay_chn_tilt_reverse_all(); 
     vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch));
+    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]") {
-    uint8_t ch = 0;
-
     // Prepare channel by running forward first to set last_run_cmd, then tilt
-    prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
-    relay_chn_tilt_forward(ch); // Go to tilt state
+    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));
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
+    check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD);
 
     // 2. Issue run forward command
-    relay_chn_run_forward(ch); 
+    relay_chn_run_forward_all(); 
     // From Tilt to Run in the same logical name but in the opposite direction, inertia is expected.
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD_PENDING, relay_chn_get_state(ch));
+    check_all_channels_for_state(RELAY_CHN_STATE_FORWARD_PENDING);
     vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch));
+    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]") {
-    uint8_t ch = 0;
-
     // Prepare channel by running reverse first to set last_run_cmd, then tilt
-    prepare_channel_for_tilt(ch, RELAY_CHN_CMD_REVERSE);
-    relay_chn_tilt_reverse(ch); // Go to tilt state
+    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));
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch));
+    check_all_channels_for_state(RELAY_CHN_STATE_TILT_REVERSE);
 
     // 2. Issue run reverse command
-    relay_chn_run_reverse(ch); 
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE_PENDING, relay_chn_get_state(ch));
+    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));
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(ch));
+    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]") {
-    uint8_t ch = 0;
-
     // Prepare channel by running forward first to set last_run_cmd, then tilt
-    prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
-    relay_chn_tilt_forward(ch); // Go to tilt state
+    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));
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
+    check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD);
 
     // 2. Issue run reverse command (opposite direction)
-    relay_chn_run_reverse(ch); 
+    relay_chn_run_reverse_all(); 
     vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(ch));
+    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]") {
-    uint8_t ch = 0;
-
-    // Prepare channel by running forward first to set last_run_cmd, then tilt
-    prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
-    relay_chn_tilt_forward(ch); // Go to tilt state
+    // 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));
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
+    // Verify all channels are tilting forward
+    check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD);
 
     // 2. Issue stop command
-    relay_chn_tilt_stop(ch);
+    relay_chn_tilt_stop_all();
     // Stop command should apply immediately, setting state to FREE since last state was tilt.
-    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state(ch));
+    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
@@ -184,44 +210,34 @@ TEST_CASE("Tilt to Stop transition without immediate inertia for stop", "[relay_
 TEST_CASE("tilt_forward_all sets all channels to TILT_FORWARD", "[relay_chn][tilt][batch]")
 {
     // 1. Prepare all channels.
-    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
-        prepare_channel_for_tilt(i, RELAY_CHN_CMD_FORWARD);
-    }
+    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
-    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
-        ESP_LOGI(TEST_TAG, "Checking channel %d", i);
-        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(i));
-    }
+    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.
-    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
-        prepare_channel_for_tilt(i, RELAY_CHN_CMD_REVERSE);
-    }
+    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
-    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
-        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(i));
-    }
+    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
-    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
-        prepare_channel_for_tilt(i, RELAY_CHN_CMD_REVERSE);
-    }
+    prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD);
+    
     relay_chn_tilt_forward_all();
     vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
 
@@ -230,10 +246,7 @@ TEST_CASE("tilt_stop_all stops all tilting channels", "[relay_chn][tilt][batch]"
     vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
 
     // 3. Verify all channels are free
-    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
-        ESP_LOGI(TEST_TAG, "Checking channel %d", i);
-        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state(i));
-    }
+    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]")
@@ -242,34 +255,39 @@ TEST_CASE("tilt_auto_all tilts channels based on last run direction", "[relay_ch
     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_channel_for_tilt(0, RELAY_CHN_CMD_FORWARD);
-    prepare_channel_for_tilt(1, RELAY_CHN_CMD_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 channel 0 tilts forward (last run was forward) and channel 1 tilts reverse (last run was reverse)
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(0));
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(1));
+    // 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]") {
-    uint8_t ch = 0;
     // Prepare FORWARD
-    prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
-    relay_chn_tilt_auto(ch);
+    prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD);
+    relay_chn_tilt_auto_all();
     vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
-    relay_chn_tilt_stop(ch);
+    // 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_channel_for_tilt(ch, RELAY_CHN_CMD_REVERSE);
-    relay_chn_tilt_auto(ch);
+    prepare_all_channels_for_tilt(RELAY_CHN_CMD_REVERSE);
+    relay_chn_tilt_auto_all();
     vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch));
+    // Verify all tilt reverse
+    check_all_channels_for_state(RELAY_CHN_STATE_TILT_REVERSE);
 }
 
 // Test sensitivity set/get
@@ -296,49 +314,47 @@ TEST_CASE("relay_chn_tilt_set_sensitivity and get", "[relay_chn][tilt][sensitivi
 
 // Test tilt counter logic: forward x3, reverse x3, extra reverse fails
 TEST_CASE("tilt counter logic: forward and reverse consumption", "[relay_chn][tilt][counter]") {
-    uint8_t ch = 0;
-    prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
+
+// 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(ch);
-        vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
-        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
-        relay_chn_tilt_stop(ch);
-        vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
+        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(ch);
-        vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
-        if (i < 3) {
-            TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch));
-            relay_chn_tilt_stop(ch);
-            vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
-        }
+        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(ch);
+    relay_chn_tilt_reverse_all();
     vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
-    // Should not enter TILT_REVERSE, should remain FREE or STOPPED
-    relay_chn_state_t state = relay_chn_get_state(ch);
-    TEST_ASSERT(state != RELAY_CHN_STATE_TILT_REVERSE);
+    // 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]") {
-    uint8_t ch = 0;
-    prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
-    relay_chn_tilt_forward(ch);
+    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));
-    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
+    check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD);
 
     // Issue run reverse while in TILT_FORWARD
-    relay_chn_run_reverse(ch);
+    relay_chn_run_reverse_all();
     vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
-    // Should transition to REVERSE or REVERSE_PENDING depending on inertia logic
-    relay_chn_state_t state = relay_chn_get_state(ch);
-    TEST_ASSERT(state == RELAY_CHN_STATE_REVERSE || state == RELAY_CHN_STATE_REVERSE_PENDING);
+    // Should transition to REVERSE
+    check_all_channels_for_state(RELAY_CHN_STATE_REVERSE);
 }