Merge pull request 'release-0.5.0' (!31 ) from release-0.5.0 into main

Reviewed-on: #31
Bump version to 0.5.0 and update repo URLs.
2025-07-23 17:48:18 +03:00 · 2025-07-23 17:37:27 +03:00 · 2025-07-22 16:59:47 +03:00 · 2025-07-22 10:02:40 +03:00 · 2025-07-22 10:00:33 +03:00 · 2025-07-22 09:58:59 +03:00
25 changed files with 4163 additions and 4608 deletions
--- a/relay_chn/CMakeLists.txt
+++ b/relay_chn/CMakeLists.txt
--- a/relay_chn/Kconfig
+++ b/relay_chn/Kconfig
--- a/README.md
+++ b/README.md
@@ -38,7 +38,7 @@ dependencies:
  # Add as a custom component from git repository
  relay_chn:
    git: https://git.kozmotronik.com.tr/KozmotronikTech/relay_chn.git
-    version: '>=0.4.0'
+    version: '>=0.5.0'
 ```

 ## Usage
--- a/app_test/CMakeLists.txt
+++ b/app_test/CMakeLists.txt
@@ -1,13 +0,0 @@
-cmake_minimum_required(VERSION 3.5)
-
-# Define component search paths
-# IMPORTANT: We should tell to the ESP-IDF
-# where it can find relay_chn component.
-# We add the 'relay_chn' directory to the COMPONENT_DIRS by specifying: ../relay_chn
-set(EXTRA_COMPONENT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/../relay_chn")
-
-# Include ESP-IDF project build system
-include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-
-# Define the name of this project
-project(relay_chn_app_test)
--- a/app_test/main/CMakeLists.txt
+++ b/app_test/main/CMakeLists.txt
@@ -1,3 +0,0 @@
-idf_component_register(SRCS "test_relay_chn.c"
-                       INCLUDE_DIRS "."
-                       REQUIRES unity relay_chn)
--- a/app_test/main/test_relay_chn.c
+++ b/app_test/main/test_relay_chn.c
@@ -1,443 +0,0 @@
-#include "driver/gpio.h"
-#include "unity.h"
-#include "unity_test_utils.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]);
-// 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) {
-    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 returns void
-        vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms)); // Wait for FREE state
-    }
-    ESP_LOGI("TEST_SETUP", "All channels initialized to RELAY_CHN_STATE_FREE.");
-}
-
-void tearDown(void) {
-    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 returns void
-        vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms)); // Wait for FREE state
-    }
-    ESP_LOGI("TEST_TEARDOWN", "All channels returned to RELAY_CHN_STATE_FREE.");
-}
-
-// --- 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_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));
-    }
-}
-
-// 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));
-
-        // 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 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.");
-    }
-}
-
-
-// ### 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 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;
-
-    // Prepare channel by running forward first to set last_run_cmd
-    prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
-
-    // 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));
-
-    // 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();
-
-    // 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
-    }
-}
--- a/app_test/sdkconfig
+++ b/app_test/sdkconfig
--- a/app_test/sdkconfig.old
+++ b/app_test/sdkconfig.old
--- a/0
+++ b/0
--- a/relay_chn/idf_component.yml
+++ b/relay_chn/idf_component.yml
@@ -1,6 +1,6 @@
 name: relay_chn
-version: "0.4.0"
+version: "0.5.0"
 description: "Custom component for relay channel control"
 license: "MIT"
-url: "https://git.kozmotronik.com.tr/KozmotronikTech/relay_chn_component"
-repository: "https://git.kozmotronik.com.tr/KozmotronikTech/relay_chn_component.git"
+url: "https://git.kozmotronik.com.tr/KozmotronikTech/relay_chn"
+repository: "https://git.kozmotronik.com.tr/KozmotronikTech/relay_chn.git"
--- a/relay_chn/include/relay_chn.h
+++ b/relay_chn/include/relay_chn.h
@@ -49,6 +49,7 @@ typedef enum relay_chn_direction_enum relay_chn_direction_t;
 * @brief Enums that represent the state of a relay channel.
 */
 enum relay_chn_state_enum {
+    RELAY_CHN_STATE_UNDEFINED,  ///< The relay channel state is undefined.
    RELAY_CHN_STATE_FREE,       ///< The relay channel is free to run or execute commands.
    RELAY_CHN_STATE_STOPPED,    ///< The relay channel is stopped and not running.
    RELAY_CHN_STATE_FORWARD,    ///< The relay channel is running in the forward direction.
@@ -96,6 +97,13 @@ typedef void (*relay_chn_state_listener_t)(uint8_t chn_id, relay_chn_state_t old
 */
 esp_err_t relay_chn_create(const gpio_num_t* gpio_map, uint8_t gpio_count);

+/**
+ * @brief Destroy the relay channels and free resources.
+ *
+ * This function cleans up the relay channels and releases any resources allocated during their creation.
+ */
+void relay_chn_destroy(void);
+
 /**
 * @brief Register a channel state change listener.
 * 
--- a/relay_chn/sdkconfig.defaults
+++ b/relay_chn/sdkconfig.defaults
@@ -1,5 +0,0 @@
-# For IDF 5.0
-CONFIG_ESP_TASK_WDT_EN=n
-
-# For IDF4.4
-CONFIG_ESP_TASK_WDT=n
--- a/scripts/run_tests.sh
+++ b/scripts/run_tests.sh
@@ -0,0 +1,156 @@
+#!/usr/bin/env bash
+
+set -e
+
+# ==== 1. Check ESP-IDF environment ====
+if [[ -z "$IDF_PATH" ]]; then
+  echo "❌ ESP-IDF environment not found. Please source the export.sh file first:"
+  echo "'. $HOME/esp/esp-idf/export.sh' or wherever the ESP-IDF is installed"
+  exit 1
+fi
+
+# ==== 2. Valid Modes and Defaults ====
+valid_test_tags=("core" "tilt" "listener" "all" "relay_chn")
+arg_tag="all" # Default to 'all' if no tag specified
+arg_clean=false
+arg_log=false
+arg_dry_run=false
+arg_sdkconfig_file=""
+flag_file=false
+
+print_help() {
+    echo "Usage: $0 -t <tags> [OPTIONS]"
+    echo ""
+    echo "This script builds and runs tests for the relay_chn component using QEMU."
+    echo ""
+    echo "Arguments:"
+    echo "  -t, --tag [relay_chn|core|tilt|listener|all]  Specify which test tag to run."
+    echo ""
+    echo "  If no tag is specified, it defaults to 'all'."
+    echo ""
+    echo "Options:"
+    echo "  -f, --file <path>                    Specify a custom sdkconfig file to use for the build."
+    echo "                                       Defaults to 'sdkconfig.defaults' if not provided."
+    echo "  -c, --clean                          Perform a 'fullclean' before building the tests."
+    echo "  -l, --log                            Log the test output to a timestamped file."
+    echo "  -n, --dry-run                        Build the project without running qemu."
+    echo "  -h, --help                           Show this help message and exit."
+}
+
+help() {
+  print_help
+  exit 0
+}
+
+usage() {
+  print_help
+  exit 1
+}
+
+# ==== 3. Argument Parsing ====
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --tag|-t)
+      arg_tag="$2"
+      shift 2
+      ;;
+    --file|-f)
+      arg_sdkconfig_file="$2"
+      flag_file=true
+      shift 2
+      ;;
+    --clean|-c)
+      arg_clean=true
+      shift
+      ;;
+    --log|-l)
+      arg_log=true
+      shift
+      ;;
+    --dry-run|-n)
+      arg_dry_run=true
+      shift
+      ;;
+    --help|-h)
+      help
+      ;;
+    *)
+      usage
+      ;;
+  esac
+done
+
+# ==== 4. Validity Check ====
+if [[ ! " ${valid_test_tags[*]} " =~ " $arg_tag " ]]; then
+    echo "❌ Invalid mode: '$arg_tag'"
+    usage
+fi
+
+# ==== 5. Resolve Paths and Switch to Working Directory ====
+script_dir=$(dirname "$(readlink -f "$0")")
+project_root=$(dirname "$script_dir")
+
+echo "🔍 Searching for 'test_apps' directory in '$project_root'..."
+test_apps_dir=$(find "$project_root" -type d -name "test_apps" | head -n 1)
+
+if [[ -z "$test_apps_dir" || ! -d "$test_apps_dir" ]]; then
+    echo "❌ 'test_apps' directory not found within the project root: '$project_root'"
+    echo "   Please ensure the script is in a 'scripts' directory and 'test_apps' is a sibling."
+    exit 1
+fi
+echo "✅ Found 'test_apps' at: $test_apps_dir"
+
+if $flag_file; then
+    if [[ -z "$arg_sdkconfig_file" || ! -f "$arg_sdkconfig_file" ]]; then
+        echo "❌ Invalid or missing file: '$arg_sdkconfig_file'"
+        usage
+    fi
+    # Resolve to an absolute path to work correctly after changing directory
+    arg_sdkconfig_file=$(readlink -f "$arg_sdkconfig_file")
+else
+    echo "⚠️ No SDK configuration file provided. Using default sdkconfig."
+    arg_sdkconfig_file="$test_apps_dir/sdkconfig.defaults"
+fi
+
+echo "🧪 Test mode: $arg_tag"
+echo "🧹 Clean: $arg_clean | 📄 Log: $arg_log"
+
+echo "📂 Changing to working directory: $test_apps_dir"
+cd "$test_apps_dir" || exit 1
+
+# ==== 6. Clean if requested ====
+if $arg_clean; then
+  echo "🧹 Doing Fullclean..."
+  idf.py fullclean
+  rm sdkconfig
+fi
+
+# ==== 7. Building and Running Tests ====
+# In some locales, we can get errors like: "Error: unknown opcode or format name 'wsr.IBREAKA1'"
+# The 'LC_ALL=C' env variable is set to ensure consistent locale settings.
+LC_ALL=C \
+SDKCONFIG_DEFAULTS="$arg_sdkconfig_file" \
+RELAY_CHN_UNITY_TEST_GROUP_TAG="$arg_tag" \
+idf.py reconfigure build
+
+echo "🚀 Running test with QEMU..."
+
+if $arg_log; then
+    TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
+    LOGFILE="test_log_${arg_tag}_$TIMESTAMP.txt"
+    if $arg_dry_run; then
+        echo "🔍 Dry run mode: Logging to $LOGFILE but not executing." | tee "$LOGFILE"
+        echo "Command: idf.py qemu" | tee "$LOGFILE"
+    else
+        echo "📜 Logging test output to: $LOGFILE"
+        idf.py qemu --qemu-extra-args "-no-reboot" | tee "$LOGFILE"
+    fi
+else
+    if $arg_dry_run; then
+        echo "🔍 Dry run mode: Not executing idf.py qemu."
+        echo "Command: idf.py qemu"
+    else
+        echo "🚀 Running idf.py qemu..."
+        idf.py qemu --qemu-extra-args "-no-reboot"
+    fi
+fi
--- a/relay_chn/src/relay_chn.c
+++ b/relay_chn/src/relay_chn.c
@@ -23,6 +23,7 @@
 #include "esp_event_base.h"
 #include "esp_event.h"
 #include "relay_chn.h"
+#include "freertos/idf_additions.h"
 #include "sdkconfig.h"


@@ -180,13 +181,19 @@ static esp_err_t relay_chn_dispatch_tilt_cmd(relay_chn_t *relay_chn, relay_chn_t


 /**
- * @brief Structure to manage the state change listeners. 
+ * @brief Structure to hold a listener entry in the linked list. 
 */
-struct relay_chn_state_listener_manager_type {
-    uint8_t listener_count;                 ///< The number of registered listeners.
-    relay_chn_state_listener_t *listeners;  ///< The list that holds references to the registered listeners.
-} relay_chn_state_listener_manager;
+typedef struct relay_chn_listener_entry_type {
+    relay_chn_state_listener_t listener;  ///< The listener function pointer.
+    ListItem_t list_item;                 ///< FreeRTOS list item.
+} relay_chn_listener_entry_t;

+/**
+ * @brief The list that holds references to the registered listeners.
+ *
+ * Uses a FreeRTOS list for safe and dynamic management of listeners.
+ */
+static List_t relay_chn_listener_list;

 static relay_chn_t relay_channels[RELAY_CHN_COUNT];
 static esp_event_loop_handle_t relay_chn_event_loop;
@@ -291,6 +298,8 @@ static esp_err_t relay_chn_create_event_loop()

 esp_err_t relay_chn_create(const gpio_num_t* gpio_map, uint8_t gpio_count)
 {
+    ESP_RETURN_ON_FALSE(gpio_map, ESP_ERR_INVALID_ARG, TAG, "gpio_map cannot be NULL");
+
    // Check if the device's GPIOs are enough for the number of channels
    if (RELAY_CHN_COUNT > (GPIO_PIN_COUNT / 2)) {
        ESP_LOGE(TAG, "Not enough GPIOs for the number of channels!");
@@ -360,84 +369,117 @@ esp_err_t relay_chn_create(const gpio_num_t* gpio_map, uint8_t gpio_count)
    ESP_RETURN_ON_ERROR(ret, TAG, "Failed to initialize tilt feature");
 #endif

-    // Init the state listener manager
-    relay_chn_state_listener_manager.listeners = malloc(sizeof(relay_chn_state_listener_t*));
-    if (relay_chn_state_listener_manager.listeners == NULL) {
-        ESP_LOGE(TAG, "Failed to initialize memory for the listeners!");
-        ret = ESP_ERR_NO_MEM;
-    }
+    // Init the state listener list
+    vListInitialise(&relay_chn_listener_list);

    return ret;
 }

-static int relay_chn_listener_index(relay_chn_state_listener_t listener)
+void relay_chn_destroy(void)
 {
-    for (int i = 0; i < relay_chn_state_listener_manager.listener_count; i++) {
-        if (relay_chn_state_listener_manager.listeners[i] == listener) {
-            // This is the listener to unregister. Check if it is in the middle
-            ESP_LOGD(TAG, "relay_chn_listener_index: Listener %p; found at index %d.", listener, i);
-            return i;
+    // Destroy the event loop
+    esp_event_loop_delete(relay_chn_event_loop);
+    relay_chn_event_loop = NULL;
+
+    // Free the listeners
+    while (listCURRENT_LIST_LENGTH(&relay_chn_listener_list) > 0) {
+        ListItem_t *pxItem = listGET_HEAD_ENTRY(&relay_chn_listener_list);
+        relay_chn_listener_entry_t *entry = listGET_LIST_ITEM_OWNER(pxItem);
+        uxListRemove(pxItem);
+        free(entry);
+    }
+
+    // Destroy the timers and reset GPIOs
+    for (int i = 0; i < RELAY_CHN_COUNT; i++) {
+        relay_chn_t* relay_chn = &relay_channels[i];
+        if (relay_chn->inertia_timer != NULL) {
+            esp_timer_delete(relay_chn->inertia_timer);
+            relay_chn->inertia_timer = NULL;
+        }
+
+#if RELAY_CHN_ENABLE_TILTING == 1
+        if (relay_chn->tilt_control.tilt_timer != NULL) {
+            esp_timer_delete(relay_chn->tilt_control.tilt_timer);
+            relay_chn->tilt_control.tilt_timer = NULL;
+        }
+#endif // RELAY_CHN_ENABLE_TILTING
+
+        gpio_reset_pin(relay_chn->output.forward_pin);
+        gpio_reset_pin(relay_chn->output.reverse_pin);
    }
 }
-    return -1;
+
+/**
+ * @brief Find a listener entry in the list by its function pointer.
+ *
+ * This function replaces the old index-based search and is used to check
+ * for the existence of a listener before registration or for finding it
+ * during unregistration.
+ *
+ * @param listener The listener function pointer to find.
+ * @return Pointer to the listener entry if found, otherwise NULL.
+ */
+static relay_chn_listener_entry_t* find_listener_entry(relay_chn_state_listener_t listener)
+{
+    // Iterate through the linked list of listeners
+    for (ListItem_t *pxListItem = listGET_HEAD_ENTRY(&relay_chn_listener_list);
+         pxListItem != listGET_END_MARKER(&relay_chn_listener_list);
+         pxListItem = listGET_NEXT(pxListItem)) {
+        
+        relay_chn_listener_entry_t *entry = (relay_chn_listener_entry_t *) listGET_LIST_ITEM_OWNER(pxListItem);
+        if (entry->listener == listener) {
+            // Found the listener, return the entry
+            return entry;
+        }
+    }
+
+    // Listener was not found in the list
+    return NULL;
 }

 esp_err_t relay_chn_register_listener(relay_chn_state_listener_t listener)
 {
-    if (listener == NULL) {
-        ESP_LOGE(TAG, "relay_chn_register_listener: A NULL listener given.");
-        return ESP_ERR_INVALID_ARG;
-    }
+    ESP_RETURN_ON_FALSE(listener, ESP_ERR_INVALID_ARG, TAG, "Listener cannot be NULL");

-    if (relay_chn_listener_index(listener) > -1) {
-        ESP_LOGD(TAG, "relay_chn_register_listener: The listener %p is already registered.", listener);
+    // Check for duplicates
+    if (find_listener_entry(listener) != NULL) {
+        ESP_LOGD(TAG, "Listener %p already registered", listener);
        return ESP_OK;
    }

-    ESP_LOGD(TAG, "relay_chn_register_listener: Register listener: %p", listener);
-    relay_chn_state_listener_manager.listeners[relay_chn_state_listener_manager.listener_count] = listener;
-    // Update listener count
-    relay_chn_state_listener_manager.listener_count++;
+    // Allocate memory for the new listener entry
+    relay_chn_listener_entry_t *entry = malloc(sizeof(relay_chn_listener_entry_t));
+    ESP_RETURN_ON_FALSE(entry, ESP_ERR_NO_MEM, TAG, "Failed to allocate memory for listener");

+    // Initialize and insert the new listener
+    entry->listener = listener;
+    vListInitialiseItem(&(entry->list_item));
+    listSET_LIST_ITEM_OWNER(&(entry->list_item), (void *)entry);
+    vListInsertEnd(&relay_chn_listener_list, &(entry->list_item));
+
+    ESP_LOGD(TAG, "Registered listener %p", listener);
    return ESP_OK;
 }

 void relay_chn_unregister_listener(relay_chn_state_listener_t listener)
 {
-    if (listener == NULL) {
-        ESP_LOGD(TAG, "relay_chn_unregister_listener: A NULL listener given, nothing to do.");
-        return;
-    }
-    // Search the listener in the listeners list and get its index if exists
-    int i = relay_chn_listener_index(listener);
-    if (i == -1) {
-        ESP_LOGD(TAG, "relay_chn_unregister_listener: %p is not registered already.", listener);
+    if (listener == NULL)
+    {
+        ESP_LOGD(TAG, "Cannot unregister a NULL listener.");
        return;
    }

-    uint8_t max_index = relay_chn_state_listener_manager.listener_count - 1;
-    // Check whether the listener's index is in the middle
-    if (i == max_index) {
-        // free(&relay_chn_state_listener_manager.listeners[i]);
-        relay_chn_state_listener_manager.listeners[i] = NULL;
+    // Find the listener entry in the list
+    relay_chn_listener_entry_t *entry = find_listener_entry(listener);
+
+    if (entry != NULL) {
+        // Remove the item from the list and free the allocated memory
+        uxListRemove(&(entry->list_item));
+        free(entry);
+        ESP_LOGD(TAG, "Unregistered listener %p", listener);
+    } else {
+        ESP_LOGD(TAG, "Listener %p not found for unregistration.", listener);
    }
-    else {
-        // It is in the middle, so align the next elements in the list and then free the last empty pointer
-        // Align the next elements
-        uint8_t num_of_elements = max_index - i;
-        relay_chn_state_listener_t *pnext = NULL;
-        // (i + j): current index; (i + j + 1): next index
-        for (uint8_t j = 0; j < num_of_elements; j++) {
-            uint8_t current_index = i + j;
-            uint8_t next_index = current_index + 1;
-            pnext = &relay_chn_state_listener_manager.listeners[next_index];
-            relay_chn_state_listener_manager.listeners[current_index] = *pnext;
-        }
-        // free(&relay_chn_state_listener_manager.listeners[max_index]); // Free the last element
-        relay_chn_state_listener_manager.listeners[max_index] = NULL; // Free the last element
-    }
-    // Decrease listener count
-    relay_chn_state_listener_manager.listener_count--;
 }

 /**
@@ -492,17 +534,24 @@ static esp_err_t relay_chn_start_esp_timer_once(esp_timer_handle_t esp_timer, ui

 static void relay_chn_update_state(relay_chn_t *relay_chn, relay_chn_state_t new_state)
 {
-    relay_chn_state_t old = relay_chn->state;
+    relay_chn_state_t old_state = relay_chn->state;
+
+    // Only update and notify if the state has actually changed.
+    if (old_state == new_state) {
+        return;
+    }
+
    relay_chn->state = new_state;

-    for (uint8_t i = 0; i < relay_chn_state_listener_manager.listener_count; i++) {
-        relay_chn_state_listener_t listener = relay_chn_state_listener_manager.listeners[i];
-        if (listener == NULL) {
-            relay_chn_state_listener_manager.listener_count -= 1;
-            ESP_LOGD(TAG, "relay_chn_update_state: A listener is NULL at index: %u", i);
-        }
+    // Iterate through the linked list of listeners and notify them.
+    for (ListItem_t *pxListItem = listGET_HEAD_ENTRY(&relay_chn_listener_list);
+         pxListItem != listGET_END_MARKER(&relay_chn_listener_list);
+         pxListItem = listGET_NEXT(pxListItem)) {
+        relay_chn_listener_entry_t *entry = (relay_chn_listener_entry_t *) listGET_LIST_ITEM_OWNER(pxListItem);
+        if (entry && entry->listener) {
            // Emit the state change to the listeners
-        listener(relay_chn->id, old, new_state);
+            entry->listener(relay_chn->id, old_state, new_state);
+        }
    }
 }

@@ -648,16 +697,16 @@ static void relay_chn_issue_cmd(relay_chn_t* relay_chn, relay_chn_cmd_t cmd)
 /* relay_chn APIs */
 relay_chn_state_t relay_chn_get_state(uint8_t chn_id)
 {
-    if (!relay_chn_is_channel_id_valid(chn_id)) {
-        return RELAY_CHN_STATE_STOPPED;
+    if (!relay_chn_is_channel_id_valid(chn_id) || chn_id == RELAY_CHN_ID_ALL) {
+        return RELAY_CHN_STATE_UNDEFINED;
    }
    return relay_channels[chn_id].state;
 }

 char *relay_chn_get_state_str(uint8_t chn_id)
 {
-    if (!relay_chn_is_channel_id_valid(chn_id)) {
-        return "INVALID";
+    if (!relay_chn_is_channel_id_valid(chn_id) || chn_id == RELAY_CHN_ID_ALL) {
+        return relay_chn_state_str(RELAY_CHN_STATE_UNDEFINED);
    }
    return relay_chn_state_str(relay_channels[chn_id].state);
 }
@@ -1219,8 +1268,11 @@ static uint32_t relay_chn_tilt_count_update(relay_chn_t *relay_chn)
            return ++relay_chn->tilt_control.tilt_counter.tilt_forward_count;
        }
        else if (relay_chn->tilt_control.cmd == RELAY_CHN_TILT_CMD_REVERSE) {
-            if (relay_chn->tilt_control.tilt_counter.tilt_forward_count > 0)
-                return --relay_chn->tilt_control.tilt_counter.tilt_forward_count;
+            if (relay_chn->tilt_control.tilt_counter.tilt_forward_count > 0) {
+                --relay_chn->tilt_control.tilt_counter.tilt_forward_count;
+                // Still should do one more move, return non-zero value
+                return 1;
+            }
            else
                return 0;
        }
@@ -1234,8 +1286,11 @@ static uint32_t relay_chn_tilt_count_update(relay_chn_t *relay_chn)
            return ++relay_chn->tilt_control.tilt_counter.tilt_reverse_count;
        }
        else if (relay_chn->tilt_control.cmd == RELAY_CHN_TILT_CMD_FORWARD) {
-            if (relay_chn->tilt_control.tilt_counter.tilt_reverse_count > 0)
-                return --relay_chn->tilt_control.tilt_counter.tilt_reverse_count;
+            if (relay_chn->tilt_control.tilt_counter.tilt_reverse_count > 0) {
+                --relay_chn->tilt_control.tilt_counter.tilt_reverse_count;
+                // Still should do one more move, return non-zero value
+                return 1;
+            }
            else
                return 0;
        }
--- a/test_apps/CMakeLists.txt
+++ b/test_apps/CMakeLists.txt
@@ -0,0 +1,20 @@
+# This is the project CMakeLists.txt file for the test subproject
+cmake_minimum_required(VERSION 3.5)
+
+# Define component search paths
+# IMPORTANT: We should tell to the ESP-IDF
+# where it can find relay_chn component.
+# We add the 'relay_chn' root directory to the EXTRA_COMPONENT_DIRS by specifying: "../"
+set(EXTRA_COMPONENT_DIRS "../")
+
+# "Trim" the build. Include the minimal set of components, main, and anything it depends on.
+set(COMPONENTS main)
+
+# Include ESP-IDF project build system
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+
+# Inject the test tag into the build
+add_compile_definitions(RELAY_CHN_UNITY_TEST_GROUP_TAG=\"$ENV{RELAY_CHN_UNITY_TEST_GROUP_TAG}\")
+
+# Define the name of this project
+project(relay_chn_test)
--- a/test_apps/main/CMakeLists.txt
+++ b/test_apps/main/CMakeLists.txt
@@ -0,0 +1,20 @@
+# === These files must be included in any case ===
+set(srcs "test_common.c"
+         "test_app_main.c"
+         "test_relay_chn_core.c"
+         "test_relay_chn_listener.c")
+
+if(CONFIG_RELAY_CHN_ENABLE_TILTING)
+    list(APPEND srcs "test_relay_chn_tilt.c")
+endif()
+
+message(STATUS "srcs=${srcs}")
+
+# In order for the cases defined by `TEST_CASE` to be linked into the final elf,
+# the component can be registered as WHOLE_ARCHIVE
+idf_component_register(
+    SRCS ${srcs}
+    INCLUDE_DIRS "."
+    REQUIRES unity relay_chn
+    WHOLE_ARCHIVE
+)
--- a/test_apps/main/test_app_main.c
+++ b/test_apps/main/test_app_main.c
@@ -0,0 +1,49 @@
+
+#include "esp_log.h"
+#include "esp_system.h"
+#include "test_common.h"
+#include "unity.h"
+#include "unity_internals.h"
+#include "unity_test_runner.h"
+#include <stdbool.h>
+
+
+#ifndef RELAY_CHN_UNITY_TEST_GROUP_TAG
+#warning "RELAY_CHN_UNITY_TEST_GROUP_TAG is not defined, using default 'relay_chn'"
+#define RELAY_CHN_UNITY_TEST_GROUP_TAG "relay_chn"
+#endif
+
+void setUp() 
+{
+    g_is_component_initialized = false;
+}
+
+void tearDown()
+{
+    // Clean up after each test
+    if (g_is_component_initialized) {
+        relay_chn_destroy();
+        g_is_component_initialized = false;
+    }
+}
+
+void app_main(void) 
+{
+    UNITY_BEGIN();
+
+    // Log general test information
+    ESP_LOGI(TEST_TAG, "Available test count: %d", unity_get_test_count());
+    ESP_LOGI(TEST_TAG, "Running tests for tag: %s", RELAY_CHN_UNITY_TEST_GROUP_TAG);
+
+    if (strncmp(RELAY_CHN_UNITY_TEST_GROUP_TAG, "all", strlen("all")) == 0) {
+        unity_run_all_tests();
+    }
+    else {
+        unity_run_tests_by_tag(RELAY_CHN_UNITY_TEST_GROUP_TAG, false);
+    }
+
+    UNITY_END();
+    ESP_LOGI(TEST_TAG, "All tests complete.");
+    
+    esp_restart(); // Restart to invoke qemu exit
+}
--- a/test_apps/main/test_common.c
+++ b/test_apps/main/test_common.c
@@ -0,0 +1,17 @@
+#include "test_common.h"
+
+const char *TEST_TAG = "RELAY_CHN_TEST";
+
+// GPIO eşlemesi (örn: GPIO_NUM_4 vs GPIO_NUM_5)
+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;
+
+// Konfigürasyon tabanlı inertia süresi
+const uint32_t opposite_inertia_ms = CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS;
+const uint32_t test_delay_margin_ms = 50;  // ms toleransı
+
+bool g_is_component_initialized = false;
--- a/test_apps/main/test_common.h
+++ b/test_apps/main/test_common.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <string.h> // For memset
+#include "unity.h"
+#include "relay_chn.h"
+#include "driver/gpio.h"
+#include "esp_log.h"
+#include "sdkconfig.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+
+// Test log tag
+extern const char *TEST_TAG;
+
+// GPIO konfigürasyonları
+extern const gpio_num_t gpio_map[];
+extern const uint8_t gpio_count;
+extern const uint8_t relay_chn_count;
+
+// Config parametreleri
+extern const uint32_t opposite_inertia_ms;
+extern const uint32_t test_delay_margin_ms;
+
+// Init durumu
+extern bool g_is_component_initialized;
--- a/test_apps/main/test_relay_chn_core.c
+++ b/test_apps/main/test_relay_chn_core.c
@@ -0,0 +1,403 @@
+#include "test_common.h"
+
+
+// --- Initialization Tests ---
+
+TEST_CASE("relay_chn_create handles invalid arguments", "[relay_chn][core]")
+{
+    // 1. Test with NULL gpio_map
+    TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_create(NULL, gpio_count));
+
+    // 2. Test with incorrect gpio_count (must be RELAY_CHN_COUNT * 2)
+    TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_create(gpio_map, gpio_count - 1));
+    TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_create(gpio_map, 1));
+    TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_create(gpio_map, 0));
+
+    // 3. Test with invalid GPIO numbers (GPIO_NUM_MAX is an invalid GPIO for output)
+    gpio_num_t invalid_gpio_map[] = {GPIO_NUM_4, GPIO_NUM_MAX, GPIO_NUM_18, GPIO_NUM_19};
+    TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_create(invalid_gpio_map, gpio_count));
+}
+
+// --- Basic Functionality Tests ---
+
+// TEST_CASE: Test that relay channels initialize correctly to RELAY_CHN_STATE_FREE
+TEST_CASE("Relay channels initialize correctly to FREE state", "[relay_chn][core]") {
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(i));
+    }
+}
+
+// TEST_CASE: Test that relays do nothing when an invlid channel id given
+TEST_CASE("Run forward does nothing if channel id is invalid", "[relay_chn][core]") {
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        int invalid_id = relay_chn_count * 2 + i;
+        relay_chn_run_forward(invalid_id); // 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_FREE, relay_chn_get_state(i));
+    }
+}
+
+// TEST_CASE: Test that relays run in the forward direction and update their state
+TEST_CASE("Relay channels run forward and update state", "[relay_chn][core]") {
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    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));
+    }
+}
+
+// TEST_CASE: Test that relays do nothing when an invlid channel id given
+TEST_CASE("Run reverse does nothing if channel id is invalid", "[relay_chn][core]") {
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // Verify that no valid channels were affected
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        int invalid_id = relay_chn_count * 2 + i;
+        // Call run_reverse with an invalid ID
+        relay_chn_run_reverse(invalid_id);
+        vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(i));
+    }
+}
+
+// TEST_CASE: Test that relays run in the reverse direction and update their state
+TEST_CASE("Relay channels run reverse and update state", "[relay_chn][core]") {
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    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));
+    }
+}
+
+
+// ### Broadcast Command (RELAY_CHN_ID_ALL) Tests
+
+TEST_CASE("run_forward with ID_ALL sets all channels to FORWARD", "[relay_chn][core][id_all]")
+{
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    relay_chn_run_forward(RELAY_CHN_ID_ALL);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(i));
+    }
+}
+
+TEST_CASE("run_reverse with ID_ALL sets all channels to REVERSE", "[relay_chn][core][id_all]")
+{
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    relay_chn_run_reverse(RELAY_CHN_ID_ALL);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(i));
+    }
+}
+
+TEST_CASE("stop with ID_ALL stops all running channels", "[relay_chn][core][id_all]")
+{
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // 1. Start all channels forward to ensure they are in a known running state
+    relay_chn_run_forward(RELAY_CHN_ID_ALL);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+
+    // 2. Stop all channels using the broadcast command
+    relay_chn_stop(RELAY_CHN_ID_ALL);
+    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+
+    // 3. Verify all channels have transitioned to the FREE state
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(i));
+    }
+}
+
+
+
+// TEST_CASE: 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][core]") {
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    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));
+
+        // 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: Get state should return UNDEFINED when id is not valid
+TEST_CASE("Get state returns UNDEFINED when id is invalid", "[relay_chn][core]") {
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        int invalid_id = relay_chn_count * 2 + i;
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_UNDEFINED, relay_chn_get_state(invalid_id));
+    }
+    // Test for running states also
+    relay_chn_run_forward(RELAY_CHN_ID_ALL);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        int invalid_id = relay_chn_count * 2 + i;
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_UNDEFINED, relay_chn_get_state(invalid_id));
+    }
+}
+
+// TEST_CASE: Get state string should return "UNKNOWN" when id is not valid
+TEST_CASE("Get state string returns UNKNOWN when id is invalid", "[relay_chn][core]") {
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        int invalid_id = relay_chn_count * 2 + i;
+        TEST_ASSERT_EQUAL_STRING("UNKNOWN", relay_chn_get_state_str(invalid_id));
+    }
+    // Test for running states also
+    relay_chn_run_forward(RELAY_CHN_ID_ALL);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        int invalid_id = relay_chn_count * 2 + i;
+        TEST_ASSERT_EQUAL_STRING("UNKNOWN", relay_chn_get_state_str(invalid_id));
+    }
+}
+
+// TEST_CASE: Test independent operation of multiple relay channels
+TEST_CASE("Multiple channels can operate independently", "[relay_chn][core]") {
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    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.");
+    }
+}
+
+
+// ### Inertia and State Transition Tests
+
+// This section specifically targets the inertia periods and complex state transitions as per the component's logic.
+
+// TEST_CASE: 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][core][inertia]") {
+    uint8_t ch = 0; // Channel to test
+
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // 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: 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][core][inertia]") {
+    uint8_t ch = 0;
+
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // 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: 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][core][inertia]") {
+    uint8_t ch = 0;
+
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // 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: 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][core][inertia]") {
+    uint8_t ch = 0;
+
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // 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));
+}
+
+// ### Direction Flipping Tests
+
+TEST_CASE("Single channel direction can be flipped", "[relay_chn][core][direction]")
+{
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+    const uint8_t ch = 0;
+
+    // 1. Initial direction should be default
+    TEST_ASSERT_EQUAL(RELAY_CHN_DIRECTION_DEFAULT, relay_chn_get_direction(ch));
+
+    // 2. Flip the direction
+    relay_chn_flip_direction(ch);
+    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms)); // Wait for flip inertia
+
+    // 3. Verify direction is flipped
+    TEST_ASSERT_EQUAL(RELAY_CHN_DIRECTION_FLIPPED, relay_chn_get_direction(ch));
+
+    // 4. Flip back
+    relay_chn_flip_direction(ch);
+    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms)); // Wait for flip inertia
+
+    // 5. Verify direction is back to default
+    TEST_ASSERT_EQUAL(RELAY_CHN_DIRECTION_DEFAULT, relay_chn_get_direction(ch));
+}
+
+TEST_CASE("All channels direction can be flipped simultaneously", "[relay_chn][core][direction][id_all]")
+{
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // 1. Flip all channels
+    relay_chn_flip_direction(RELAY_CHN_ID_ALL);
+    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+
+    // 2. Verify all channels are flipped
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        TEST_ASSERT_EQUAL(RELAY_CHN_DIRECTION_FLIPPED, relay_chn_get_direction(i));
+    }
+
+    // 3. Flip all back
+    relay_chn_flip_direction(RELAY_CHN_ID_ALL);
+    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+
+    // 4. Verify all channels are back to default
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        TEST_ASSERT_EQUAL(RELAY_CHN_DIRECTION_DEFAULT, relay_chn_get_direction(i));
+    }
+}
+
+TEST_CASE("Flipping a running channel stops it and flips direction", "[relay_chn][core][direction]")
+{
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+    const uint8_t ch = 0;
+
+    // 1. Start channel running and verify state
+    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));
+
+    // 2. Flip the direction while running
+    relay_chn_flip_direction(ch);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms)); // Give time for events to process
+    
+    // 3. The channel should stop as part of the flip process
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state(ch));
+
+    // 4. Wait for the flip inertia to pass, after which it should be FREE and FLIPPED
+    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(ch));
+    TEST_ASSERT_EQUAL(RELAY_CHN_DIRECTION_FLIPPED, relay_chn_get_direction(ch));
+}
+
+TEST_CASE("Direction flip handles invalid channel ID gracefully", "[relay_chn][core][direction]")
+{
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+    const uint8_t invalid_ch = relay_chn_count + 5;
+
+    relay_chn_flip_direction(invalid_ch); // Call with an invalid ID
+    TEST_ASSERT_EQUAL(RELAY_CHN_DIRECTION_DEFAULT, relay_chn_get_direction(invalid_ch));
+}
--- a/test_apps/main/test_relay_chn_listener.c
+++ b/test_apps/main/test_relay_chn_listener.c
@@ -0,0 +1,135 @@
+#include "test_common.h"
+
+
+// --- Listener Test Globals ---
+typedef struct {
+    uint8_t chn_id;
+    relay_chn_state_t old_state;
+    relay_chn_state_t new_state;
+    int call_count;
+} listener_callback_info_t;
+
+static listener_callback_info_t listener1_info;
+static listener_callback_info_t listener2_info;
+
+// --- Listener Test Helper Functions ---
+
+// Clear the memory from possible garbage values
+static void reset_listener_info(listener_callback_info_t* info) {
+    memset(info, 0, sizeof(listener_callback_info_t));
+}
+
+static void test_listener_1(uint8_t chn_id, relay_chn_state_t old_state, relay_chn_state_t new_state) {
+    listener1_info.chn_id = chn_id;
+    listener1_info.old_state = old_state;
+    listener1_info.new_state = new_state;
+    listener1_info.call_count++;
+}
+
+static void test_listener_2(uint8_t chn_id, relay_chn_state_t old_state, relay_chn_state_t new_state) {
+    listener2_info.chn_id = chn_id;
+    listener2_info.old_state = old_state;
+    listener2_info.new_state = new_state;
+    listener2_info.call_count++;
+}
+
+// ### Listener Functionality Tests
+
+TEST_CASE("Listener is called on state change", "[relay_chn][listener]") {
+    uint8_t ch = 0;
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    reset_listener_info(&listener1_info);
+
+    // 1. Register the listener
+    TEST_ESP_OK(relay_chn_register_listener(test_listener_1));
+
+    // 2. Trigger a state change
+    relay_chn_run_forward(ch);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms)); // Allow event to be processed
+
+    // 3. Verify the listener was called with correct parameters
+    TEST_ASSERT_EQUAL(1, listener1_info.call_count);
+    TEST_ASSERT_EQUAL(ch, listener1_info.chn_id);
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, listener1_info.old_state);
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, listener1_info.new_state);
+
+    // 4. Unregister to clean up
+    relay_chn_unregister_listener(test_listener_1);
+}
+
+TEST_CASE("Unregistered listener is not called", "[relay_chn][listener]") {
+    uint8_t ch = 0;
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    reset_listener_info(&listener1_info);
+
+    // 1. Register and then immediately unregister the listener
+    TEST_ESP_OK(relay_chn_register_listener(test_listener_1));
+    relay_chn_unregister_listener(test_listener_1);
+
+    // 2. Trigger a state change
+    relay_chn_run_forward(ch);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+
+    // 3. Verify the listener was NOT called
+    TEST_ASSERT_EQUAL(0, listener1_info.call_count);
+}
+
+TEST_CASE("Multiple listeners are called on state change", "[relay_chn][listener]") {
+    uint8_t ch = 0;
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    reset_listener_info(&listener1_info);
+    reset_listener_info(&listener2_info);
+
+    // 1. Register two different listeners
+    TEST_ESP_OK(relay_chn_register_listener(test_listener_1));
+    TEST_ESP_OK(relay_chn_register_listener(test_listener_2));
+
+    // 2. Trigger a state change
+    relay_chn_run_forward(ch);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+
+    // 3. Verify listener 1 was called correctly
+    TEST_ASSERT_EQUAL(1, listener1_info.call_count);
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, listener1_info.old_state);
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, listener1_info.new_state);
+
+    // 4. Verify listener 2 was also called correctly
+    TEST_ASSERT_EQUAL(1, listener2_info.call_count);
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, listener2_info.old_state);
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, listener2_info.new_state);
+
+    // 5. Clean up
+    relay_chn_unregister_listener(test_listener_1);
+    relay_chn_unregister_listener(test_listener_2);
+}
+
+TEST_CASE("Listener registration handles invalid arguments and duplicates", "[relay_chn][listener]") {
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    reset_listener_info(&listener1_info);
+
+    // 1. Registering a NULL listener should fail
+    TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_register_listener(NULL));
+
+    // 2. Unregistering a NULL listener should not crash
+    relay_chn_unregister_listener(NULL);
+
+    // 3. Registering the same listener twice should be handled gracefully
+    TEST_ESP_OK(relay_chn_register_listener(test_listener_1));
+    TEST_ESP_OK(relay_chn_register_listener(test_listener_1)); // Second call should be a no-op
+
+    // 4. Trigger a state change and verify the listener is only called ONCE
+    relay_chn_run_forward(0);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(1, listener1_info.call_count);
+
+    // 5. Clean up
+    relay_chn_unregister_listener(test_listener_1);
+}
--- a/test_apps/main/test_relay_chn_tilt.c
+++ b/test_apps/main/test_relay_chn_tilt.c
@@ -0,0 +1,389 @@
+#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
+
+// 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: 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;
+
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // Prepare channel by running forward first to set last_run_cmd
+    prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
+
+    // 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));
+
+    // 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: 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;
+
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // 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: 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]") {
+    uint8_t ch = 0;
+
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // 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: 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]") {
+    uint8_t ch = 0;
+
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // 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: 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;
+
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // 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: 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;
+
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // 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: 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;
+
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // 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: 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]") {
+    uint8_t ch = 0;
+
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // 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));
+}
+
+// ### Tilt Broadcast Command (RELAY_CHN_ID_ALL) Tests
+
+TEST_CASE("tilt_forward with ID_ALL sets all channels to TILT_FORWARD", "[relay_chn][tilt][id_all]")
+{
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // 1. Prepare all channels.
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        prepare_channel_for_tilt(i, RELAY_CHN_CMD_FORWARD);
+    }
+
+    // 2. Issue tilt forward to all channels
+    relay_chn_tilt_forward(RELAY_CHN_ID_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 < relay_chn_count; i++) {
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(i));
+    }
+}
+
+TEST_CASE("tilt_reverse with ID_ALL sets all channels to TILT_REVERSE", "[relay_chn][tilt][id_all]")
+{
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // 1. Prepare all channels.
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        prepare_channel_for_tilt(i, RELAY_CHN_CMD_REVERSE);
+    }
+
+    // 2. Issue tilt reverse to all channels
+    relay_chn_tilt_reverse(RELAY_CHN_ID_ALL);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+
+    // 3. Verify all channels are tilting reverse
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(i));
+    }
+}
+
+TEST_CASE("tilt_stop with ID_ALL stops all tilting channels", "[relay_chn][tilt][id_all]")
+{
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // 1. Prepare and start all channels tilting forward
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        prepare_channel_for_tilt(i, RELAY_CHN_CMD_REVERSE);
+    }
+    relay_chn_tilt_forward(RELAY_CHN_ID_ALL);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+
+    // 2. Stop tilting on all channels
+    relay_chn_tilt_stop(RELAY_CHN_ID_ALL);
+    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+
+    // 3. Verify all channels are free
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(i));
+    }
+}
+
+TEST_CASE("tilt_auto with ID_ALL tilts channels based on last run direction", "[relay_chn][tilt][id_all]")
+{
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // This test requires at least 2 channels to demonstrate different behaviors
+    TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(2, 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);
+
+    // 2. Issue auto tilt command to all channels
+    relay_chn_tilt_auto(RELAY_CHN_ID_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));
+}
+
+// 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;
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // Prepare FORWARD
+    prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
+    relay_chn_tilt_auto(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));
+
+    // Prepare REVERSE
+    prepare_channel_for_tilt(ch, RELAY_CHN_CMD_REVERSE);
+    relay_chn_tilt_auto(ch);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch));
+}
+
+// Test sensitivity set/get
+TEST_CASE("relay_chn_tilt_sensitivity_set and get", "[relay_chn][tilt][sensitivity]") {
+    uint8_t ch = 0;
+    uint8_t val = 0;
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    relay_chn_tilt_sensitivity_set(ch, 0);
+    TEST_ESP_OK(relay_chn_tilt_sensitivity_get(ch, &val, 1));
+    TEST_ASSERT_EQUAL_UINT8(0, val);
+
+    relay_chn_tilt_sensitivity_set(ch, 50);
+    TEST_ESP_OK(relay_chn_tilt_sensitivity_get(ch, &val, 1));
+    TEST_ASSERT_EQUAL_UINT8(50, val);
+
+    relay_chn_tilt_sensitivity_set(ch, 100);
+    TEST_ESP_OK(relay_chn_tilt_sensitivity_get(ch, &val, 1));
+    TEST_ASSERT_EQUAL_UINT8(100, val);
+
+    // Set all channels
+    relay_chn_tilt_sensitivity_set(RELAY_CHN_ID_ALL, 42);
+    uint8_t vals[CONFIG_RELAY_CHN_COUNT] = {0};
+    TEST_ESP_OK(relay_chn_tilt_sensitivity_get(RELAY_CHN_ID_ALL, vals, relay_chn_count));
+    for (int i = 0; i < relay_chn_count; ++i) {
+        TEST_ASSERT_EQUAL_UINT8(42, vals[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]") {
+    uint8_t ch = 0;
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
+
+    // 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));
+    }
+
+    // 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));
+        }
+    }
+
+    // Extra reverse tilt should fail (counter exhausted)
+    relay_chn_tilt_reverse(ch);
+    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);
+}
+
+// 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;
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
+    relay_chn_tilt_forward(ch);
+    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
+
+    // Issue run reverse while in TILT_FORWARD
+    relay_chn_run_reverse(ch);
+    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);
+}
--- a/test_apps/sdkconfig
+++ b/test_apps/sdkconfig
--- a/test_apps/sdkconfig.defaults
+++ b/test_apps/sdkconfig.defaults
@@ -0,0 +1,8 @@
+# Disable task WDT for tests
+CONFIG_ESP_TASK_WDT_INIT=n
+
+# Relay Channel Driver Default Configuration for Testing
+# Keep this as short as possible for tests
+CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS=200
+CONFIG_RELAY_CHN_COUNT=2
+CONFIG_RELAY_CHN_ENABLE_TILTING=y
--- a/test_apps/sdkconfig.old
+++ b/test_apps/sdkconfig.old
Author	SHA1	Message	Date
Ismail Sahillioglu	1776c81c8d	Merge pull request 'release-0.5.0' (!31 ) from release-0.5.0 into main Reviewed-on: #31	2025-07-23 17:48:18 +03:00
ismail	2e81966afb	Bump version to 0.5.0 and update repo URLs.	2025-07-23 17:37:27 +03:00
Ismail Sahillioglu	5734f47cd3	Merge pull request 'feat/1030-more-unit-tests' (!29 ) from feat/1030-more-unit-tests into dev Reviewed-on: #29	2025-07-22 16:59:47 +03:00
ismail	d884f5f45c	Add missing test cases for tilt API. Added missing test cases for the tilt API. Closes #1056.	2025-07-22 10:02:40 +03:00
ismail	c7678d6084	Add restart chip to make qemu exit in tests.	2025-07-22 10:00:33 +03:00
ismail	8527ebea83	Fix imbalanced tilt counts. Fixed the tilt count logic that causes an imbalance in tilting within the same run frame but opposite direction. Fixes #1057.	2025-07-22 09:58:59 +03:00
ismail	f31eae649f	Add a shell utility for running tests.	2025-07-21 18:47:41 +03:00
ismail	a143484748	Break down tests into categories. Break down tests into categories to improve maintainability and test granularity. This makes it easier to execute unit tests in CI/CD pipelines. Closes #1054.	2025-07-21 15:37:49 +03:00
ismail	a9a8169710	Add test cases for `ID_ALL` channel id. Add test cases to test all relevant functions that support operating with the `RELAY_CHN_ID_ALL` channel id. Closes #1052.	2025-07-16 11:42:44 +03:00
ismail	74f4341c1d	Add test cases for direction flip. Closes #1051.	2025-07-15 16:14:19 +03:00
ismail	a587036093	Add tests for init error handling. Added tests for covering initialization error handling cases like; NULL pointer, invalid GPIO count etc. This changed implied removing the `relay_chn_create` from the Unity's `setUp` function and place it in each testcase. Refs #1050, #1030.	2025-07-15 12:23:21 +03:00
ismail	82312ba7c3	Add NULL handling for the `gpio_num` pointer. Fixes #1050.	2025-07-15 12:17:46 +03:00
ismail	db62a7b5b2	Fix listener memory allocation bug. - Replaced the buggy, oldschool, plain pointer based list approach with more robust FreeRTOS linked list implementation for the listener API. Fixes #1049. - Added relevant test cases. Refs #1030.	2025-07-14 18:49:47 +03:00
ismail	1ee70be715	Fix invalid ID test loops.	2025-07-14 18:49:47 +03:00
ismail	f1cb928341	Add missing destroy function. The component allocates resources (timers, event loop) in relay_chn_create but never frees them. This is a resource leak. Hence, a destroy function added to free the resources gracefully. Fixes #1048.	2025-07-14 11:37:14 +03:00
ismail	a90649a4d3	Clean and add more tests. Clean the unnecessary codes and logging macros to keep the test output cleaner. Add fail tests for the `get_state*` functions.	2025-07-11 18:32:28 +03:00
ismail	b239b50abe	Fix invalid channel ID handling. Fix the issue where get_state* functions do not handle when id is RELAY_CHN_ID_ALL. Fixes #1037.	2025-07-11 18:28:59 +03:00
ismail	9b2274ed7c	Add default configs for unit tests.	2025-07-11 17:35:50 +03:00
kozmotronik	5a38956146	Restructure the project tree. Restructured the project tree to align with Espressif's project tree pattern and practice. Also updated the affected cmake files. Fixes: #1033	2025-07-07 22:57:02 +03:00
kozmotronik	82168f34eb	Delete this ghost file appeared out of nowhere.	2025-07-07 20:25:45 +03:00
Ismail Sahillioglu	2165e9d571	Merge pull request 'release-0.4.0' (!28 ) from release-0.4.0 into main Reviewed-on: KozmotronikTech/relay_chn_component#28	2025-07-07 14:45:01 +03:00
Ismail Sahillioglu	c0c7fbf3df	Merge pull request 'Fix error handling issues.' (!26 ) from release-0.3.2 into main Reviewed-on: https://dev.kozmotronik.com.tr/gitea/KozmotronikTech/relay_chn/pulls/26	2025-04-03 10:21:37 +03:00