app_test/main/test_relay_chn.c

@@ -1,104 +1,443 @@
 #include "driver/gpio.h"
 #include "unity.h"
 #include "unity_test_utils.h"
-#include "relay_chn.h"
+#include "relay_chn.h" // Main header file for the relay_chn component
 #include <esp_log.h>
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
+#include "sdkconfig.h" // For accessing CONFIG_* values
 
-
+// Test GPIOs and channel IDs
+// Please ensure these GPIOs are correct and suitable for your board.
+// Two channels (4 GPIOs) are used as an example.
 const gpio_num_t gpio_map[] = {GPIO_NUM_4, GPIO_NUM_5, GPIO_NUM_18, GPIO_NUM_19};
 const uint8_t gpio_count = sizeof(gpio_map) / sizeof(gpio_map[0]);
-const uint8_t relay_chn_count = gpio_count / 2;
+// Assuming 2 GPIOs are used per channel
+const uint8_t relay_chn_count = gpio_count / 2; 
 
+// Retrieve inertia value from SDKconfig
+#ifndef CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS
+#define CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS 500 // Default if not defined in SDKconfig
+#endif
 
+const uint32_t opposite_inertia_ms = CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS;
+
+// Tolerant delay margin to ensure operations complete, especially after inertia.
+const uint32_t test_delay_margin_ms = 50; 
+
+// --- Test Setup/Teardown Functions ---
 void setUp(void) {
-    // Her testten önce çalışacak kod
-    // relay_chn_create'i burada çağırarak her testin temiz bir başlangıç yapmasını sağlayalım.
-    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
-    // Tüm röleleri başlangıçta durdur (temiz bir durum için)
+    ESP_LOGI("TEST_SETUP", "Running setUp for relay_chn tests.");
+    // Re-create the component before each test. relay_chn_create returns esp_err_t.
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count)); 
+    // Ensure all relays are stopped at the beginning, and transition to FREE state
     for (uint8_t i = 0; i < relay_chn_count; i++) {
-        relay_chn_stop(i);
+        relay_chn_stop(i); // relay_chn_stop returns void
+        vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms)); // Wait for FREE state
     }
-    vTaskDelay(pdMS_TO_TICKS(100)); // Rölelerin stabilize olması için kısa bir gecikme
+    ESP_LOGI("TEST_SETUP", "All channels initialized to RELAY_CHN_STATE_FREE.");
 }
 
 void tearDown(void) {
-    // Her testten sonra çalışacak kod (isteğe bağlı, genellikle cleanup için)
-    // Örneğin, GPIO'ları de-initialize edebilirsin, ama relay_chn'in buna ihtiyacı yoksa boş bırakabilirsin.
-    // Ancak her test sonunda tüm rölelerin kapalı olduğundan emin olmak iyi bir pratik.
+    ESP_LOGI("TEST_TEARDOWN", "Running tearDown for relay_chn tests.");
+    // Stop all relays after each test, and transition to FREE state
     for (uint8_t i = 0; i < relay_chn_count; i++) {
-        relay_chn_stop(i);
+        relay_chn_stop(i); // relay_chn_stop returns void
+        vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms)); // Wait for FREE state
     }
-    vTaskDelay(pdMS_TO_TICKS(100));
+    ESP_LOGI("TEST_TEARDOWN", "All channels returned to RELAY_CHN_STATE_FREE.");
 }
 
-TEST_CASE("Relay channels run forward and update state", "[relay_chn][forward]")
-{
-    // Test forward run on all channels
+// --- Basic Functionality Tests ---
+
+// TEST_CASE 1: Test that relay channels initialize correctly to RELAY_CHN_STATE_FREE
+TEST_CASE("Relay channels initialize correctly to FREE state", "[relay_chn]") {
+    ESP_LOGI("TEST", "Running test: Relay channels initialize correctly to FREE state");
     for (uint8_t i = 0; i < relay_chn_count; i++) {
-        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state(i));
-        relay_chn_run_forward(i); // Run the channel forward
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(i));
+    }
+}
+
+// TEST_CASE 2: Test that relays run in the forward direction and update their state
+TEST_CASE("Relay channels run forward and update state", "[relay_chn]") {
+    ESP_LOGI("TEST", "Running test: Relay channels run forward and update state");
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        relay_chn_run_forward(i); // relay_chn_run_forward returns void
+        // Short delay for state to update
+        vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(i));
-        relay_chn_stop(i); // Stop the channel
-        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state(i));
-        
-        relay_chn_flip_direction(i); // Flip the direction
-        TEST_ASSERT_EQUAL(RELAY_CHN_DIRECTION_FLIPPED, relay_chn_get_direction(i));
-        relay_chn_run_forward(i); // Run the channel forward
+    }
+}
+
+// TEST_CASE 3: Test that relays run in the reverse direction and update their state
+TEST_CASE("Relay channels run reverse and update state", "[relay_chn]") {
+    ESP_LOGI("TEST", "Running test: Relay channels run reverse and update state");
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        relay_chn_run_reverse(i); // relay_chn_run_reverse returns void
+        vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(i));
+    }
+}
+
+// TEST_CASE 4: Test that relays stop and transition to RELAY_CHN_STATE_FREE
+// This test also verifies the transition to FREE state after a STOP command.
+TEST_CASE("Relay channels stop and update to FREE state", "[relay_chn]") {
+    ESP_LOGI("TEST", "Running test: Relay channels stop and update to FREE state");
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        // First, run forward to test stopping and transitioning to FREE state
+        relay_chn_run_forward(i); // relay_chn_run_forward returns void
+        vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(i));
-        relay_chn_stop(i); // Stop the channel
+
+        // Now, issue the stop command
+        relay_chn_stop(i); // relay_chn_stop returns void
+        // Immediately after stop, state should be STOPPED
+        vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state(i));
+
+        // Then, wait for the inertia period for it to transition to RELAY_CHN_STATE_FREE
+        vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(i));
     }
 }
 
-TEST_CASE("Relay channels run reverse and update state", "[relay_chn][reverse]")
-{
-    // Test reverse run on all channels
-    for (uint8_t i = 0; i < relay_chn_count; i++) {
-        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state(i));
-        relay_chn_run_reverse(i); // Run the channel reverse
-        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(i));
-        relay_chn_stop(i); // Stop the channel
-        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state(i));
-        
-        relay_chn_flip_direction(i); // Flip the direction
-        TEST_ASSERT_EQUAL(RELAY_CHN_DIRECTION_FLIPPED, relay_chn_get_direction(i));
-        relay_chn_run_reverse(i); // Run the channel forward
-        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(i));
-        relay_chn_stop(i); // Stop the channel
-        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state(i));
+// TEST_CASE 5: Test function calls with invalid channel IDs
+// TEST_CASE("Invalid channel ID handling", "[relay_chn]") {
+//     ESP_LOGI("TEST", "Running test: Invalid channel ID handling");
+//     uint8_t invalid_channel_id = relay_chn_count + 1; // An ID that is out of bounds
+
+//     // These calls are expected to return ESP_ERR_INVALID_ARG, so TEST_ASSERT_EQUAL is appropriate.
+//     TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_run_forward(invalid_channel_id));
+//     TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_run_reverse(invalid_channel_id));
+//     TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_stop(invalid_channel_id));
+    
+//     // Test tilt commands only if tilt functionality is enabled
+// #if CONFIG_RELAY_CHN_ENABLE_TILTING == 1
+//     TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_tilt_forward(invalid_channel_id));
+//     TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_tilt_reverse(invalid_channel_id));
+// #endif
+    
+//     TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_get_state(invalid_channel_id));
+// }
+
+// TEST_CASE 6: Test independent operation of multiple relay channels
+TEST_CASE("Multiple channels can operate independently", "[relay_chn]") {
+    ESP_LOGI("TEST", "Running test: Multiple channels can operate independently");
+    if (relay_chn_count >= 2) {
+        // Start Channel 0 in forward direction
+        relay_chn_run_forward(0); // relay_chn_run_forward returns void
+        vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(0));
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(1)); // Other channel should not be affected
+
+        // Start Channel 1 in reverse direction
+        relay_chn_run_reverse(1); // relay_chn_run_reverse returns void
+        vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(0));
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(1));
+
+        // Stop Channel 0 and wait for it to become FREE
+        relay_chn_stop(0); // relay_chn_stop returns void
+        vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(0));
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(1)); // Other channel should continue running
+
+        // Stop Channel 1 and wait for it to become FREE
+        relay_chn_stop(1); // relay_chn_stop returns void
+        vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(0));
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(1));
+    } else {
+        ESP_LOGW("TEST", "Skipping 'Multiple channels can operate independently' test: Not enough channels available.");
     }
 }
 
-static void check_channels_state_unchanged(void)
-{
-    for (uint8_t i = 0; i < relay_chn_count; i++) {
-        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state(i));
-        TEST_ASSERT_EQUAL(RELAY_CHN_DIRECTION_DEFAULT, relay_chn_get_direction(i));
+
+// ### Inertia and State Transition Tests
+
+// This section specifically targets the inertia periods and complex state transitions as per the component's logic.
+
+// TEST_CASE 7: Test transition from forward to reverse with inertia and state checks
+// Scenario: RELAY_CHN_STATE_FORWARD -> (relay_chn_run_reverse) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_REVERSE
+TEST_CASE("Forward to Reverse transition with opposite inertia", "[relay_chn][inertia]") {
+    ESP_LOGI("TEST", "Running test: Forward to Reverse transition with opposite inertia");
+    uint8_t ch = 0; // Channel to test
+
+    // 1. Start in forward direction
+    relay_chn_run_forward(ch); // relay_chn_run_forward returns void
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms)); // Short delay for state stabilization
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch));
+
+    // 2. Issue reverse command
+    relay_chn_run_reverse(ch); // relay_chn_run_reverse returns void
+    // Immediately after the command, the motor should be stopped
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms)); 
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE_PENDING, relay_chn_get_state(ch)); 
+
+    // Wait for the inertia period (after which the reverse command will be dispatched)
+    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms)); 
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(ch)); // Should now be in reverse state
+}
+
+// TEST_CASE 8: Test transition from reverse to forward with inertia and state checks
+// Scenario: RELAY_CHN_STATE_REVERSE -> (relay_chn_run_forward) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_FORWARD
+TEST_CASE("Reverse to Forward transition with opposite inertia", "[relay_chn][inertia]") {
+    ESP_LOGI("TEST", "Running test: Reverse to Forward transition with opposite inertia");
+    uint8_t ch = 0;
+
+    // 1. Start in reverse direction
+    relay_chn_run_reverse(ch); // relay_chn_run_reverse returns void
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(ch));
+
+    // 2. Issue forward command
+    relay_chn_run_forward(ch); // relay_chn_run_forward returns void
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD_PENDING, relay_chn_get_state(ch));
+
+    // Wait for inertia
+    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch));
+}
+
+// TEST_CASE 9: Test issuing the same run command while already running (no inertia expected)
+// Scenario: RELAY_CHN_STATE_FORWARD -> (relay_chn_run_forward) -> RELAY_CHN_STATE_FORWARD
+TEST_CASE("Running in same direction does not incur inertia", "[relay_chn][inertia]") {
+    ESP_LOGI("TEST", "Running test: Running in same direction does not incur inertia");
+    uint8_t ch = 0;
+
+    // 1. Start in forward direction
+    relay_chn_run_forward(ch); // relay_chn_run_forward returns void
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch));
+
+    // 2. Issue the same forward command again
+    relay_chn_run_forward(ch); // relay_chn_run_forward returns void
+    // As per the code, is_direction_opposite_to_current_motion should return false, so no inertia.
+    // Just a short delay to check state remains the same.
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms)); 
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch));
+}
+
+// TEST_CASE 10: Test transition from FREE state to running (no inertia expected)
+// Scenario: RELAY_CHN_STATE_FREE -> (relay_chn_run_forward) -> RELAY_CHN_STATE_FORWARD
+TEST_CASE("FREE to Running transition without inertia", "[relay_chn][inertia]") {
+    ESP_LOGI("TEST", "Running test: FREE to Running transition without inertia");
+    uint8_t ch = 0;
+
+    // setUp() should have already brought the channel to FREE state
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(ch));
+
+    // Start in forward direction
+    relay_chn_run_forward(ch); // relay_chn_run_forward returns void
+    // No inertia is expected when starting from FREE state.
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch));
+}
+
+
+// ### Tilt Functionality Tests (Conditional)
+
+// This section will only be compiled if **`CONFIG_RELAY_CHN_ENABLE_TILTING`** is defined as **`1`** in `sdkconfig`.
+
+#if CONFIG_RELAY_CHN_ENABLE_TILTING == 1
+
+#define RELAY_CHN_CMD_FORWARD 1
+#define RELAY_CHN_CMD_REVERSE 2
+
+// Helper function to prepare channel for tilt tests
+void prepare_channel_for_tilt(uint8_t chn_id, int initial_cmd) {
+    // Ensure the channel has had a 'last_run_cmd'
+    if (initial_cmd == RELAY_CHN_CMD_FORWARD) {
+        relay_chn_run_forward(chn_id);
+    } else { // Assuming initial_cmd is RELAY_CHN_CMD_REVERSE
+        relay_chn_run_reverse(chn_id);
     }
+    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
+    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(chn_id));
 }
 
-TEST_CASE("Relay channels do not change state for invalid channel", "[relay_chn][invalid]")
-{
-     // Test invalid channel run
-    relay_chn_run_forward(relay_chn_count); // İlk geçersiz kanal (index out of bounds)
-    check_channels_state_unchanged(); // Tüm geçerli kanalların durumu değişmemeli
+// TEST_CASE 11: 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]") {
+    ESP_LOGI("TEST", "Running test: Run Forward to Tilt Forward transition with inertia");
+    uint8_t ch = 0;
 
-    relay_chn_run_reverse(relay_chn_count);
-    check_channels_state_unchanged();
+    // Prepare channel by running forward first to set last_run_cmd
+    prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
 
-    relay_chn_stop(relay_chn_count);
-    check_channels_state_unchanged();
+    // 1. Start in forward direction
+    relay_chn_run_forward(ch); 
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch));
 
-    relay_chn_flip_direction(relay_chn_count);
-    check_channels_state_unchanged();
+    // 2. Issue tilt forward command
+    relay_chn_tilt_forward(ch); 
+    // 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)); 
+
+    // Wait for the inertia period (after which the tilt command will be dispatched)
+    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
 }
 
+// TEST_CASE 12: 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]") {
+    ESP_LOGI("TEST", "Running test: Run Reverse to Tilt Reverse transition with 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);
+
+    // 1. Start in reverse direction
+    relay_chn_run_reverse(ch); 
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(ch));
+
+    // 2. Issue tilt reverse command
+    relay_chn_tilt_reverse(ch); 
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state(ch));
+
+    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch));
+}
+
+// TEST_CASE 13: Test transition from FREE state to tilt forward (now with preparation)
+// Scenario: RELAY_CHN_STATE_FREE -> (prepare) -> RELAY_CHN_STATE_FREE -> (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]") {
+    ESP_LOGI("TEST", "Running test: FREE to Tilt Forward transition with inertia (prepared)");
+    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_FREE, relay_chn_get_state(ch)); // Ensure we are back to FREE
+
+    // Issue tilt forward command
+    relay_chn_tilt_forward(ch); 
+    // 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));
+}
+
+// TEST_CASE 14: Test transition from FREE state to tilt reverse (now with preparation)
+// Scenario: RELAY_CHN_STATE_FREE -> (prepare) -> RELAY_CHN_STATE_FREE -> (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]") {
+    ESP_LOGI("TEST", "Running test: FREE to Tilt Reverse transition with inertia (prepared)");
+    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_FREE, relay_chn_get_state(ch)); // Ensure we are back to FREE
+
+    // Issue tilt reverse command
+    relay_chn_tilt_reverse(ch); 
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch));
+}
+
+// TEST_CASE 15: 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]") {
+    ESP_LOGI("TEST", "Running test: Tilt Forward to Run Forward transition with 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
+    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
+
+    // 2. Issue run forward command
+    relay_chn_run_forward(ch); 
+    // 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));
+    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch));
+}
+
+// TEST_CASE 16: 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]") {
+    ESP_LOGI("TEST", "Running test: Tilt Reverse to Run Reverse transition with 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
+    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch));
+
+    // 2. Issue run reverse command
+    relay_chn_run_reverse(ch); 
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE_PENDING, relay_chn_get_state(ch));
+    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(ch));
+}
+
+// TEST_CASE 17: 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]") {
+    ESP_LOGI("TEST", "Running test: Tilt Forward to Run Reverse transition without 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
+    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
+
+    // 2. Issue run reverse command (opposite direction)
+    relay_chn_run_reverse(ch); 
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(ch));
+}
+
+// TEST_CASE 18: Test stopping from a tilt state (no inertia for stop command itself)
+// Scenario: RELAY_CHN_STATE_TILT_FORWARD -> (relay_chn_stop) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_FREE
+TEST_CASE("Tilt to Stop transition without immediate inertia for stop", "[relay_chn][tilt][inertia]") {
+    ESP_LOGI("TEST", "Running test: Tilt to Stop transition without immediate inertia for stop");
+    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
+    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
+
+    // 2. Issue stop command
+    relay_chn_stop(ch);
+    // 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_FREE, relay_chn_get_state(ch));
+}
+
+#else // CONFIG_RELAY_CHN_ENABLE_TILTING == 0
+// If tilt functionality is disabled, these tests are skipped.
+// A dummy test case is added to indicate this in the test output.
+TEST_CASE("Tilt functionality is disabled, skipping tilt tests", "[relay_chn][tilt_disabled]") {
+    ESP_LOGI("TEST", "Tilt functionality is disabled (CONFIG_RELAY_CHN_ENABLE_TILTING is 0). Skipping tilt tests.");
+    TEST_ASSERT_TRUE(true); // Just to ensure at least one test passes for visibility
+}
+#endif // CONFIG_RELAY_CHN_ENABLE_TILTING
+
+
+// ### `app_main` Function
+
+// --- app_main function ---
 void app_main(void) {
     ESP_LOGI("APP_MAIN", "Starting relay_chn unit tests...");
+
+    // Run the Unity test runner
     unity_run_all_tests();
-    ESP_LOGI("APP_MAIN", "All relay_chn tests completed. Restarting in 10 seconds...");
-    vTaskDelay(pdMS_TO_TICKS(10000));
-    esp_restart();
+
+    // After tests complete, instead of restarting, the device will halt.
+    ESP_LOGI("APP_MAIN", "All relay_chn tests completed. Device halted.");
+    while (1) {
+        vTaskDelay(pdMS_TO_TICKS(1000)); // Wait with low power consumption
+    }
 }

app_test/sdkconfig

@@ -1,6 +1,6 @@
 #
 # Automatically generated file. DO NOT EDIT.
-# Espressif IoT Development Framework (ESP-IDF) 5.4.2 Project Configuration
+# Espressif IoT Development Framework (ESP-IDF) 5.4.0 Project Configuration
 #
 CONFIG_SOC_ADC_SUPPORTED=y
 CONFIG_SOC_DEDICATED_GPIO_SUPPORTED=y
@@ -79,7 +79,6 @@ CONFIG_SOC_ADC_SHARED_POWER=y
 CONFIG_SOC_APB_BACKUP_DMA=y
 CONFIG_SOC_BROWNOUT_RESET_SUPPORTED=y
 CONFIG_SOC_SHARED_IDCACHE_SUPPORTED=y
-CONFIG_SOC_CACHE_FREEZE_SUPPORTED=y
 CONFIG_SOC_CACHE_MEMORY_IBANK_SIZE=0x4000
 CONFIG_SOC_CPU_CORES_NUM=1
 CONFIG_SOC_CPU_INTR_NUM=32
@@ -216,8 +215,6 @@ CONFIG_SOC_TIMER_GROUP_COUNTER_BIT_WIDTH=54
 CONFIG_SOC_TIMER_GROUP_SUPPORT_XTAL=y
 CONFIG_SOC_TIMER_GROUP_SUPPORT_APB=y
 CONFIG_SOC_TIMER_GROUP_TOTAL_TIMERS=2
-CONFIG_SOC_LP_TIMER_BIT_WIDTH_LO=32
-CONFIG_SOC_LP_TIMER_BIT_WIDTH_HI=16
 CONFIG_SOC_MWDT_SUPPORT_XTAL=y
 CONFIG_SOC_TWAI_CONTROLLER_NUM=1
 CONFIG_SOC_TWAI_CLK_SUPPORT_APB=y
@@ -290,7 +287,7 @@ CONFIG_IDF_TOOLCHAIN_GCC=y
 CONFIG_IDF_TARGET_ARCH_RISCV=y
 CONFIG_IDF_TARGET_ARCH="riscv"
 CONFIG_IDF_TARGET="esp32c3"
-CONFIG_IDF_INIT_VERSION="5.4.2"
+CONFIG_IDF_INIT_VERSION="5.4.0"
 CONFIG_IDF_TARGET_ESP32C3=y
 CONFIG_IDF_FIRMWARE_CHIP_ID=0x0005
 
@@ -329,10 +326,10 @@ CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_SIZE=y
 # CONFIG_BOOTLOADER_LOG_LEVEL_NONE is not set
 # CONFIG_BOOTLOADER_LOG_LEVEL_ERROR is not set
 # CONFIG_BOOTLOADER_LOG_LEVEL_WARN is not set
-CONFIG_BOOTLOADER_LOG_LEVEL_INFO=y
-# CONFIG_BOOTLOADER_LOG_LEVEL_DEBUG is not set
+# CONFIG_BOOTLOADER_LOG_LEVEL_INFO is not set
+CONFIG_BOOTLOADER_LOG_LEVEL_DEBUG=y
 # CONFIG_BOOTLOADER_LOG_LEVEL_VERBOSE is not set
-CONFIG_BOOTLOADER_LOG_LEVEL=3
+CONFIG_BOOTLOADER_LOG_LEVEL=4
 
 #
 # Format
@@ -521,12 +518,7 @@ CONFIG_APPTRACE_LOCK_ENABLE=y
 # Bluetooth
 #
 # CONFIG_BT_ENABLED is not set
-
-#
-# Common Options
-#
-# CONFIG_BT_BLE_LOG_SPI_OUT_ENABLED is not set
-# end of Common Options
+CONFIG_BT_ALARM_MAX_NUM=50
 # end of Bluetooth
 
 #
@@ -550,7 +542,6 @@ CONFIG_TWAI_ERRATA_FIX_LISTEN_ONLY_DOM=y
 # Legacy ADC Driver Configuration
 #
 # CONFIG_ADC_SUPPRESS_DEPRECATE_WARN is not set
-# CONFIG_ADC_SKIP_LEGACY_CONFLICT_CHECK is not set
 
 #
 # Legacy ADC Calibration Configuration
@@ -563,41 +554,30 @@ CONFIG_TWAI_ERRATA_FIX_LISTEN_ONLY_DOM=y
 # Legacy Timer Group Driver Configurations
 #
 # CONFIG_GPTIMER_SUPPRESS_DEPRECATE_WARN is not set
-# CONFIG_GPTIMER_SKIP_LEGACY_CONFLICT_CHECK is not set
 # end of Legacy Timer Group Driver Configurations
 
 #
 # Legacy RMT Driver Configurations
 #
 # CONFIG_RMT_SUPPRESS_DEPRECATE_WARN is not set
-# CONFIG_RMT_SKIP_LEGACY_CONFLICT_CHECK is not set
 # end of Legacy RMT Driver Configurations
 
 #
 # Legacy I2S Driver Configurations
 #
 # CONFIG_I2S_SUPPRESS_DEPRECATE_WARN is not set
-# CONFIG_I2S_SKIP_LEGACY_CONFLICT_CHECK is not set
 # end of Legacy I2S Driver Configurations
 
-#
-# Legacy I2C Driver Configurations
-#
-# CONFIG_I2C_SKIP_LEGACY_CONFLICT_CHECK is not set
-# end of Legacy I2C Driver Configurations
-
 #
 # Legacy SDM Driver Configurations
 #
 # CONFIG_SDM_SUPPRESS_DEPRECATE_WARN is not set
-# CONFIG_SDM_SKIP_LEGACY_CONFLICT_CHECK is not set
 # end of Legacy SDM Driver Configurations
 
 #
 # Legacy Temperature Sensor Driver Configurations
 #
 # CONFIG_TEMP_SENSOR_SUPPRESS_DEPRECATE_WARN is not set
-# CONFIG_TEMP_SENSOR_SKIP_LEGACY_CONFLICT_CHECK is not set
 # end of Legacy Temperature Sensor Driver Configurations
 # end of Driver Configurations
 
@@ -620,7 +600,6 @@ CONFIG_ESP_TLS_USE_DS_PERIPHERAL=y
 # CONFIG_ESP_TLS_SERVER_MIN_AUTH_MODE_OPTIONAL is not set
 # CONFIG_ESP_TLS_PSK_VERIFICATION is not set
 # CONFIG_ESP_TLS_INSECURE is not set
-CONFIG_ESP_TLS_DYN_BUF_STRATEGY_SUPPORTED=y
 # end of ESP-TLS
 
 #
@@ -659,7 +638,6 @@ CONFIG_ESP_ERR_TO_NAME_LOOKUP=y
 CONFIG_GPTIMER_ISR_HANDLER_IN_IRAM=y
 # CONFIG_GPTIMER_CTRL_FUNC_IN_IRAM is not set
 # CONFIG_GPTIMER_ISR_IRAM_SAFE is not set
-CONFIG_GPTIMER_OBJ_CACHE_SAFE=y
 # CONFIG_GPTIMER_ENABLE_DEBUG_LOG is not set
 # end of ESP-Driver:GPTimer Configurations
 
@@ -755,13 +733,6 @@ CONFIG_ESP_GDBSTUB_SUPPORT_TASKS=y
 CONFIG_ESP_GDBSTUB_MAX_TASKS=32
 # end of GDB Stub
 
-#
-# ESP HID
-#
-CONFIG_ESPHID_TASK_SIZE_BT=2048
-CONFIG_ESPHID_TASK_SIZE_BLE=4096
-# end of ESP HID
-
 #
 # ESP HTTP client
 #
@@ -870,17 +841,15 @@ CONFIG_RTC_CLK_CAL_CYCLES=1024
 #
 # Peripheral Control
 #
-# CONFIG_PERIPH_CTRL_FUNC_IN_IRAM is not set
+CONFIG_PERIPH_CTRL_FUNC_IN_IRAM=y
 # end of Peripheral Control
 
 #
 # GDMA Configurations
 #
 CONFIG_GDMA_CTRL_FUNC_IN_IRAM=y
-CONFIG_GDMA_ISR_HANDLER_IN_IRAM=y
-CONFIG_GDMA_OBJ_DRAM_SAFE=y
-# CONFIG_GDMA_ENABLE_DEBUG_LOG is not set
 # CONFIG_GDMA_ISR_IRAM_SAFE is not set
+# CONFIG_GDMA_ENABLE_DEBUG_LOG is not set
 # end of GDMA Configurations
 
 #
@@ -1173,14 +1142,6 @@ CONFIG_FATFS_VFS_FSTAT_BLKSIZE=0
 # CONFIG_FATFS_IMMEDIATE_FSYNC is not set
 # CONFIG_FATFS_USE_LABEL is not set
 CONFIG_FATFS_LINK_LOCK=y
-# CONFIG_FATFS_USE_DYN_BUFFERS is not set
-
-#
-# File system free space calculation behavior
-#
-CONFIG_FATFS_DONT_TRUST_FREE_CLUSTER_CNT=0
-CONFIG_FATFS_DONT_TRUST_LAST_ALLOC=0
-# end of File system free space calculation behavior
 # end of FAT Filesystem support
 
 #
@@ -1262,6 +1223,7 @@ CONFIG_HAL_ASSERTION_EQUALS_SYSTEM=y
 CONFIG_HAL_DEFAULT_ASSERTION_LEVEL=2
 CONFIG_HAL_SPI_MASTER_FUNC_IN_IRAM=y
 CONFIG_HAL_SPI_SLAVE_FUNC_IN_IRAM=y
+# CONFIG_HAL_ECDSA_GEN_SIG_CM is not set
 # end of Hardware Abstraction Layer (HAL) and Low Level (LL)
 
 #
@@ -1557,7 +1519,6 @@ CONFIG_MBEDTLS_HAVE_TIME=y
 # CONFIG_MBEDTLS_PLATFORM_TIME_ALT is not set
 # CONFIG_MBEDTLS_HAVE_TIME_DATE is not set
 CONFIG_MBEDTLS_ECDSA_DETERMINISTIC=y
-CONFIG_MBEDTLS_SHA1_C=y
 CONFIG_MBEDTLS_SHA512_C=y
 # CONFIG_MBEDTLS_SHA3_C is not set
 CONFIG_MBEDTLS_TLS_SERVER_AND_CLIENT=y
@@ -1639,7 +1600,6 @@ CONFIG_MBEDTLS_ECP_NIST_OPTIM=y
 # CONFIG_MBEDTLS_THREADING_C is not set
 CONFIG_MBEDTLS_ERROR_STRINGS=y
 CONFIG_MBEDTLS_FS_IO=y
-# CONFIG_MBEDTLS_ALLOW_WEAK_CERTIFICATE_VERIFICATION is not set
 # end of mbedTLS
 
 #
@@ -1700,7 +1660,6 @@ CONFIG_NEWLIB_TIME_SYSCALL_USE_RTC_HRT=y
 CONFIG_ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_0=y
 CONFIG_ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_1=y
 CONFIG_ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_2=y
-CONFIG_ESP_PROTOCOMM_SUPPORT_SECURITY_PATCH_VERSION=y
 # end of Protocomm
 
 #
@@ -1742,7 +1701,6 @@ CONFIG_SPI_FLASH_BROWNOUT_RESET=y
 # CONFIG_SPI_FLASH_AUTO_SUSPEND is not set
 CONFIG_SPI_FLASH_SUSPEND_TSUS_VAL_US=50
 # CONFIG_SPI_FLASH_FORCE_ENABLE_XMC_C_SUSPEND is not set
-# CONFIG_SPI_FLASH_FORCE_ENABLE_C6_H2_SUSPEND is not set
 # end of Optional and Experimental Features (READ DOCS FIRST)
 # end of Main Flash configuration
 
@@ -1888,8 +1846,8 @@ CONFIG_WIFI_PROV_STA_ALL_CHANNEL_SCAN=y
 # Relay Channel Driver Configuration
 #
 CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS=800
-CONFIG_RELAY_CHN_COUNT=1
-# CONFIG_RELAY_CHN_ENABLE_TILTING is not set
+CONFIG_RELAY_CHN_COUNT=2
+CONFIG_RELAY_CHN_ENABLE_TILTING=y
 # end of Relay Channel Driver Configuration
 # end of Component config
 
@@ -1901,10 +1859,10 @@ CONFIG_RELAY_CHN_COUNT=1
 # CONFIG_LOG_BOOTLOADER_LEVEL_NONE is not set
 # CONFIG_LOG_BOOTLOADER_LEVEL_ERROR is not set
 # CONFIG_LOG_BOOTLOADER_LEVEL_WARN is not set
-CONFIG_LOG_BOOTLOADER_LEVEL_INFO=y
-# CONFIG_LOG_BOOTLOADER_LEVEL_DEBUG is not set
+# CONFIG_LOG_BOOTLOADER_LEVEL_INFO is not set
+CONFIG_LOG_BOOTLOADER_LEVEL_DEBUG=y
 # CONFIG_LOG_BOOTLOADER_LEVEL_VERBOSE is not set
-CONFIG_LOG_BOOTLOADER_LEVEL=3
+CONFIG_LOG_BOOTLOADER_LEVEL=4
 # CONFIG_APP_ROLLBACK_ENABLE is not set
 # CONFIG_FLASH_ENCRYPTION_ENABLED is not set
 # CONFIG_FLASHMODE_QIO is not set
@@ -1978,6 +1936,7 @@ CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU0=y
 CONFIG_ESP32C3_DEBUG_OCDAWARE=y
 CONFIG_BROWNOUT_DET=y
 CONFIG_ESP32C3_BROWNOUT_DET=y
+CONFIG_ESP32C3_BROWNOUT_DET=y
 CONFIG_BROWNOUT_DET_LVL_SEL_7=y
 CONFIG_ESP32C3_BROWNOUT_DET_LVL_SEL_7=y
 # CONFIG_BROWNOUT_DET_LVL_SEL_6 is not set
@@ -2005,6 +1964,8 @@ CONFIG_ESP32_WIFI_DYNAMIC_TX_BUFFER_NUM=32
 CONFIG_ESP32_WIFI_AMPDU_TX_ENABLED=y
 CONFIG_ESP32_WIFI_TX_BA_WIN=6
 CONFIG_ESP32_WIFI_AMPDU_RX_ENABLED=y
+CONFIG_ESP32_WIFI_AMPDU_RX_ENABLED=y
+CONFIG_ESP32_WIFI_RX_BA_WIN=6
 CONFIG_ESP32_WIFI_RX_BA_WIN=6
 CONFIG_ESP32_WIFI_NVS_ENABLED=y
 CONFIG_ESP32_WIFI_SOFTAP_BEACON_MAX_LEN=752