diff --git a/test_apps/main/test_common.c b/test_apps/main/test_common.c
index 21986a4..1dcdfad 100644
--- a/test_apps/main/test_common.c
+++ b/test_apps/main/test_common.c
@@ -2,10 +2,6 @@
 
 const char *TEST_TAG = "RELAY_CHN_TEST";
 
-const uint8_t relay_chn_count = CONFIG_RELAY_CHN_COUNT;
-const uint32_t opposite_inertia_ms = CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS;
-const uint32_t test_delay_margin_ms = 50;  // ms tolerance
-
 // Test-wide GPIO map
 #if CONFIG_RELAY_CHN_COUNT > 1
 const uint8_t gpio_map[] = {
@@ -40,13 +36,13 @@ void reset_channels_to_idle_state()
 {
 #if CONFIG_RELAY_CHN_COUNT > 1
     relay_chn_stop_all();
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state(i));
     }
 #else
     relay_chn_stop();
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state());
 #endif
 }
\ No newline at end of file
diff --git a/test_apps/main/test_common.h b/test_apps/main/test_common.h
index 7a17e80..1b9c94a 100644
--- a/test_apps/main/test_common.h
+++ b/test_apps/main/test_common.h
@@ -13,14 +13,9 @@ extern const char *TEST_TAG;
 // GPIO configurations
 extern const uint8_t gpio_map[];
 extern const uint8_t gpio_count;
-extern const uint8_t relay_chn_count;
 
 // Config variables for tests
-extern const uint32_t opposite_inertia_ms;
-extern const uint32_t test_delay_margin_ms;
-
-// Init state
-extern bool g_is_component_initialized;
+#define TEST_DELAY_MARGIN_MS 50
 
 // Reset channels to Idle state
 void reset_channels_to_idle_state(void);
\ No newline at end of file
diff --git a/test_apps/main/test_relay_chn_core_multi.c b/test_apps/main/test_relay_chn_core_multi.c
index b33ab9a..e24a387 100644
--- a/test_apps/main/test_relay_chn_core_multi.c
+++ b/test_apps/main/test_relay_chn_core_multi.c
@@ -22,28 +22,28 @@ TEST_CASE("relay_chn_create handles invalid arguments", "[relay_chn][core]")
 
 // TEST_CASE: Test that relay channels initialize correctly to RELAY_CHN_STATE_IDLE
 TEST_CASE("Relay channels initialize correctly to FREE state", "[relay_chn][core]") {
-    for (uint8_t i = 0; i < relay_chn_count; i++) {
+    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, 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]") {
-    for (uint8_t i = 0; i < relay_chn_count; i++) {
-        int invalid_id = relay_chn_count * 2 + i;
+    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
+        int invalid_id = CONFIG_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));
+        vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, 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]") {
-    for (uint8_t i = 0; i < relay_chn_count; i++) {
+    for (uint8_t i = 0; i < CONFIG_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));
+        vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(i));
     }
 }
@@ -51,20 +51,20 @@ TEST_CASE("Relay channels run forward and update state", "[relay_chn][core]") {
 // 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]") {
     // 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;
+    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
+        int invalid_id = CONFIG_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));
+        vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, 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]") {
-    for (uint8_t i = 0; i < relay_chn_count; i++) {
+    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
         relay_chn_run_reverse(i); // relay_chn_run_reverse returns void
-        vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+        vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(i));
     }
 }
@@ -74,9 +74,9 @@ TEST_CASE("Relay channels run reverse and update state", "[relay_chn][core]") {
 TEST_CASE("run_forward_all sets all channels to FORWARD", "[relay_chn][core][batch]")
 {
     relay_chn_run_forward_all();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
 
-    for (uint8_t i = 0; i < relay_chn_count; i++) {
+    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(i));
     }
 }
@@ -84,9 +84,9 @@ TEST_CASE("run_forward_all sets all channels to FORWARD", "[relay_chn][core][bat
 TEST_CASE("run_reverse_all sets all channels to REVERSE", "[relay_chn][core][batch]")
 {
     relay_chn_run_reverse_all();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
 
-    for (uint8_t i = 0; i < relay_chn_count; i++) {
+    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(i));
     }
 }
@@ -95,14 +95,14 @@ TEST_CASE("stop_all stops all running channels", "[relay_chn][core][batch]")
 {
     // 1. Start all channels forward to ensure they are in a known running state
     relay_chn_run_forward_all();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
 
     // 2. Stop all channels
     relay_chn_stop_all();
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_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++) {
+    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state(i));
     }
 }
@@ -112,78 +112,78 @@ TEST_CASE("stop_all stops all running channels", "[relay_chn][core][batch]")
 // TEST_CASE: Test that relays stop and transition to RELAY_CHN_STATE_IDLE
 // 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]") {
-    for (uint8_t i = 0; i < relay_chn_count; i++) {
+    for (uint8_t i = 0; i < CONFIG_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));
+        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));
+        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_IDLE
-        vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+        vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state(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]") {
-    for (uint8_t i = 0; i < relay_chn_count; i++) {
-        int invalid_id = relay_chn_count * 2 + i;
+    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
+        int invalid_id = CONFIG_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_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;
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
+    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
+        int invalid_id = CONFIG_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]") {
-    for (uint8_t i = 0; i < relay_chn_count; i++) {
-        int invalid_id = relay_chn_count * 2 + i;
+    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
+        int invalid_id = CONFIG_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_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;
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
+    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
+        int invalid_id = CONFIG_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]") {
-    if (relay_chn_count >= 2) {
+    if (CONFIG_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));
+        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_IDLE, 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));
+        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));
+        vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state(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));
+        vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state(0));
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state(1));
     } else {
@@ -203,17 +203,17 @@ TEST_CASE("Forward to Reverse transition with opposite inertia", "[relay_chn][co
 
     // 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
+    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)); 
+    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)); 
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); 
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(ch)); // Should now be in reverse state
 }
 
@@ -224,16 +224,16 @@ TEST_CASE("Reverse to Forward transition with opposite inertia", "[relay_chn][co
 
     // 1. Start in reverse direction
     relay_chn_run_reverse(ch); // relay_chn_run_reverse returns void
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    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));
+    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));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch));
 }
 
@@ -244,14 +244,14 @@ TEST_CASE("Running in same direction does not incur inertia", "[relay_chn][core]
 
     // 1. Start in forward direction
     relay_chn_run_forward(ch); // relay_chn_run_forward returns void
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    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)); 
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); 
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch));
 }
 
@@ -266,7 +266,7 @@ TEST_CASE("FREE to Running transition without inertia", "[relay_chn][core][inert
     // 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));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch));
 }
 
@@ -281,14 +281,14 @@ TEST_CASE("Single channel direction can be flipped", "[relay_chn][core][directio
 
     // 2. Flip the direction
     relay_chn_flip_direction(ch);
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms)); // Wait for flip inertia
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_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
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_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));
@@ -298,19 +298,19 @@ TEST_CASE("All channels direction can be flipped simultaneously", "[relay_chn][c
 {
     // 1. Flip all channels
     relay_chn_flip_direction_all();
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
 
     // 2. Verify all channels are flipped
-    for (uint8_t i = 0; i < relay_chn_count; i++) {
+    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
         TEST_ASSERT_EQUAL(RELAY_CHN_DIRECTION_FLIPPED, relay_chn_get_direction(i));
     }
 
     // 3. Flip all back
     relay_chn_flip_direction_all();
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_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++) {
+    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
         TEST_ASSERT_EQUAL(RELAY_CHN_DIRECTION_DEFAULT, relay_chn_get_direction(i));
     }
 }
@@ -330,14 +330,14 @@ TEST_CASE("Flipping a running channel stops it and flips direction", "[relay_chn
     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));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state(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]")
 {
-    const uint8_t invalid_ch = relay_chn_count + 5;
+    const uint8_t invalid_ch = CONFIG_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));
@@ -387,7 +387,7 @@ TEST_CASE("Test run limit stops channel after timeout", "[relay_chn][run_limit]"
     }
     
     // Wait for run limit timeout
-    vTaskDelay(pdMS_TO_TICKS(TEST_SHORT_RUN_LIMIT_SEC * 1000 + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_SHORT_RUN_LIMIT_SEC * 1000 + TEST_DELAY_MARGIN_MS));
     for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state(i));
     }
@@ -409,14 +409,14 @@ TEST_CASE("Test run limit reset on direction change and time out finally", "[rel
     relay_chn_run_reverse_all();
     
     // Wait for the inertia period (after which the reverse command will be dispatched)
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
 
     for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(i));
     }
     
     // Timer should time out and stop the channel after the run limit time
-    vTaskDelay(pdMS_TO_TICKS(TEST_SHORT_RUN_LIMIT_SEC * 1000 + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_SHORT_RUN_LIMIT_SEC * 1000 + TEST_DELAY_MARGIN_MS));
     
     for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state(i));
diff --git a/test_apps/main/test_relay_chn_core_single.c b/test_apps/main/test_relay_chn_core_single.c
index 0945d0b..0b82c40 100644
--- a/test_apps/main/test_relay_chn_core_single.c
+++ b/test_apps/main/test_relay_chn_core_single.c
@@ -29,14 +29,14 @@ TEST_CASE("Relay channels initialize correctly to IDLE state", "[relay_chn][core
 TEST_CASE("Relay channels run forward and update state", "[relay_chn][core]") {
     relay_chn_run_forward();
     // Short delay for state to update
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state());
 }
 
 // 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]") {
     relay_chn_run_reverse(); // relay_chn_run_reverse returns void
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state());
 }
 
@@ -46,17 +46,17 @@ TEST_CASE("Relay channels run reverse and update state", "[relay_chn][core]") {
 TEST_CASE("Relay channels stop and update to IDLE state", "[relay_chn][core]") {
     // First, run forward to test stopping and transitioning to IDLE state
     relay_chn_run_forward();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state());
 
     // Now, issue the stop command
     relay_chn_stop(); // relay_chn_stop returns void
     // Immediately after stop, state should be STOPPED
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state());
 
     // Then, wait for the inertia period for it to transition to RELAY_CHN_STATE_IDLE
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state());
 }
 
@@ -70,17 +70,17 @@ TEST_CASE("Relay channels stop and update to IDLE state", "[relay_chn][core]") {
 TEST_CASE("Forward to Reverse transition with opposite inertia", "[relay_chn][core][inertia]") {
     // 1. Start in forward direction
     relay_chn_run_forward();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms)); // Short delay for state stabilization
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); // Short delay for state stabilization
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state());
 
     // 2. Issue reverse command
     relay_chn_run_reverse(); // relay_chn_run_reverse returns void
     // Immediately after the command, the motor should be stopped
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms)); 
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); 
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE_PENDING, relay_chn_get_state()); 
 
     // Wait for the inertia period (after which the reverse command will be dispatched)
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms)); 
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); 
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state()); // Should now be in reverse state
 }
 
@@ -89,16 +89,16 @@ TEST_CASE("Forward to Reverse transition with opposite inertia", "[relay_chn][co
 TEST_CASE("Reverse to Forward transition with opposite inertia", "[relay_chn][core][inertia]") {
     // 1. Start in reverse direction
     relay_chn_run_reverse(); // relay_chn_run_reverse returns void
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state());
 
     // 2. Issue forward command
     relay_chn_run_forward();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD_PENDING, relay_chn_get_state());
 
     // Wait for inertia
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state());
 }
 
@@ -107,14 +107,14 @@ TEST_CASE("Reverse to Forward transition with opposite inertia", "[relay_chn][co
 TEST_CASE("Running in same direction does not incur inertia", "[relay_chn][core][inertia]") {
     // 1. Start in forward direction
     relay_chn_run_forward();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state());
 
     // 2. Issue the same forward command again
     relay_chn_run_forward();
     // 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)); 
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); 
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state());
 }
 
@@ -127,7 +127,7 @@ TEST_CASE("IDLE to Running transition without inertia", "[relay_chn][core][inert
     // Start in forward direction
     relay_chn_run_forward();
     // No inertia is expected when starting from IDLE state.
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state());
 }
 
@@ -140,14 +140,14 @@ TEST_CASE("Single channel direction can be flipped", "[relay_chn][core][directio
 
     // 2. Flip the direction
     relay_chn_flip_direction();
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms)); // Wait for flip inertia
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_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());
 
     // 4. Flip back
     relay_chn_flip_direction();
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms)); // Wait for flip inertia
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_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());
@@ -157,18 +157,18 @@ TEST_CASE("Flipping a running channel stops it and flips direction", "[relay_chn
 {
     // 1. Start channel running and verify state
     relay_chn_run_forward();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state());
 
     // 2. Flip the direction while running
     relay_chn_flip_direction();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms)); // Give time for events to process
+    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());
 
     // 4. Wait for the flip inertia to pass, after which it should be IDLE and FLIPPED
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state());
     TEST_ASSERT_EQUAL(RELAY_CHN_DIRECTION_FLIPPED, relay_chn_get_direction());
 }
@@ -208,7 +208,7 @@ TEST_CASE("Test run limit stops channel after timeout", "[relay_chn][run_limit]"
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state());
     
     // Wait for run limit timeout
-    vTaskDelay(pdMS_TO_TICKS(TEST_SHORT_RUN_LIMIT_SEC * 1000 + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_SHORT_RUN_LIMIT_SEC * 1000 + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state());
 }
 
@@ -225,12 +225,12 @@ TEST_CASE("Test run limit reset on direction change and time out finally", "[rel
     relay_chn_run_reverse();
     
     // Wait for the inertia period (after which the reverse command will be dispatched)
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state());
     
     // Timer should time out and stop the channel after the run limit time
-    vTaskDelay(pdMS_TO_TICKS(TEST_SHORT_RUN_LIMIT_SEC * 1000 + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_SHORT_RUN_LIMIT_SEC * 1000 + TEST_DELAY_MARGIN_MS));
     
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state());
 }
diff --git a/test_apps/main/test_relay_chn_listener_multi.c b/test_apps/main/test_relay_chn_listener_multi.c
index 1f8d979..117a4cd 100644
--- a/test_apps/main/test_relay_chn_listener_multi.c
+++ b/test_apps/main/test_relay_chn_listener_multi.c
@@ -44,7 +44,7 @@ TEST_CASE("Listener is called on state change", "[relay_chn][listener]") {
 
     // 2. Trigger a state change
     relay_chn_run_forward(ch);
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms)); // Allow event to be processed
+    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);
@@ -66,7 +66,7 @@ TEST_CASE("Unregistered listener is not called", "[relay_chn][listener]") {
 
     // 2. Trigger a state change
     relay_chn_run_forward(ch);
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
 
     // 3. Verify the listener was NOT called
     TEST_ASSERT_EQUAL(0, listener1_info.call_count);
@@ -83,7 +83,7 @@ TEST_CASE("Multiple listeners are called on state change", "[relay_chn][listener
 
     // 2. Trigger a state change
     relay_chn_run_forward(ch);
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
 
     // 3. Verify listener 1 was called correctly
     TEST_ASSERT_EQUAL(1, listener1_info.call_count);
@@ -115,7 +115,7 @@ TEST_CASE("Listener registration handles invalid arguments and duplicates", "[re
 
     // 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));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(1, listener1_info.call_count);
 
     // 5. Clean up
diff --git a/test_apps/main/test_relay_chn_listener_single.c b/test_apps/main/test_relay_chn_listener_single.c
index 9d0970d..53e27ad 100644
--- a/test_apps/main/test_relay_chn_listener_single.c
+++ b/test_apps/main/test_relay_chn_listener_single.c
@@ -42,7 +42,7 @@ TEST_CASE("Listener is called on state change", "[relay_chn][listener]") {
 
     // 2. Trigger a state change
     relay_chn_run_forward();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms)); // Allow event to be processed
+    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);
@@ -62,7 +62,7 @@ TEST_CASE("Unregistered listener is not called", "[relay_chn][listener]") {
 
     // 2. Trigger a state change
     relay_chn_run_forward();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
 
     // 3. Verify the listener was NOT called
     TEST_ASSERT_EQUAL(0, listener1_info.call_count);
@@ -78,7 +78,7 @@ TEST_CASE("Multiple listeners are called on state change", "[relay_chn][listener
 
     // 2. Trigger a state change
     relay_chn_run_forward();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
 
     // 3. Verify listener 1 was called correctly
     TEST_ASSERT_EQUAL(1, listener1_info.call_count);
@@ -110,7 +110,7 @@ TEST_CASE("Listener registration handles invalid arguments and duplicates", "[re
 
     // 4. Trigger a state change and verify the listener is only called ONCE
     relay_chn_run_forward();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(1, listener1_info.call_count);
 
     // 5. Clean up
diff --git a/test_apps/main/test_relay_chn_tilt_multi.c b/test_apps/main/test_relay_chn_tilt_multi.c
index bc4aa32..7aa1034 100644
--- a/test_apps/main/test_relay_chn_tilt_multi.c
+++ b/test_apps/main/test_relay_chn_tilt_multi.c
@@ -16,7 +16,7 @@
 void prepare_channel_for_tilt(uint8_t chn_id, int initial_cmd) {
     // Ensure the channel reset tilt control
     relay_chn_tilt_stop(chn_id);
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     
     // Ensure the channel has had a 'last_run_cmd'
     if (initial_cmd == RELAY_CHN_CMD_FORWARD) {
@@ -24,9 +24,9 @@ void prepare_channel_for_tilt(uint8_t chn_id, int initial_cmd) {
     } 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
+    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));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state(chn_id));
 }
 
@@ -40,17 +40,17 @@ TEST_CASE("Run Forward to Tilt Forward transition with inertia", "[relay_chn][ti
 
     // 1. Start in forward direction
     relay_chn_run_forward(ch); 
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    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)); 
+    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));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
 }
 
@@ -64,15 +64,15 @@ TEST_CASE("Run Reverse to Tilt Reverse transition with inertia", "[relay_chn][ti
 
     // 1. Start in reverse direction
     relay_chn_run_reverse(ch); 
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    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));
+    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));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch));
 }
 
@@ -88,7 +88,7 @@ TEST_CASE("FREE to Tilt Forward transition with inertia (prepared)", "[relay_chn
     // 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)); 
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); 
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
 }
 
@@ -103,7 +103,7 @@ TEST_CASE("FREE to Tilt Reverse transition with inertia (prepared)", "[relay_chn
 
     // Issue tilt reverse command
     relay_chn_tilt_reverse(ch); 
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch));
 }
 
@@ -115,14 +115,14 @@ TEST_CASE("Tilt Forward to Run Forward transition with inertia", "[relay_chn][ti
     // 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));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
 
     // 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));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch));
 }
 
@@ -134,13 +134,13 @@ TEST_CASE("Tilt Reverse to Run Reverse transition with inertia", "[relay_chn][ti
     // 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));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch));
 
     // 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));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(ch));
 }
 
@@ -152,12 +152,12 @@ TEST_CASE("Tilt Forward to Run Reverse transition without inertia", "[relay_chn]
     // 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));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
 
     // 2. Issue run reverse command (opposite direction)
     relay_chn_run_reverse(ch); 
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(ch));
 }
 
@@ -169,13 +169,13 @@ TEST_CASE("Tilt to Stop transition without immediate inertia for stop", "[relay_
     // 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));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
 
     // 2. Issue stop command
     relay_chn_tilt_stop(ch);
     // Stop command should apply immediately, setting state to FREE since last state was tilt.
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state(ch));
 }
 
@@ -184,16 +184,16 @@ TEST_CASE("Tilt to Stop transition without immediate inertia for stop", "[relay_
 TEST_CASE("tilt_forward_all sets all channels to TILT_FORWARD", "[relay_chn][tilt][batch]")
 {
     // 1. Prepare all channels.
-    for (uint8_t i = 0; i < relay_chn_count; i++) {
+    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
         prepare_channel_for_tilt(i, RELAY_CHN_CMD_FORWARD);
     }
 
     // 2. Issue tilt forward to all channels
     relay_chn_tilt_forward_all();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms)); // Tilt from FREE doesn't have stop-inertia
+    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++) {
+    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
         ESP_LOGI(TEST_TAG, "Checking channel %d", i);
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(i));
     }
@@ -202,16 +202,16 @@ TEST_CASE("tilt_forward_all sets all channels to TILT_FORWARD", "[relay_chn][til
 TEST_CASE("tilt_reverse_all sets all channels to TILT_REVERSE", "[relay_chn][tilt][batch]")
 {
     // 1. Prepare all channels.
-    for (uint8_t i = 0; i < relay_chn_count; i++) {
+    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
         prepare_channel_for_tilt(i, RELAY_CHN_CMD_REVERSE);
     }
 
     // 2. Issue tilt reverse to all channels
     relay_chn_tilt_reverse_all();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    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++) {
+    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(i));
     }
 }
@@ -219,18 +219,18 @@ TEST_CASE("tilt_reverse_all sets all channels to TILT_REVERSE", "[relay_chn][til
 TEST_CASE("tilt_stop_all stops all tilting channels", "[relay_chn][tilt][batch]")
 {
     // 1. Prepare and start all channels tilting forward
-    for (uint8_t i = 0; i < relay_chn_count; i++) {
+    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
         prepare_channel_for_tilt(i, RELAY_CHN_CMD_REVERSE);
     }
     relay_chn_tilt_forward_all();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
 
     // 2. Stop tilting on all channels
     relay_chn_tilt_stop_all();
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
 
     // 3. Verify all channels are free
-    for (uint8_t i = 0; i < relay_chn_count; i++) {
+    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
         ESP_LOGI(TEST_TAG, "Checking channel %d", i);
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state(i));
     }
@@ -239,7 +239,7 @@ TEST_CASE("tilt_stop_all stops all tilting channels", "[relay_chn][tilt][batch]"
 TEST_CASE("tilt_auto_all tilts channels based on last run direction", "[relay_chn][tilt][batch]")
 {
     // This test requires at least 2 channels to demonstrate different behaviors
-    TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(2, relay_chn_count, "Test requires at least 2 channels");
+    TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(2, CONFIG_RELAY_CHN_COUNT, "Test requires at least 2 channels");
 
     // 1. Prepare channel 0 with last run FORWARD and channel 1 with last run REVERSE
     prepare_channel_for_tilt(0, RELAY_CHN_CMD_FORWARD);
@@ -247,7 +247,7 @@ TEST_CASE("tilt_auto_all tilts channels based on last run direction", "[relay_ch
 
     // 2. Issue auto tilt command to all channels
     relay_chn_tilt_auto_all();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms)); // Tilt from FREE state is dispatched immediately
+    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));
@@ -260,15 +260,15 @@ TEST_CASE("relay_chn_tilt_auto chooses correct direction", "[relay_chn][tilt][au
     // Prepare FORWARD
     prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
     relay_chn_tilt_auto(ch);
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    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));
+    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));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch));
 }
 
@@ -302,26 +302,26 @@ TEST_CASE("tilt counter logic: forward and reverse consumption", "[relay_chn][ti
     // Tilt forward 3 times
     for (int i = 0; i < 3; ++i) {
         relay_chn_tilt_forward(ch);
-        vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+        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));
+        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));
+        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));
+            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));
+    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);
@@ -332,12 +332,12 @@ TEST_CASE("run command during TILT state transitions correctly", "[relay_chn][ti
     uint8_t ch = 0;
     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));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
 
     // Issue run reverse while in TILT_FORWARD
     relay_chn_run_reverse(ch);
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    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);
diff --git a/test_apps/main/test_relay_chn_tilt_single.c b/test_apps/main/test_relay_chn_tilt_single.c
index b302838..c30242f 100644
--- a/test_apps/main/test_relay_chn_tilt_single.c
+++ b/test_apps/main/test_relay_chn_tilt_single.c
@@ -16,7 +16,7 @@
 void prepare_channel_for_tilt(int initial_cmd) {
     // Ensure the channel reset tilt control
     relay_chn_tilt_stop();
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
 
     // Ensure the channel has had a 'last_run_cmd'
     if (initial_cmd == RELAY_CHN_CMD_FORWARD) {
@@ -24,9 +24,9 @@ void prepare_channel_for_tilt(int initial_cmd) {
     } else { // Assuming initial_cmd is RELAY_CHN_CMD_REVERSE
         relay_chn_run_reverse();
     }
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms)); // Allow command to process
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); // Allow command to process
     relay_chn_stop(); // 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));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state());
 }
 
@@ -38,17 +38,17 @@ TEST_CASE("Run Forward to Tilt Forward transition with inertia", "[relay_chn][ti
 
     // 1. Start in forward direction
     relay_chn_run_forward(); 
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state());
 
     // 2. Issue tilt forward command
     relay_chn_tilt_forward(); 
     // After tilt command, it should immediately stop and then trigger inertia.
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms)); 
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); 
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state()); 
 
     // Wait for the inertia period (after which the tilt command will be dispatched)
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state());
 }
 
@@ -60,15 +60,15 @@ TEST_CASE("Run Reverse to Tilt Reverse transition with inertia", "[relay_chn][ti
 
     // 1. Start in reverse direction
     relay_chn_run_reverse(); 
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state());
 
     // 2. Issue tilt reverse command
     relay_chn_tilt_reverse(); 
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state());
 
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state());
 }
 
@@ -82,7 +82,7 @@ TEST_CASE("FREE to Tilt Forward transition with inertia (prepared)", "[relay_chn
     // Issue tilt forward command
     relay_chn_tilt_forward(); 
     // From FREE state, tilt command should still incur the inertia due to the internal timer logic
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms)); 
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); 
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state());
 }
 
@@ -95,7 +95,7 @@ TEST_CASE("FREE to Tilt Reverse transition with inertia (prepared)", "[relay_chn
 
     // Issue tilt reverse command
     relay_chn_tilt_reverse(); 
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state());
 }
 
@@ -105,14 +105,14 @@ TEST_CASE("Tilt Forward to Run Forward transition with inertia", "[relay_chn][ti
     // Prepare channel by running forward first to set last_run_cmd, then tilt
     prepare_channel_for_tilt(RELAY_CHN_CMD_FORWARD);
     relay_chn_tilt_forward(); // Go to tilt state
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state());
 
     // 2. Issue run forward command
     relay_chn_run_forward(); 
     // 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());
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state());
 }
 
@@ -122,13 +122,13 @@ TEST_CASE("Tilt Reverse to Run Reverse transition with inertia", "[relay_chn][ti
     // Prepare channel by running reverse first to set last_run_cmd, then tilt
     prepare_channel_for_tilt(RELAY_CHN_CMD_REVERSE);
     relay_chn_tilt_reverse(); // Go to tilt state
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state());
 
     // 2. Issue run reverse command
     relay_chn_run_reverse(); 
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE_PENDING, relay_chn_get_state());
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state());
 }
 
@@ -138,12 +138,12 @@ TEST_CASE("Tilt Forward to Run Reverse transition without inertia", "[relay_chn]
     // Prepare channel by running forward first to set last_run_cmd, then tilt
     prepare_channel_for_tilt(RELAY_CHN_CMD_FORWARD);
     relay_chn_tilt_forward(); // Go to tilt state
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state());
 
     // 2. Issue run reverse command (opposite direction)
     relay_chn_run_reverse(); 
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state());
 }
 
@@ -153,13 +153,13 @@ TEST_CASE("Tilt to Stop transition without immediate inertia for stop", "[relay_
     // Prepare channel by running forward first to set last_run_cmd, then tilt
     prepare_channel_for_tilt(RELAY_CHN_CMD_FORWARD);
     relay_chn_tilt_forward(); // Go to tilt state
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state());
 
     // 2. Issue stop command
     relay_chn_stop();
     // Stop command should apply immediately, setting state to FREE since last state was tilt.
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state());
 }
 
@@ -168,15 +168,15 @@ TEST_CASE("relay_chn_tilt_auto chooses correct direction", "[relay_chn][tilt][au
     // Prepare FORWARD
     prepare_channel_for_tilt(RELAY_CHN_CMD_FORWARD);
     relay_chn_tilt_auto();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state());
     relay_chn_tilt_stop();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
 
     // Prepare REVERSE
     prepare_channel_for_tilt(RELAY_CHN_CMD_REVERSE);
     relay_chn_tilt_auto();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state());
 }
 
@@ -202,26 +202,26 @@ TEST_CASE("tilt counter logic: forward and reverse consumption", "[relay_chn][ti
     // Tilt forward 3 times
     for (int i = 0; i < 3; ++i) {
         relay_chn_tilt_forward();
-        vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+        vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state());
         relay_chn_tilt_stop();
-        vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+        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();
-        vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+        vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
         if (i < 3) {
             TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state());
             relay_chn_tilt_stop();
-            vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+            vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS));
         }
     }
 
     // Extra reverse tilt should fail (counter exhausted)
     relay_chn_tilt_reverse();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    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();
     TEST_ASSERT(state != RELAY_CHN_STATE_TILT_REVERSE);
@@ -231,12 +231,12 @@ TEST_CASE("tilt counter logic: forward and reverse consumption", "[relay_chn][ti
 TEST_CASE("run command during TILT state transitions correctly", "[relay_chn][tilt][run-during-tilt]") {
     prepare_channel_for_tilt(RELAY_CHN_CMD_FORWARD);
     relay_chn_tilt_forward();
-    vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
+    vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS));
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state());
 
     // Issue run reverse while in TILT_FORWARD
     relay_chn_run_reverse();
-    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    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();
     TEST_ASSERT(state == RELAY_CHN_STATE_REVERSE || state == RELAY_CHN_STATE_REVERSE_PENDING);