KozmotronikTech/relay_chn
3
0
Fork 0
Code Issues Pull Requests Actions Packages Releases 10 Wiki Activity

Fix esp_timer_start error handling

Browse Source 
A helper function added for each module so that each module
handles errors by itself.

Fixes #1092
This commit is contained in:
Ismail Sahillioglu
2025-08-27 15:56:24 +03:00
parent 374647732c
commit 71b632737e
2 changed files with 40 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
src/relay_chn_core.c
View File

@@ -263,6 +263,18 @@ void relay_chn_update_state(relay_chn_ctl_t *chn_ctl, relay_chn_state_t new_stat
} }
} }
static void relay_chn_execute_idle(relay_chn_ctl_t *chn_ctl);
static void relay_chn_start_timer_or_idle(relay_chn_ctl_t *chn_ctl, esp_timer_handle_t timer, uint32_t time_ms, const char* timer_name)
{
if (relay_chn_start_esp_timer_once(timer, time_ms) != ESP_OK) {
ESP_LOGE(TAG, "Failed to start %s timer for ch %d", timer_name, chn_ctl->id);
// Attempt to go to a safe state.
// relay_chn_execute_idle is safe to call, it stops timers and sets state.
relay_chn_execute_idle(chn_ctl);
}
}
/** /**
* @brief The command issuer function. * @brief The command issuer function.
* *
@@ -374,7 +386,7 @@ void relay_chn_issue_cmd(relay_chn_ctl_t* chn_ctl, relay_chn_cmd_t cmd)
relay_chn_state_t new_state = cmd == RELAY_CHN_CMD_FORWARD relay_chn_state_t new_state = cmd == RELAY_CHN_CMD_FORWARD
? RELAY_CHN_STATE_FORWARD_PENDING : RELAY_CHN_STATE_REVERSE_PENDING; ? RELAY_CHN_STATE_FORWARD_PENDING : RELAY_CHN_STATE_REVERSE_PENDING;
relay_chn_update_state(chn_ctl, new_state); relay_chn_update_state(chn_ctl, new_state);
relay_chn_start_esp_timer_once(chn_ctl->inertia_timer, CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS); relay_chn_start_timer_or_idle(chn_ctl, chn_ctl->inertia_timer, CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS, "inertia");
break; break;
#if CONFIG_RELAY_CHN_ENABLE_TILTING #if CONFIG_RELAY_CHN_ENABLE_TILTING
@@ -456,12 +468,13 @@ static void relay_chn_execute_stop(relay_chn_ctl_t *chn_ctl)
relay_chn_run_info_set_last_run_cmd_time_ms(chn_ctl->run_info, (uint32_t)(esp_timer_get_time() / 1000)); relay_chn_run_info_set_last_run_cmd_time_ms(chn_ctl->run_info, (uint32_t)(esp_timer_get_time() / 1000));
// Schedule a free command for the channel // Schedule a free command for the channel
chn_ctl->pending_cmd = RELAY_CHN_CMD_IDLE; chn_ctl->pending_cmd = RELAY_CHN_CMD_IDLE;
relay_chn_start_esp_timer_once(chn_ctl->inertia_timer, CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS); relay_chn_start_timer_or_idle(chn_ctl, chn_ctl->inertia_timer, CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS, "idle");
} else { } else {
// If the channel was not running one of the run or fwd, issue a free command immediately // If the channel was not running one of the run or fwd, issue a free command immediately
// relay_chn_dispatch_cmd(chn_ctl, RELAY_CHN_CMD_IDLE); // relay_chn_dispatch_cmd(chn_ctl, RELAY_CHN_CMD_IDLE);
relay_chn_execute_idle(chn_ctl); relay_chn_execute_idle(chn_ctl);
} }
ESP_LOGI(TAG, "execute_stop: #%d, state: %d", chn_ctl->id, chn_ctl->state); // TODO delete
} }
static void relay_chn_execute_forward(relay_chn_ctl_t *chn_ctl) static void relay_chn_execute_forward(relay_chn_ctl_t *chn_ctl)
@@ -474,7 +487,7 @@ static void relay_chn_execute_forward(relay_chn_ctl_t *chn_ctl)
relay_chn_update_state(chn_ctl, RELAY_CHN_STATE_FORWARD); relay_chn_update_state(chn_ctl, RELAY_CHN_STATE_FORWARD);
#if CONFIG_RELAY_CHN_ENABLE_RUN_LIMIT #if CONFIG_RELAY_CHN_ENABLE_RUN_LIMIT
relay_chn_start_esp_timer_once(chn_ctl->run_limit_timer, chn_ctl->run_limit_sec * 1000); relay_chn_start_timer_or_idle(chn_ctl, chn_ctl->run_limit_timer, chn_ctl->run_limit_sec * 1000, "run limit");
#endif #endif
} }
@@ -488,7 +501,7 @@ static void relay_chn_execute_reverse(relay_chn_ctl_t *chn_ctl)
relay_chn_update_state(chn_ctl, RELAY_CHN_STATE_REVERSE); relay_chn_update_state(chn_ctl, RELAY_CHN_STATE_REVERSE);
#if CONFIG_RELAY_CHN_ENABLE_RUN_LIMIT #if CONFIG_RELAY_CHN_ENABLE_RUN_LIMIT
relay_chn_start_esp_timer_once(chn_ctl->run_limit_timer, chn_ctl->run_limit_sec * 1000); relay_chn_start_timer_or_idle(chn_ctl, chn_ctl->run_limit_timer, chn_ctl->run_limit_sec * 1000, "run limit");
#endif #endif
} }
@@ -497,7 +510,7 @@ static void relay_chn_execute_flip(relay_chn_ctl_t *chn_ctl)
relay_chn_output_flip(chn_ctl->output); relay_chn_output_flip(chn_ctl->output);
// Set an inertia on the channel to prevent any immediate movement // Set an inertia on the channel to prevent any immediate movement
chn_ctl->pending_cmd = RELAY_CHN_CMD_IDLE; chn_ctl->pending_cmd = RELAY_CHN_CMD_IDLE;
relay_chn_start_esp_timer_once(chn_ctl->inertia_timer, CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS); relay_chn_start_timer_or_idle(chn_ctl, chn_ctl->inertia_timer, CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS, "flip inertia");
} }
// Dispatch relay channel command // Dispatch relay channel command

29
src/relay_chn_tilt.c
View File

@@ -91,6 +91,18 @@ static uint32_t relay_chn_tilt_get_required_timing_before_tilting(relay_chn_tilt
return CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS - inertia_time_passed_ms; return CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS - inertia_time_passed_ms;
} }
static void relay_chn_tilt_execute_stop(relay_chn_tilt_ctl_t *tilt_ctl);
static void relay_chn_tilt_start_timer_or_stop(relay_chn_tilt_ctl_t *tilt_ctl, esp_timer_handle_t timer, uint32_t time_ms, const char* timer_name)
{
if (relay_chn_start_esp_timer_once(timer, time_ms) != ESP_OK) {
ESP_LOGE(TAG, "Failed to start %s timer for ch %d", timer_name, tilt_ctl->chn_ctl->id);
// Attempt to go to a safe state for tilt.
// relay_chn_tilt_execute_stop is safe to call, it stops timers and sets state.
relay_chn_tilt_execute_stop(tilt_ctl);
}
}
// Issue a tilt command to a specific relay channel. // Issue a tilt command to a specific relay channel.
static void relay_chn_tilt_issue_cmd(relay_chn_tilt_ctl_t *tilt_ctl, relay_chn_tilt_cmd_t cmd) static void relay_chn_tilt_issue_cmd(relay_chn_tilt_ctl_t *tilt_ctl, relay_chn_tilt_cmd_t cmd)
{ {
@@ -136,7 +148,7 @@ static void relay_chn_tilt_issue_cmd(relay_chn_tilt_ctl_t *tilt_ctl, relay_chn_t
} else { } else {
// Channel needs timing before running tilting action, schedule it // Channel needs timing before running tilting action, schedule it
tilt_ctl->step = RELAY_CHN_TILT_STEP_PENDING; tilt_ctl->step = RELAY_CHN_TILT_STEP_PENDING;
relay_chn_start_esp_timer_once(tilt_ctl->tilt_timer, req_timing_ms); relay_chn_tilt_start_timer_or_stop(tilt_ctl, tilt_ctl->tilt_timer, req_timing_ms, "pending tilt");
} }
break; break;
} }
@@ -147,7 +159,7 @@ static void relay_chn_tilt_issue_cmd(relay_chn_tilt_ctl_t *tilt_ctl, relay_chn_t
relay_chn_dispatch_cmd(tilt_ctl->chn_ctl, RELAY_CHN_CMD_STOP); relay_chn_dispatch_cmd(tilt_ctl->chn_ctl, RELAY_CHN_CMD_STOP);
// Schedule for tilting // Schedule for tilting
tilt_ctl->step = RELAY_CHN_TILT_STEP_PENDING; tilt_ctl->step = RELAY_CHN_TILT_STEP_PENDING;
relay_chn_start_esp_timer_once(tilt_ctl->tilt_timer, CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS); relay_chn_tilt_start_timer_or_stop(tilt_ctl, tilt_ctl->tilt_timer, CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS, "tilt inertia");
} else if (cmd == RELAY_CHN_TILT_CMD_REVERSE) { } else if (cmd == RELAY_CHN_TILT_CMD_REVERSE) {
// Stop the running channel first // Stop the running channel first
relay_chn_dispatch_cmd(tilt_ctl->chn_ctl, RELAY_CHN_CMD_STOP); relay_chn_dispatch_cmd(tilt_ctl->chn_ctl, RELAY_CHN_CMD_STOP);
@@ -162,7 +174,7 @@ static void relay_chn_tilt_issue_cmd(relay_chn_tilt_ctl_t *tilt_ctl, relay_chn_t
relay_chn_dispatch_cmd(tilt_ctl->chn_ctl, RELAY_CHN_CMD_STOP); relay_chn_dispatch_cmd(tilt_ctl->chn_ctl, RELAY_CHN_CMD_STOP);
// Schedule for tilting // Schedule for tilting
tilt_ctl->step = RELAY_CHN_TILT_STEP_PENDING; tilt_ctl->step = RELAY_CHN_TILT_STEP_PENDING;
relay_chn_start_esp_timer_once(tilt_ctl->tilt_timer, CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS); relay_chn_tilt_start_timer_or_stop(tilt_ctl, tilt_ctl->tilt_timer, CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS, "tilt inertia");
} else if (cmd == RELAY_CHN_TILT_CMD_FORWARD) { } else if (cmd == RELAY_CHN_TILT_CMD_FORWARD) {
// Stop the running channel first // Stop the running channel first
relay_chn_dispatch_cmd(tilt_ctl->chn_ctl, RELAY_CHN_CMD_STOP); relay_chn_dispatch_cmd(tilt_ctl->chn_ctl, RELAY_CHN_CMD_STOP);
@@ -507,7 +519,10 @@ static void relay_chn_tilt_execute_stop(relay_chn_tilt_ctl_t *tilt_ctl)
#if CONFIG_RELAY_CHN_ENABLE_NVS #if CONFIG_RELAY_CHN_ENABLE_NVS
// Start the flush debounce timer // Start the flush debounce timer
relay_chn_start_esp_timer_once(tilt_ctl->flush_timer, RELAY_CHN_TILT_FLUSH_DEBOUNCE_MS); if (relay_chn_start_esp_timer_once(tilt_ctl->flush_timer, RELAY_CHN_TILT_FLUSH_DEBOUNCE_MS) != ESP_OK) {
ESP_LOGE(TAG, "Failed to start tilt flush timer for ch %d", tilt_ctl->chn_ctl->id);
// This is not a critical failure, just log it. The count will be saved on next stop.
}
#endif #endif
} }
@@ -520,7 +535,7 @@ static void relay_chn_tilt_execute_forward(relay_chn_tilt_ctl_t *tilt_ctl)
return; return;
} }
// Set the move time timer // Set the move time timer
relay_chn_start_esp_timer_once(tilt_ctl->tilt_timer, tilt_ctl->tilt_timing.move_time_ms); relay_chn_tilt_start_timer_or_stop(tilt_ctl, tilt_ctl->tilt_timer, tilt_ctl->tilt_timing.move_time_ms, "tilt move");
// Set to pause step // Set to pause step
tilt_ctl->step = RELAY_CHN_TILT_STEP_PAUSE; tilt_ctl->step = RELAY_CHN_TILT_STEP_PAUSE;
} }
@@ -534,7 +549,7 @@ static void relay_chn_tilt_execute_reverse(relay_chn_tilt_ctl_t *tilt_ctl)
return; return;
} }
// Set the move time timer // Set the move time timer
relay_chn_start_esp_timer_once(tilt_ctl->tilt_timer, tilt_ctl->tilt_timing.move_time_ms); relay_chn_tilt_start_timer_or_stop(tilt_ctl, tilt_ctl->tilt_timer, tilt_ctl->tilt_timing.move_time_ms, "tilt move");
// Set to pause step // Set to pause step
tilt_ctl->step = RELAY_CHN_TILT_STEP_PAUSE; tilt_ctl->step = RELAY_CHN_TILT_STEP_PAUSE;
} }
@@ -558,7 +573,7 @@ static void relay_chn_tilt_execute_pause(relay_chn_tilt_ctl_t *tilt_ctl)
} }
// Set the pause time timer // Set the pause time timer
relay_chn_start_esp_timer_once(tilt_ctl->tilt_timer, tilt_ctl->tilt_timing.pause_time_ms); relay_chn_tilt_start_timer_or_stop(tilt_ctl, tilt_ctl->tilt_timer, tilt_ctl->tilt_timing.pause_time_ms, "tilt pause");
// Set to move step // Set to move step
tilt_ctl->step = RELAY_CHN_TILT_STEP_MOVE; tilt_ctl->step = RELAY_CHN_TILT_STEP_MOVE;
} }