From 86cc29a33b30e6989262bcdd2274895f827695b1 Mon Sep 17 00:00:00 2001 From: ismail Date: Thu, 4 Sep 2025 18:20:51 +0300 Subject: [PATCH] Fix static variable names Fixed static variable names according to the ESP-IDF C code formatting guide. Refs #1085 and fixes #1103 --- src/relay_chn_ctl_multi.c | 36 ++++---- src/relay_chn_ctl_single.c | 54 +++++------ src/relay_chn_notify.c | 64 ++++++------- src/relay_chn_nvs.c | 100 ++++++++++----------- src/relay_chn_output.c | 20 ++--- src/relay_chn_run_info.c | 18 ++-- src/relay_chn_tilt.c | 46 +++++----- test_apps/main/test_relay_chn_core_multi.c | 82 ++++++++--------- 8 files changed, 210 insertions(+), 210 deletions(-) diff --git a/src/relay_chn_ctl_multi.c b/src/relay_chn_ctl_multi.c index a581b79..d433fd5 100644 --- a/src/relay_chn_ctl_multi.c +++ b/src/relay_chn_ctl_multi.c @@ -16,7 +16,7 @@ static const char *TAG = "RELAY_CHN_CTL"; -static relay_chn_ctl_t chn_ctls[CONFIG_RELAY_CHN_COUNT]; +static relay_chn_ctl_t s_chn_ctls[CONFIG_RELAY_CHN_COUNT]; esp_err_t relay_chn_ctl_init(relay_chn_output_t *outputs, relay_chn_run_info_t *run_infos) @@ -24,7 +24,7 @@ esp_err_t relay_chn_ctl_init(relay_chn_output_t *outputs, relay_chn_run_info_t * // Initialize all relay channels esp_err_t ret; for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { - relay_chn_ctl_t* chn_ctl = &chn_ctls[i]; + relay_chn_ctl_t* chn_ctl = &s_chn_ctls[i]; relay_chn_output_t* output = &outputs[i]; relay_chn_run_info_t* run_info = &run_infos[i]; @@ -54,7 +54,7 @@ esp_err_t relay_chn_ctl_init(relay_chn_output_t *outputs, relay_chn_run_info_t * void relay_chn_ctl_deinit() { for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { - relay_chn_ctl_t* chn_ctl = &chn_ctls[i]; + relay_chn_ctl_t* chn_ctl = &s_chn_ctls[i]; if (chn_ctl->inertia_timer != NULL) { esp_timer_delete(chn_ctl->inertia_timer); chn_ctl->inertia_timer = NULL; @@ -71,7 +71,7 @@ void relay_chn_ctl_deinit() relay_chn_state_t relay_chn_ctl_get_state(uint8_t chn_id) { return relay_chn_is_channel_id_valid(chn_id) ? - chn_ctls[chn_id].state : RELAY_CHN_STATE_UNDEFINED; + s_chn_ctls[chn_id].state : RELAY_CHN_STATE_UNDEFINED; } esp_err_t relay_chn_ctl_get_state_all(relay_chn_state_t *states) @@ -84,7 +84,7 @@ esp_err_t relay_chn_ctl_get_state_all(relay_chn_state_t *states) ESP_LOGW(TAG, "get_state_all: States have been copied until channel %d since states[%d] is NULL", i, i); break; } - *dest_state = chn_ctls[i].state; + *dest_state = s_chn_ctls[i].state; } return ESP_OK; } @@ -92,7 +92,7 @@ esp_err_t relay_chn_ctl_get_state_all(relay_chn_state_t *states) char *relay_chn_ctl_get_state_str(uint8_t chn_id) { return relay_chn_is_channel_id_valid(chn_id) - ? relay_chn_state_str(chn_ctls[chn_id].state) + ? relay_chn_state_str(s_chn_ctls[chn_id].state) : relay_chn_state_str(RELAY_CHN_STATE_UNDEFINED); } @@ -100,14 +100,14 @@ char *relay_chn_ctl_get_state_str(uint8_t chn_id) static void relay_chn_ctl_issue_cmd_on_all_channels(relay_chn_cmd_t cmd) { for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { - relay_chn_issue_cmd(&chn_ctls[i], cmd); + relay_chn_issue_cmd(&s_chn_ctls[i], cmd); } } void relay_chn_ctl_run_forward(uint8_t chn_id) { if (relay_chn_is_channel_id_valid(chn_id)) - relay_chn_issue_cmd(&chn_ctls[chn_id], RELAY_CHN_CMD_FORWARD); + relay_chn_issue_cmd(&s_chn_ctls[chn_id], RELAY_CHN_CMD_FORWARD); } void relay_chn_ctl_run_forward_all() @@ -118,7 +118,7 @@ void relay_chn_ctl_run_forward_all() void relay_chn_ctl_run_reverse(uint8_t chn_id) { if (relay_chn_is_channel_id_valid(chn_id)) - relay_chn_issue_cmd(&chn_ctls[chn_id], RELAY_CHN_CMD_REVERSE); + relay_chn_issue_cmd(&s_chn_ctls[chn_id], RELAY_CHN_CMD_REVERSE); } void relay_chn_ctl_run_reverse_all() @@ -129,7 +129,7 @@ void relay_chn_ctl_run_reverse_all() void relay_chn_ctl_stop(uint8_t chn_id) { if (relay_chn_is_channel_id_valid(chn_id)) - relay_chn_issue_cmd(&chn_ctls[chn_id], RELAY_CHN_CMD_STOP); + relay_chn_issue_cmd(&s_chn_ctls[chn_id], RELAY_CHN_CMD_STOP); } void relay_chn_ctl_stop_all() @@ -140,7 +140,7 @@ void relay_chn_ctl_stop_all() void relay_chn_ctl_flip_direction(uint8_t chn_id) { if (relay_chn_is_channel_id_valid(chn_id)) - relay_chn_issue_cmd(&chn_ctls[chn_id], RELAY_CHN_CMD_FLIP); + relay_chn_issue_cmd(&s_chn_ctls[chn_id], RELAY_CHN_CMD_FLIP); } void relay_chn_ctl_flip_direction_all() @@ -151,7 +151,7 @@ void relay_chn_ctl_flip_direction_all() relay_chn_direction_t relay_chn_ctl_get_direction(uint8_t chn_id) { return relay_chn_is_channel_id_valid(chn_id) - ? relay_chn_output_get_direction(chn_ctls[chn_id].output) + ? relay_chn_output_get_direction(s_chn_ctls[chn_id].output) : RELAY_CHN_DIRECTION_DEFAULT; } @@ -165,7 +165,7 @@ esp_err_t relay_chn_ctl_get_direction_all(relay_chn_direction_t *directions) ESP_LOGW(TAG, "get_direction_all: Directions have been copied until channel %d since directions[%d] is NULL", i, i); break; } - *dest_direction = relay_chn_output_get_direction(chn_ctls[i].output); + *dest_direction = relay_chn_output_get_direction(s_chn_ctls[i].output); } return ESP_OK; } @@ -173,7 +173,7 @@ esp_err_t relay_chn_ctl_get_direction_all(relay_chn_direction_t *directions) #if CONFIG_RELAY_CHN_ENABLE_RUN_LIMIT uint16_t relay_chn_ctl_get_run_limit(uint8_t chn_id) { - return relay_chn_is_channel_id_valid(chn_id) ? chn_ctls[chn_id].run_limit_sec : 0; + return relay_chn_is_channel_id_valid(chn_id) ? s_chn_ctls[chn_id].run_limit_sec : 0; } esp_err_t relay_chn_ctl_get_run_limit_all(uint16_t *limits_sec) @@ -186,7 +186,7 @@ esp_err_t relay_chn_ctl_get_run_limit_all(uint16_t *limits_sec) ESP_LOGW(TAG, "get_run_limit_all: Run limits have been copied until channel %d since limits_sec[%d] is NULL", i, i); break; } - *dest_limit_sec = chn_ctls[i].run_limit_sec; + *dest_limit_sec = s_chn_ctls[i].run_limit_sec; } return ESP_OK; } @@ -199,7 +199,7 @@ static void relay_chn_ctl_set_run_limit_common(uint8_t chn_id, uint16_t limit_se else if (limit_sec < CONFIG_RELAY_CHN_RUN_LIMIT_MIN_SEC) limit_sec = CONFIG_RELAY_CHN_RUN_LIMIT_MIN_SEC; - chn_ctls[chn_id].run_limit_sec = limit_sec; + s_chn_ctls[chn_id].run_limit_sec = limit_sec; #if CONFIG_RELAY_CHN_ENABLE_NVS relay_chn_nvs_set_run_limit(chn_id, limit_sec); @@ -241,10 +241,10 @@ esp_err_t relay_chn_ctl_set_run_limit_all_with(uint16_t limit_sec) relay_chn_ctl_t *relay_chn_ctl_get(uint8_t chn_id) { - return relay_chn_is_channel_id_valid(chn_id) ? &chn_ctls[chn_id] : NULL; + return relay_chn_is_channel_id_valid(chn_id) ? &s_chn_ctls[chn_id] : NULL; } relay_chn_ctl_t *relay_chn_ctl_get_all(void) { - return chn_ctls; + return s_chn_ctls; } \ No newline at end of file diff --git a/src/relay_chn_ctl_single.c b/src/relay_chn_ctl_single.c index 6840d49..e242030 100644 --- a/src/relay_chn_ctl_single.c +++ b/src/relay_chn_ctl_single.c @@ -16,43 +16,43 @@ static const char *TAG = "RELAY_CHN_CTL"; -static relay_chn_ctl_t chn_ctl; +static relay_chn_ctl_t s_chn_ctl; esp_err_t relay_chn_ctl_init(relay_chn_output_t *output, relay_chn_run_info_t *run_info) { // Initialize the relay channel - chn_ctl.id = 0; // Single channel, so ID is 0 - chn_ctl.state = RELAY_CHN_STATE_IDLE; - chn_ctl.pending_cmd = RELAY_CHN_CMD_NONE; - chn_ctl.output = output; - chn_ctl.run_info = run_info; + s_chn_ctl.id = 0; // Single channel, so ID is 0 + s_chn_ctl.state = RELAY_CHN_STATE_IDLE; + s_chn_ctl.pending_cmd = RELAY_CHN_CMD_NONE; + s_chn_ctl.output = output; + s_chn_ctl.run_info = run_info; #if CONFIG_RELAY_CHN_ENABLE_RUN_LIMIT uint16_t run_limit_sec = CONFIG_RELAY_CHN_RUN_LIMIT_DEFAULT_SEC; esp_err_t ret; #if CONFIG_RELAY_CHN_ENABLE_NVS // Load run limit value from NVS - ret = relay_chn_nvs_get_run_limit(chn_ctl.id, &run_limit_sec, CONFIG_RELAY_CHN_RUN_LIMIT_DEFAULT_SEC); + ret = relay_chn_nvs_get_run_limit(s_chn_ctl.id, &run_limit_sec, CONFIG_RELAY_CHN_RUN_LIMIT_DEFAULT_SEC); ESP_RETURN_ON_ERROR(ret, TAG, "Failed to load run limit from NVS with error: %s", esp_err_to_name(ret)); #endif - chn_ctl.run_limit_sec = run_limit_sec; - ret = relay_chn_init_run_limit_timer(&chn_ctl); + s_chn_ctl.run_limit_sec = run_limit_sec; + ret = relay_chn_init_run_limit_timer(&s_chn_ctl); ESP_RETURN_ON_ERROR(ret, TAG, "Failed to initialize run limit timer"); #endif - return relay_chn_init_timer(&chn_ctl); // Create direction change inertia timer + return relay_chn_init_timer(&s_chn_ctl); // Create direction change inertia timer } void relay_chn_ctl_deinit() { - if (chn_ctl.inertia_timer != NULL) { - esp_timer_delete(chn_ctl.inertia_timer); - chn_ctl.inertia_timer = NULL; + if (s_chn_ctl.inertia_timer != NULL) { + esp_timer_delete(s_chn_ctl.inertia_timer); + s_chn_ctl.inertia_timer = NULL; } #if CONFIG_RELAY_CHN_ENABLE_RUN_LIMIT - if (chn_ctl.run_limit_timer != NULL) { - esp_timer_delete(chn_ctl.run_limit_timer); - chn_ctl.run_limit_timer = NULL; + if (s_chn_ctl.run_limit_timer != NULL) { + esp_timer_delete(s_chn_ctl.run_limit_timer); + s_chn_ctl.run_limit_timer = NULL; } #endif } @@ -60,43 +60,43 @@ void relay_chn_ctl_deinit() /* relay_chn APIs */ relay_chn_state_t relay_chn_ctl_get_state() { - return chn_ctl.state; + return s_chn_ctl.state; } char *relay_chn_ctl_get_state_str() { - return relay_chn_state_str(chn_ctl.state); + return relay_chn_state_str(s_chn_ctl.state); } void relay_chn_ctl_run_forward() { - relay_chn_issue_cmd(&chn_ctl, RELAY_CHN_CMD_FORWARD); + relay_chn_issue_cmd(&s_chn_ctl, RELAY_CHN_CMD_FORWARD); } void relay_chn_ctl_run_reverse() { - relay_chn_issue_cmd(&chn_ctl, RELAY_CHN_CMD_REVERSE); + relay_chn_issue_cmd(&s_chn_ctl, RELAY_CHN_CMD_REVERSE); } void relay_chn_ctl_stop() { - relay_chn_issue_cmd(&chn_ctl, RELAY_CHN_CMD_STOP); + relay_chn_issue_cmd(&s_chn_ctl, RELAY_CHN_CMD_STOP); } void relay_chn_ctl_flip_direction() { - relay_chn_issue_cmd(&chn_ctl, RELAY_CHN_CMD_FLIP); + relay_chn_issue_cmd(&s_chn_ctl, RELAY_CHN_CMD_FLIP); } relay_chn_direction_t relay_chn_ctl_get_direction() { - return relay_chn_output_get_direction(chn_ctl.output); + return relay_chn_output_get_direction(s_chn_ctl.output); } #if CONFIG_RELAY_CHN_ENABLE_RUN_LIMIT uint16_t relay_chn_ctl_get_run_limit() { - return chn_ctl.run_limit_sec; +return s_chn_ctl.run_limit_sec; } void relay_chn_ctl_set_run_limit(uint16_t limit_sec) @@ -107,10 +107,10 @@ void relay_chn_ctl_set_run_limit(uint16_t limit_sec) else if (limit_sec < CONFIG_RELAY_CHN_RUN_LIMIT_MIN_SEC) limit_sec = CONFIG_RELAY_CHN_RUN_LIMIT_MIN_SEC; - chn_ctl.run_limit_sec = limit_sec; + s_chn_ctl.run_limit_sec = limit_sec; #if CONFIG_RELAY_CHN_ENABLE_NVS - relay_chn_nvs_set_run_limit(chn_ctl.id, limit_sec); + relay_chn_nvs_set_run_limit(s_chn_ctl.id, limit_sec); #endif } #endif @@ -118,5 +118,5 @@ void relay_chn_ctl_set_run_limit(uint16_t limit_sec) relay_chn_ctl_t *relay_chn_ctl_get() { - return &chn_ctl; + return &s_chn_ctl; } \ No newline at end of file diff --git a/src/relay_chn_notify.c b/src/relay_chn_notify.c index 50093e5..a4633eb 100644 --- a/src/relay_chn_notify.c +++ b/src/relay_chn_notify.c @@ -48,22 +48,22 @@ typedef struct { } relay_chn_notify_msg_t; // The list that holds references to the registered listeners. -static List_t listeners; +static List_t s_listeners; -static QueueHandle_t notify_msg_queue = NULL; -static TaskHandle_t notify_task_handle = NULL; +static QueueHandle_t s_notify_queue = NULL; +static TaskHandle_t s_notify_task = NULL; static void relay_chn_notify_task(void *arg); esp_err_t relay_chn_notify_init(void) { - if (notify_msg_queue != NULL) { + if (s_notify_queue != NULL) { return ESP_OK; } - notify_msg_queue = xQueueCreate(RELAY_CHN_NOTIFY_QUEUE_LEN, sizeof(relay_chn_notify_msg_t)); - if (!notify_msg_queue) { + s_notify_queue = xQueueCreate(RELAY_CHN_NOTIFY_QUEUE_LEN, sizeof(relay_chn_notify_msg_t)); + if (!s_notify_queue) { ESP_LOGE(TAG, "Failed to create notify queue"); return ESP_ERR_NO_MEM; } @@ -71,34 +71,34 @@ esp_err_t relay_chn_notify_init(void) // Create the notify dispatcher task BaseType_t ret = xTaskCreate(relay_chn_notify_task, "task_rlch_ntfy", RELAY_CHN_NOTIFY_TASK_STACK, NULL, - RELAY_CHN_NOTIFY_TASK_PRIO, ¬ify_task_handle); + RELAY_CHN_NOTIFY_TASK_PRIO, &s_notify_task); if (ret != pdPASS) { ESP_LOGE(TAG, "Failed to create notify task"); return ESP_ERR_NO_MEM; } // Init the state listener list - vListInitialise(&listeners); + vListInitialise(&s_listeners); return ESP_OK; } void relay_chn_notify_deinit(void) { - if (notify_task_handle != NULL) { - vTaskDelete(notify_task_handle); - notify_task_handle = NULL; + if (s_notify_task != NULL) { + vTaskDelete(s_notify_task); + s_notify_task = NULL; } - if (notify_msg_queue != NULL) { - vQueueDelete(notify_msg_queue); - notify_msg_queue = NULL; + if (s_notify_queue != NULL) { + vQueueDelete(s_notify_queue); + s_notify_queue = NULL; } - if (!listLIST_IS_EMPTY(&listeners)) { + if (!listLIST_IS_EMPTY(&s_listeners)) { // Free the listeners - while (listCURRENT_LIST_LENGTH(&listeners) > 0) { - ListItem_t *pxItem = listGET_HEAD_ENTRY(&listeners); + while (listCURRENT_LIST_LENGTH(&s_listeners) > 0) { + ListItem_t *pxItem = listGET_HEAD_ENTRY(&s_listeners); relay_chn_listener_entry_t *entry = listGET_LIST_ITEM_OWNER(pxItem); uxListRemove(pxItem); free(entry); @@ -118,14 +118,14 @@ void relay_chn_notify_deinit(void) */ static relay_chn_listener_entry_t* find_listener_entry(relay_chn_state_listener_t listener) { - if (listLIST_IS_EMPTY(&listeners)) { + if (listLIST_IS_EMPTY(&s_listeners)) { ESP_LOGD(TAG, "No listeners registered"); return NULL; } // Iterate through the linked list of listeners - for (ListItem_t *pxListItem = listGET_HEAD_ENTRY(&listeners); - pxListItem != listGET_END_MARKER(&listeners); + for (ListItem_t *pxListItem = listGET_HEAD_ENTRY(&s_listeners); + pxListItem != listGET_END_MARKER(&s_listeners); pxListItem = listGET_NEXT(pxListItem)) { relay_chn_listener_entry_t *entry = (relay_chn_listener_entry_t *) listGET_LIST_ITEM_OWNER(pxListItem); @@ -154,7 +154,7 @@ static void do_add_listener(relay_chn_state_listener_t listener) entry->listener = listener; vListInitialiseItem(&(entry->list_item)); listSET_LIST_ITEM_OWNER(&(entry->list_item), (void *)entry); - vListInsertEnd(&listeners, &(entry->list_item)); + vListInsertEnd(&s_listeners, &(entry->list_item)); ESP_LOGD(TAG, "Registered listener %p", listener); } @@ -170,19 +170,19 @@ static void do_remove_listener(relay_chn_state_listener_t listener) ESP_LOGD(TAG, "Listener %p not found for unregistration.", listener); } - if (listLIST_IS_EMPTY(&listeners)) { + if (listLIST_IS_EMPTY(&s_listeners)) { // Flush all pending notifications in the queue - xQueueReset(notify_msg_queue); + xQueueReset(s_notify_queue); } } esp_err_t relay_chn_notify_add_listener(relay_chn_state_listener_t listener) { ESP_RETURN_ON_FALSE(listener, ESP_ERR_INVALID_ARG, TAG, "Listener cannot be NULL"); - ESP_RETURN_ON_FALSE(notify_msg_queue, ESP_ERR_INVALID_STATE, TAG, "Notify module not initialized"); + ESP_RETURN_ON_FALSE(s_notify_queue, ESP_ERR_INVALID_STATE, TAG, "Notify module not initialized"); relay_chn_notify_msg_t msg = { .cmd = RELAY_CHN_NOTIFY_CMD_ADD_LISTENER, .payload.listener = listener }; - if (xQueueSend(notify_msg_queue, &msg, 0) != pdTRUE) { + if (xQueueSend(s_notify_queue, &msg, 0) != pdTRUE) { ESP_LOGE(TAG, "Notify queue is full, failed to queue add_listener"); return ESP_FAIL; } @@ -195,20 +195,20 @@ void relay_chn_notify_remove_listener(relay_chn_state_listener_t listener) ESP_LOGD(TAG, "Cannot unregister a NULL listener."); return; } - if (!notify_msg_queue) { + if (!s_notify_queue) { ESP_LOGE(TAG, "Notify module not initialized, cannot remove listener"); return; } relay_chn_notify_msg_t msg = { .cmd = RELAY_CHN_NOTIFY_CMD_REMOVE_LISTENER, .payload.listener = listener }; - if (xQueueSendToFront(notify_msg_queue, &msg, 0) != pdTRUE) { + if (xQueueSendToFront(s_notify_queue, &msg, 0) != pdTRUE) { ESP_LOGW(TAG, "Notify queue is full, failed to queue remove_listener"); } } esp_err_t relay_chn_notify_state_change(uint8_t chn_id, relay_chn_state_t old_state, relay_chn_state_t new_state) { - if (!notify_msg_queue) { + if (!s_notify_queue) { return ESP_ERR_INVALID_STATE; } @@ -220,7 +220,7 @@ esp_err_t relay_chn_notify_state_change(uint8_t chn_id, relay_chn_state_t old_st }; // Try to send, do not wait if the queue is full - if (xQueueSend(notify_msg_queue, &msg, 0) != pdTRUE) { + if (xQueueSend(s_notify_queue, &msg, 0) != pdTRUE) { ESP_LOGW(TAG, "Notify queue is full, dropping event: %d -> %d for #%d", old_state, new_state, chn_id); return ESP_FAIL; } @@ -231,8 +231,8 @@ static void do_notify(relay_chn_notify_event_data_t *event_data) { // Iterate through the linked list of listeners and notify them. // No mutex is needed as this is the only task accessing the list. - for (ListItem_t *pxListItem = listGET_HEAD_ENTRY(&listeners); - pxListItem != listGET_END_MARKER(&listeners); + for (ListItem_t *pxListItem = listGET_HEAD_ENTRY(&s_listeners); + pxListItem != listGET_END_MARKER(&s_listeners); pxListItem = listGET_NEXT(pxListItem)) { relay_chn_listener_entry_t *entry = (relay_chn_listener_entry_t *) listGET_LIST_ITEM_OWNER(pxListItem); if (entry && entry->listener) { @@ -247,7 +247,7 @@ static void relay_chn_notify_task(void *arg) { relay_chn_notify_msg_t msg; for (;;) { - if (xQueueReceive(notify_msg_queue, &msg, portMAX_DELAY) == pdTRUE) { + if (xQueueReceive(s_notify_queue, &msg, portMAX_DELAY) == pdTRUE) { switch (msg.cmd) { case RELAY_CHN_NOTIFY_CMD_BROADCAST: { do_notify(&msg.payload.event_data); diff --git a/src/relay_chn_nvs.c b/src/relay_chn_nvs.c index f1d0a9d..c120041 100644 --- a/src/relay_chn_nvs.c +++ b/src/relay_chn_nvs.c @@ -61,10 +61,10 @@ typedef struct { static const char *TAG = "RELAY_CHN_NVS"; -static nvs_handle_t relay_chn_nvs; -static QueueHandle_t nvs_queue_handle = NULL; -static TaskHandle_t nvs_task_handle = NULL; -static SemaphoreHandle_t deinit_sem = NULL; +static nvs_handle_t s_relay_chn_nvs; +static QueueHandle_t s_nvs_ops_queue = NULL; +static TaskHandle_t s_nvs_ops_task = NULL; +static SemaphoreHandle_t s_nvs_deinit_sem = NULL; static void relay_chn_nvs_task(void *arg); @@ -72,25 +72,25 @@ static void relay_chn_nvs_task(void *arg); esp_err_t relay_chn_nvs_init() { // Already initialized? - if (nvs_queue_handle != NULL) { + if (s_nvs_ops_queue != NULL) { return ESP_OK; } - deinit_sem = xSemaphoreCreateBinary(); - if (!deinit_sem) { + s_nvs_deinit_sem = xSemaphoreCreateBinary(); + if (!s_nvs_deinit_sem) { ESP_LOGE(TAG, "Failed to create deinit semaphore"); return ESP_ERR_NO_MEM; } - nvs_queue_handle = xQueueCreate(RELAY_CHN_NVS_QUEUE_LEN, sizeof(relay_chn_nvs_msg_t)); - if (!nvs_queue_handle) { + s_nvs_ops_queue = xQueueCreate(RELAY_CHN_NVS_QUEUE_LEN, sizeof(relay_chn_nvs_msg_t)); + if (!s_nvs_ops_queue) { ESP_LOGE(TAG, "Failed to create NVS queue"); return ESP_ERR_NO_MEM; } BaseType_t res = xTaskCreate(relay_chn_nvs_task, "task_rlch_nvs", RELAY_CHN_NVS_TASK_STACK, NULL, - RELAY_CHN_NVS_TASK_PRIO, &nvs_task_handle); + RELAY_CHN_NVS_TASK_PRIO, &s_nvs_ops_task); if (res != pdPASS) { ESP_LOGE(TAG, "Failed to create NVS task"); return ESP_ERR_NO_MEM; @@ -101,7 +101,7 @@ esp_err_t relay_chn_nvs_init() ret = nvs_open_from_partition(CONFIG_RELAY_CHN_NVS_CUSTOM_PARTITION_NAME, CONFIG_RELAY_CHN_NVS_NAMESPACE, NVS_READWRITE, - &relay_chn_nvs); + &s_relay_chn_nvs); ESP_RETURN_ON_ERROR(ret, TAG, @@ -110,7 +110,7 @@ esp_err_t relay_chn_nvs_init() CONFIG_RELAY_CHN_NVS_CUSTOM_PARTITION_NAME, esp_err_to_name(ret)); #else - ret = nvs_open(CONFIG_RELAY_CHN_NVS_NAMESPACE, NVS_READWRITE, &relay_chn_nvs); + ret = nvs_open(CONFIG_RELAY_CHN_NVS_NAMESPACE, NVS_READWRITE, &s_relay_chn_nvs); ESP_RETURN_ON_ERROR(ret, TAG, "Failed to open NVS namespace '%s'", CONFIG_RELAY_CHN_NVS_NAMESPACE); #endif // CONFIG_RELAY_CHN_NVS_CUSTOM_PARTITION return ESP_OK; @@ -118,19 +118,19 @@ esp_err_t relay_chn_nvs_init() static esp_err_t relay_chn_nvs_enqueue(relay_chn_nvs_msg_t *msg, const char *op_name) { - if (!nvs_queue_handle) { + if (!s_nvs_ops_queue) { return ESP_ERR_INVALID_STATE; } if (msg->op == RELAY_CHN_NVS_OP_DEINIT || msg->op == RELAY_CHN_NVS_OP_ERASE_ALL) { // Send DEINIT or ERASE_ALL to the front and wait up to 1 sec if needed - if (xQueueSendToFront(nvs_queue_handle, msg, pdMS_TO_TICKS(1000)) != pdTRUE) { + if (xQueueSendToFront(s_nvs_ops_queue, msg, pdMS_TO_TICKS(1000)) != pdTRUE) { ESP_LOGW(TAG, "NVS queue is full, dropping %s for #%d", op_name, msg->ch); return ESP_FAIL; } } else { // Send async - if (xQueueSend(nvs_queue_handle, msg, 0) != pdTRUE) { + if (xQueueSend(s_nvs_ops_queue, msg, 0) != pdTRUE) { ESP_LOGW(TAG, "NVS queue is full, dropping %s for #%d", op_name, msg->ch); return ESP_FAIL; } @@ -151,13 +151,13 @@ esp_err_t relay_chn_nvs_set_direction(uint8_t ch, relay_chn_direction_t directio static esp_err_t relay_chn_nvs_task_set_direction(uint8_t ch, uint8_t direction) { uint8_t direction_val = 0; - esp_err_t ret = nvs_get_u8(relay_chn_nvs, RELAY_CHN_KEY_DIR, &direction_val); + esp_err_t ret = nvs_get_u8(s_relay_chn_nvs, RELAY_CHN_KEY_DIR, &direction_val); if (ret != ESP_OK && ret != ESP_ERR_NVS_NOT_FOUND) { ESP_RETURN_ON_ERROR(ret, TAG, "Failed to get direction from NVS with error: %s", esp_err_to_name(ret)); } direction_val &= ~(1 << ch); // Clear the bit for the channel direction_val |= (((uint8_t) direction) << ch); // Set the new direction bit - ret = nvs_set_u8(relay_chn_nvs, RELAY_CHN_KEY_DIR, direction_val); + ret = nvs_set_u8(s_relay_chn_nvs, RELAY_CHN_KEY_DIR, direction_val); ESP_RETURN_ON_ERROR(ret, TAG, "Failed to set direction for channel %d", ch); return ESP_OK; } @@ -167,7 +167,7 @@ esp_err_t relay_chn_nvs_get_direction(uint8_t ch, relay_chn_direction_t *directi ESP_RETURN_ON_FALSE(direction != NULL, ESP_ERR_INVALID_ARG, TAG, "Direction pointer is NULL"); uint8_t direction_val; - esp_err_t ret = nvs_get_u8(relay_chn_nvs, RELAY_CHN_KEY_DIR, &direction_val); + esp_err_t ret = nvs_get_u8(s_relay_chn_nvs, RELAY_CHN_KEY_DIR, &direction_val); if (ret == ESP_ERR_NVS_NOT_FOUND) { *direction = default_val; return ESP_OK; @@ -196,9 +196,9 @@ static esp_err_t relay_chn_nvs_task_set_run_limit(uint8_t ch, uint16_t limit_sec #if CONFIG_RELAY_CHN_COUNT > 1 char key[NVS_KEY_NAME_MAX_SIZE]; snprintf(key, sizeof(key), RELAY_CHN_KEY_RLIM_FMT, ch); - ret = nvs_set_u16(relay_chn_nvs, key, limit_sec); + ret = nvs_set_u16(s_relay_chn_nvs, key, limit_sec); #else - ret = nvs_set_u16(relay_chn_nvs, RELAY_CHN_KEY_RLIM, limit_sec); + ret = nvs_set_u16(s_relay_chn_nvs, RELAY_CHN_KEY_RLIM, limit_sec); #endif ESP_RETURN_ON_ERROR(ret, TAG, "Failed to set run limit for channel %d", ch); return ESP_OK; @@ -212,9 +212,9 @@ esp_err_t relay_chn_nvs_get_run_limit(uint8_t ch, uint16_t *limit_sec, uint16_t #if CONFIG_RELAY_CHN_COUNT > 1 char key[NVS_KEY_NAME_MAX_SIZE]; snprintf(key, sizeof(key), RELAY_CHN_KEY_RLIM_FMT, ch); - ret = nvs_get_u16(relay_chn_nvs, key, limit_sec); + ret = nvs_get_u16(s_relay_chn_nvs, key, limit_sec); #else - ret = nvs_get_u16(relay_chn_nvs, RELAY_CHN_KEY_RLIM, limit_sec); + ret = nvs_get_u16(s_relay_chn_nvs, RELAY_CHN_KEY_RLIM, limit_sec); #endif if (ret == ESP_ERR_NVS_NOT_FOUND) { *limit_sec = default_val; @@ -241,9 +241,9 @@ static esp_err_t relay_chn_nvs_task_set_tilt_sensitivity(uint8_t ch, uint8_t sen #if CONFIG_RELAY_CHN_COUNT > 1 char key[NVS_KEY_NAME_MAX_SIZE]; snprintf(key, sizeof(key), RELAY_CHN_KEY_TSENS_FMT, ch); - ret = nvs_set_u8(relay_chn_nvs, key, sensitivity); + ret = nvs_set_u8(s_relay_chn_nvs, key, sensitivity); #else - ret = nvs_set_u8(relay_chn_nvs, RELAY_CHN_KEY_TSENS, sensitivity); + ret = nvs_set_u8(s_relay_chn_nvs, RELAY_CHN_KEY_TSENS, sensitivity); #endif ESP_RETURN_ON_ERROR(ret, TAG, "Failed to set tilt sensitivity for channel %d", ch); return ESP_OK; @@ -257,9 +257,9 @@ esp_err_t relay_chn_nvs_get_tilt_sensitivity(uint8_t ch, uint8_t *sensitivity, u #if CONFIG_RELAY_CHN_COUNT > 1 char key[NVS_KEY_NAME_MAX_SIZE]; snprintf(key, sizeof(key), RELAY_CHN_KEY_TSENS_FMT, ch); - ret = nvs_get_u8(relay_chn_nvs, key, sensitivity); + ret = nvs_get_u8(s_relay_chn_nvs, key, sensitivity); #else - ret = nvs_get_u8(relay_chn_nvs, RELAY_CHN_KEY_TSENS, sensitivity); + ret = nvs_get_u8(s_relay_chn_nvs, RELAY_CHN_KEY_TSENS, sensitivity); #endif if (ret == ESP_ERR_NVS_NOT_FOUND) { *sensitivity = default_val; @@ -284,9 +284,9 @@ static esp_err_t relay_chn_nvs_task_set_tilt_count(uint8_t ch, uint16_t tilt_cou #if CONFIG_RELAY_CHN_COUNT > 1 char key[NVS_KEY_NAME_MAX_SIZE]; snprintf(key, sizeof(key), RELAY_CHN_KEY_TCNT_FMT, ch); - ret = nvs_set_u16(relay_chn_nvs, key, tilt_count); + ret = nvs_set_u16(s_relay_chn_nvs, key, tilt_count); #else - ret = nvs_set_u16(relay_chn_nvs, RELAY_CHN_KEY_TCNT, tilt_count); + ret = nvs_set_u16(s_relay_chn_nvs, RELAY_CHN_KEY_TCNT, tilt_count); #endif ESP_RETURN_ON_ERROR(ret, TAG, "Failed to save tilt_count tilt counter"); return ESP_OK; @@ -300,9 +300,9 @@ esp_err_t relay_chn_nvs_get_tilt_count(uint8_t ch, uint16_t *tilt_count, uint16_ #if CONFIG_RELAY_CHN_COUNT > 1 char key[NVS_KEY_NAME_MAX_SIZE]; snprintf(key, sizeof(key), RELAY_CHN_KEY_TCNT_FMT, ch); - ret = nvs_get_u16(relay_chn_nvs, key, tilt_count); + ret = nvs_get_u16(s_relay_chn_nvs, key, tilt_count); #else - ret = nvs_get_u16(relay_chn_nvs, RELAY_CHN_KEY_TCNT, tilt_count); + ret = nvs_get_u16(s_relay_chn_nvs, RELAY_CHN_KEY_TCNT, tilt_count); #endif if (ret == ESP_ERR_NVS_NOT_FOUND) { *tilt_count = default_val; @@ -331,38 +331,38 @@ static esp_err_t do_nvs_deinit() static esp_err_t do_nvs_erase_all() { // Flush all pending SET operations since ERASE_ALL requested - xQueueReset(nvs_queue_handle); + xQueueReset(s_nvs_ops_queue); // Erase all key-value pairs in the relay_chn NVS namespace - esp_err_t ret = nvs_erase_all(relay_chn_nvs); + esp_err_t ret = nvs_erase_all(s_relay_chn_nvs); ESP_RETURN_ON_ERROR(ret, TAG, "Failed to erase all keys in NVS namespace '%s'", CONFIG_RELAY_CHN_NVS_NAMESPACE); return ESP_OK; } void relay_chn_nvs_deinit() { - if (nvs_task_handle) { + if (s_nvs_ops_task) { if (do_nvs_deinit() == ESP_OK) { - if (deinit_sem && xSemaphoreTake(deinit_sem, pdMS_TO_TICKS(2000)) != pdTRUE) { + if (s_nvs_deinit_sem && xSemaphoreTake(s_nvs_deinit_sem, pdMS_TO_TICKS(2000)) != pdTRUE) { ESP_LOGE(TAG, "Failed to get deinit confirmation from NVS task. Forcing deletion."); - vTaskDelete(nvs_task_handle); // Last resort + vTaskDelete(s_nvs_ops_task); // Last resort } } else { ESP_LOGE(TAG, "Failed to send deinit message to NVS task. Forcing deletion."); - vTaskDelete(nvs_task_handle); + vTaskDelete(s_nvs_ops_task); } } - if (nvs_queue_handle) { - vQueueDelete(nvs_queue_handle); - nvs_queue_handle = NULL; + if (s_nvs_ops_queue) { + vQueueDelete(s_nvs_ops_queue); + s_nvs_ops_queue = NULL; } - if (deinit_sem) { - vSemaphoreDelete(deinit_sem); - deinit_sem = NULL; + if (s_nvs_deinit_sem) { + vSemaphoreDelete(s_nvs_deinit_sem); + s_nvs_deinit_sem = NULL; } // Close NVS handle here, after task has stopped and queue is deleted. - nvs_close(relay_chn_nvs); - nvs_task_handle = NULL; + nvs_close(s_relay_chn_nvs); + s_nvs_ops_task = NULL; } static esp_err_t relay_chn_nvs_task_process_message(const relay_chn_nvs_msg_t *msg, bool *running, bool *dirty) @@ -417,7 +417,7 @@ static void relay_chn_nvs_task(void *arg) while (running) { // Block indefinitely waiting for the first message of a potential batch. - if (xQueueReceive(nvs_queue_handle, &msg, portMAX_DELAY) == pdTRUE) { + if (xQueueReceive(s_nvs_ops_queue, &msg, portMAX_DELAY) == pdTRUE) { // A batch of operations has started. Use a do-while to process the first message // and any subsequent messages that arrive within the timeout. do { @@ -425,11 +425,11 @@ static void relay_chn_nvs_task(void *arg) if (ret != ESP_OK) { ESP_LOGE(TAG, "Failed to process operation %d for #%d with error %s", msg.op, msg.ch, esp_err_to_name(ret)); } - } while (running && xQueueReceive(nvs_queue_handle, &msg, pdMS_TO_TICKS(RELAY_CHN_NVS_COMMIT_TIMEOUT_MS)) == pdTRUE); + } while (running && xQueueReceive(s_nvs_ops_queue, &msg, pdMS_TO_TICKS(RELAY_CHN_NVS_COMMIT_TIMEOUT_MS)) == pdTRUE); // The burst of messages is over (timeout occurred). Commit if anything changed. if (dirty) { - esp_err_t commit_ret = nvs_commit(relay_chn_nvs); + esp_err_t commit_ret = nvs_commit(s_relay_chn_nvs); if (commit_ret == ESP_OK) { dirty = false; } else { @@ -442,11 +442,11 @@ static void relay_chn_nvs_task(void *arg) // Before exiting, do one final commit if there are pending changes. if (dirty) { - if (nvs_commit(relay_chn_nvs) != ESP_OK) { + if (nvs_commit(s_relay_chn_nvs) != ESP_OK) { ESP_LOGE(TAG, "Final NVS commit failed on deinit"); } } - xSemaphoreGive(deinit_sem); - nvs_task_handle = NULL; + xSemaphoreGive(s_nvs_deinit_sem); + s_nvs_ops_task = NULL; vTaskDelete(NULL); } \ No newline at end of file diff --git a/src/relay_chn_output.c b/src/relay_chn_output.c index 2b1ce9d..100b9f8 100644 --- a/src/relay_chn_output.c +++ b/src/relay_chn_output.c @@ -17,9 +17,9 @@ static const char *TAG = "RELAY_CHN_OUTPUT"; #if CONFIG_RELAY_CHN_COUNT > 1 -static relay_chn_output_t outputs[CONFIG_RELAY_CHN_COUNT]; +static relay_chn_output_t s_outputs[CONFIG_RELAY_CHN_COUNT]; #else -static relay_chn_output_t output; +static relay_chn_output_t s_output; #endif @@ -90,7 +90,7 @@ esp_err_t relay_chn_output_init(const uint8_t* gpio_map, uint8_t gpio_count) #if CONFIG_RELAY_CHN_COUNT > 1 for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { - relay_chn_output_t* output = &outputs[i]; + relay_chn_output_t* output = &s_outputs[i]; int gpio_index = i << 1; // gpio_index = i * 2 gpio_num_t forward_pin = (gpio_num_t) gpio_map[gpio_index]; gpio_num_t reverse_pin = (gpio_num_t) gpio_map[gpio_index + 1]; @@ -111,7 +111,7 @@ esp_err_t relay_chn_output_init(const uint8_t* gpio_map, uint8_t gpio_count) ret = relay_chn_output_load_direction(0, &direction); ESP_RETURN_ON_ERROR(ret, TAG, "Failed to load direction from storage for channel %d", 0); #endif - ret = relay_chn_output_ctl_init(&output, gpio_map[0], gpio_map[1], direction); + ret = relay_chn_output_ctl_init(&s_output, gpio_map[0], gpio_map[1], direction); ESP_RETURN_ON_ERROR(ret, TAG, "Failed to initialize relay channel"); #endif return ESP_OK; @@ -127,10 +127,10 @@ void relay_chn_output_deinit() { #if CONFIG_RELAY_CHN_COUNT > 1 for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { - relay_chn_output_ctl_deinit(&outputs[i]); + relay_chn_output_ctl_deinit(&s_outputs[i]); } #else - relay_chn_output_ctl_deinit(&output); + relay_chn_output_ctl_deinit(&s_output); #endif // CONFIG_RELAY_CHN_COUNT > 1 } @@ -140,17 +140,17 @@ relay_chn_output_t *relay_chn_output_get(uint8_t chn_id) if (!relay_chn_is_channel_id_valid(chn_id)) { return NULL; } - return &outputs[chn_id]; + return &s_outputs[chn_id]; } relay_chn_output_t *relay_chn_output_get_all(void) { - return outputs; + return s_outputs; } #else relay_chn_output_t *relay_chn_output_get(void) { - return &output; + return &s_output; } #endif // CONFIG_RELAY_CHN_COUNT > 1 @@ -193,7 +193,7 @@ void relay_chn_output_flip(relay_chn_output_t *output) uint8_t ch = 0; #if CONFIG_RELAY_CHN_COUNT > 1 for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { - if (output == &outputs[i]) { + if (output == &s_outputs[i]) { ch = i; break; } diff --git a/src/relay_chn_run_info.c b/src/relay_chn_run_info.c index 9a21f47..172cc36 100644 --- a/src/relay_chn_run_info.c +++ b/src/relay_chn_run_info.c @@ -9,21 +9,21 @@ #if CONFIG_RELAY_CHN_COUNT > 1 -static relay_chn_run_info_t run_infos[CONFIG_RELAY_CHN_COUNT]; +static relay_chn_run_info_t s_run_infos[CONFIG_RELAY_CHN_COUNT]; #else -static relay_chn_run_info_t run_info; +static relay_chn_run_info_t s_run_info; #endif void relay_chn_run_info_init() { #if CONFIG_RELAY_CHN_COUNT > 1 for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { - run_infos[i].last_run_cmd = RELAY_CHN_CMD_NONE; - run_infos[i].last_run_cmd_time_ms = 0; + s_run_infos[i].last_run_cmd = RELAY_CHN_CMD_NONE; + s_run_infos[i].last_run_cmd_time_ms = 0; } #else - run_info.last_run_cmd = RELAY_CHN_CMD_NONE; - run_info.last_run_cmd_time_ms = 0; + s_run_info.last_run_cmd = RELAY_CHN_CMD_NONE; + s_run_info.last_run_cmd_time_ms = 0; #endif } @@ -33,17 +33,17 @@ relay_chn_run_info_t *relay_chn_run_info_get(uint8_t chn_id) if (!relay_chn_is_channel_id_valid(chn_id)) { return NULL; } - return &run_infos[chn_id]; + return &s_run_infos[chn_id]; } relay_chn_run_info_t *relay_chn_run_info_get_all() { - return run_infos; + return s_run_infos; } #else relay_chn_run_info_t *relay_chn_run_info_get() { - return &run_info; + return &s_run_info; } #endif // CONFIG_RELAY_CHN_COUNT > 1 diff --git a/src/relay_chn_tilt.c b/src/relay_chn_tilt.c index b0529d3..c9552ad 100644 --- a/src/relay_chn_tilt.c +++ b/src/relay_chn_tilt.c @@ -71,9 +71,9 @@ typedef struct relay_chn_tilt_ctl { #if CONFIG_RELAY_CHN_COUNT > 1 -static relay_chn_tilt_ctl_t tilt_ctls[CONFIG_RELAY_CHN_COUNT]; +static relay_chn_tilt_ctl_t s_tilt_ctls[CONFIG_RELAY_CHN_COUNT]; #else -static relay_chn_tilt_ctl_t tilt_ctl; +static relay_chn_tilt_ctl_t s_tilt_ctl; #endif @@ -209,7 +209,7 @@ uint8_t relay_chn_tilt_get_default_sensitivity() static void relay_chn_tilt_issue_cmd_on_all_channels(relay_chn_tilt_cmd_t cmd) { for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { - relay_chn_tilt_ctl_t* tilt_ctl = &tilt_ctls[i]; + relay_chn_tilt_ctl_t* tilt_ctl = &s_tilt_ctls[i]; relay_chn_tilt_issue_cmd(tilt_ctl, cmd); } } @@ -217,21 +217,21 @@ static void relay_chn_tilt_issue_cmd_on_all_channels(relay_chn_tilt_cmd_t cmd) void relay_chn_tilt_auto(uint8_t chn_id) { if (relay_chn_is_channel_id_valid(chn_id)) { - relay_chn_tilt_issue_auto(&tilt_ctls[chn_id]); + relay_chn_tilt_issue_auto(&s_tilt_ctls[chn_id]); } } void relay_chn_tilt_auto_all() { for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { - relay_chn_tilt_issue_auto(&tilt_ctls[i]); + relay_chn_tilt_issue_auto(&s_tilt_ctls[i]); } } void relay_chn_tilt_forward(uint8_t chn_id) { if (relay_chn_is_channel_id_valid(chn_id)) { - relay_chn_tilt_issue_cmd(&tilt_ctls[chn_id], RELAY_CHN_TILT_CMD_FORWARD); + relay_chn_tilt_issue_cmd(&s_tilt_ctls[chn_id], RELAY_CHN_TILT_CMD_FORWARD); } } @@ -243,7 +243,7 @@ void relay_chn_tilt_forward_all() void relay_chn_tilt_reverse(uint8_t chn_id) { if (relay_chn_is_channel_id_valid(chn_id)) { - relay_chn_tilt_issue_cmd(&tilt_ctls[chn_id], RELAY_CHN_TILT_CMD_REVERSE); + relay_chn_tilt_issue_cmd(&s_tilt_ctls[chn_id], RELAY_CHN_TILT_CMD_REVERSE); } } @@ -255,7 +255,7 @@ void relay_chn_tilt_reverse_all() void relay_chn_tilt_stop(uint8_t chn_id) { if (!relay_chn_is_channel_id_valid(chn_id)) { - relay_chn_tilt_dispatch_cmd(&tilt_ctls[chn_id], RELAY_CHN_TILT_CMD_STOP); + relay_chn_tilt_dispatch_cmd(&s_tilt_ctls[chn_id], RELAY_CHN_TILT_CMD_STOP); } } @@ -268,22 +268,22 @@ void relay_chn_tilt_stop_all() void relay_chn_tilt_auto() { - relay_chn_tilt_issue_auto(&tilt_ctl); + relay_chn_tilt_issue_auto(&s_tilt_ctl); } void relay_chn_tilt_forward() { - relay_chn_tilt_issue_cmd(&tilt_ctl, RELAY_CHN_TILT_CMD_FORWARD); + relay_chn_tilt_issue_cmd(&s_tilt_ctl, RELAY_CHN_TILT_CMD_FORWARD); } void relay_chn_tilt_reverse() { - relay_chn_tilt_issue_cmd(&tilt_ctl, RELAY_CHN_TILT_CMD_REVERSE); + relay_chn_tilt_issue_cmd(&s_tilt_ctl, RELAY_CHN_TILT_CMD_REVERSE); } void relay_chn_tilt_stop() { - relay_chn_tilt_dispatch_cmd(&tilt_ctl, RELAY_CHN_TILT_CMD_STOP); + relay_chn_tilt_dispatch_cmd(&s_tilt_ctl, RELAY_CHN_TILT_CMD_STOP); } #endif // CONFIG_RELAY_CHN_COUNT > 1 @@ -335,7 +335,7 @@ void relay_chn_tilt_set_sensitivity(uint8_t chn_id, uint8_t sensitivity) { if (relay_chn_is_channel_id_valid(chn_id)) { ADJUST_TILT_SENS_BOUNDARIES(sensitivity); - relay_chn_tilt_compute_set_sensitivity(&tilt_ctls[chn_id], sensitivity); + relay_chn_tilt_compute_set_sensitivity(&s_tilt_ctls[chn_id], sensitivity); #if CONFIG_RELAY_CHN_ENABLE_NVS relay_chn_nvs_set_tilt_sensitivity(chn_id, sensitivity); @@ -354,7 +354,7 @@ esp_err_t relay_chn_tilt_set_sensitivity_all(uint8_t *sensitivities) break; } ADJUST_TILT_SENS_BOUNDARIES(*src_sensitivity); - relay_chn_tilt_compute_set_sensitivity(&tilt_ctls[i], *src_sensitivity); + relay_chn_tilt_compute_set_sensitivity(&s_tilt_ctls[i], *src_sensitivity); #if CONFIG_RELAY_CHN_ENABLE_NVS relay_chn_nvs_set_tilt_sensitivity(i, *src_sensitivity); #endif // CONFIG_RELAY_CHN_ENABLE_NVS @@ -366,7 +366,7 @@ void relay_chn_tilt_set_sensitivity_all_with(uint8_t sensitivity) { for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { ADJUST_TILT_SENS_BOUNDARIES(sensitivity); - relay_chn_tilt_compute_set_sensitivity(&tilt_ctls[i], sensitivity); + relay_chn_tilt_compute_set_sensitivity(&s_tilt_ctls[i], sensitivity); #if CONFIG_RELAY_CHN_ENABLE_NVS relay_chn_nvs_set_tilt_sensitivity(i, sensitivity); #endif // CONFIG_RELAY_CHN_ENABLE_NVS @@ -376,7 +376,7 @@ void relay_chn_tilt_set_sensitivity_all_with(uint8_t sensitivity) uint8_t relay_chn_tilt_get_sensitivity(uint8_t chn_id) { return relay_chn_is_channel_id_valid(chn_id) ? - tilt_ctls[chn_id].tilt_timing.sensitivity : 0; + s_tilt_ctls[chn_id].tilt_timing.sensitivity : 0; } esp_err_t relay_chn_tilt_get_sensitivity_all(uint8_t *sensitivities) @@ -389,7 +389,7 @@ esp_err_t relay_chn_tilt_get_sensitivity_all(uint8_t *sensitivities) ESP_LOGW(TAG, "get_sensitivity_all: Sensitivites have been copied until channel %d since sensitivities[%d] is NULL", i, i); break; } - *dest_sensitivity = tilt_ctls[i].tilt_timing.sensitivity; + *dest_sensitivity = s_tilt_ctls[i].tilt_timing.sensitivity; } return ESP_OK; } @@ -399,7 +399,7 @@ esp_err_t relay_chn_tilt_get_sensitivity_all(uint8_t *sensitivities) void relay_chn_tilt_set_sensitivity(uint8_t sensitivity) { ADJUST_TILT_SENS_BOUNDARIES(sensitivity); - relay_chn_tilt_compute_set_sensitivity(&tilt_ctl, sensitivity); + relay_chn_tilt_compute_set_sensitivity(&s_tilt_ctl, sensitivity); #if CONFIG_RELAY_CHN_ENABLE_NVS relay_chn_nvs_set_tilt_sensitivity(0, sensitivity); @@ -408,7 +408,7 @@ void relay_chn_tilt_set_sensitivity(uint8_t sensitivity) uint8_t relay_chn_tilt_get_sensitivity() { - return tilt_ctl.tilt_timing.sensitivity; + return s_tilt_ctl.tilt_timing.sensitivity; } #endif // CONFIG_RELAY_CHN_COUNT > 1 @@ -707,7 +707,7 @@ esp_err_t relay_chn_tilt_init(relay_chn_ctl_t *chn_ctls) sensitivity = RELAY_CHN_TILT_DEFAULT_SENSITIVITY; tilt_count = 0; #endif // CONFIG_RELAY_CHN_ENABLE_NVS == 1 - ret = relay_chn_tilt_ctl_init(&tilt_ctls[i], &chn_ctls[i], tilt_count, sensitivity); + ret = relay_chn_tilt_ctl_init(&s_tilt_ctls[i], &chn_ctls[i], tilt_count, sensitivity); ESP_RETURN_ON_ERROR(ret, TAG, "Failed to init tilt control for channel %d", i); } return ESP_OK; @@ -720,7 +720,7 @@ esp_err_t relay_chn_tilt_init(relay_chn_ctl_t *chn_ctls) ret = relay_chn_tilt_load_tilt_count(0, &tilt_count); ESP_RETURN_ON_ERROR(ret, TAG, "Failed to load tilt count for channel %d", 0); #endif // CONFIG_RELAY_CHN_ENABLE_NVS == 1 - return relay_chn_tilt_ctl_init(&tilt_ctl, chn_ctls, tilt_count, sensitivity); + return relay_chn_tilt_ctl_init(&s_tilt_ctl, chn_ctls, tilt_count, sensitivity); #endif // CONFIG_RELAY_CHN_COUNT > 1 } @@ -742,9 +742,9 @@ void relay_chn_tilt_deinit() { #if CONFIG_RELAY_CHN_COUNT > 1 for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { - relay_chn_tilt_ctl_deinit(&tilt_ctls[i]); + relay_chn_tilt_ctl_deinit(&s_tilt_ctls[i]); } #else - relay_chn_tilt_ctl_deinit(&tilt_ctl); + relay_chn_tilt_ctl_deinit(&s_tilt_ctl); #endif // CONFIG_RELAY_CHN_COUNT > 1 } \ 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 ecd6b4b..7da4008 100644 --- a/test_apps/main/test_relay_chn_core_multi.c +++ b/test_apps/main/test_relay_chn_core_multi.c @@ -6,20 +6,20 @@ #include "test_common.h" -relay_chn_state_t states[CONFIG_RELAY_CHN_COUNT], expect_states[CONFIG_RELAY_CHN_COUNT]; -relay_chn_direction_t directions[CONFIG_RELAY_CHN_COUNT], expect_directions[CONFIG_RELAY_CHN_COUNT]; +static relay_chn_state_t s_states[CONFIG_RELAY_CHN_COUNT], s_expect_states[CONFIG_RELAY_CHN_COUNT]; +static relay_chn_direction_t s_directions[CONFIG_RELAY_CHN_COUNT], s_expect_directions[CONFIG_RELAY_CHN_COUNT]; static void test_set_expected_state_all(relay_chn_state_t state) { for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { - expect_states[i] = state; + s_expect_states[i] = state; } } static void test_set_expected_direction_all(relay_chn_direction_t direction) { for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { - expect_directions[i] = direction; + s_expect_directions[i] = direction; } } @@ -231,24 +231,24 @@ TEST_CASE("Forward to Reverse transition with opposite inertia", "[relay_chn][co // 1. Start in forward direction relay_chn_run_forward_all(); vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); // Short delay for state stabilization - TEST_ESP_OK(relay_chn_get_state_all(states)); + TEST_ESP_OK(relay_chn_get_state_all(s_states)); test_set_expected_state_all(RELAY_CHN_STATE_FORWARD); - TEST_ASSERT_EQUAL_UINT_ARRAY(expect_states, states, CONFIG_RELAY_CHN_COUNT); + TEST_ASSERT_EQUAL_UINT_ARRAY(s_expect_states, s_states, CONFIG_RELAY_CHN_COUNT); // 2. Issue reverse command relay_chn_run_reverse_all(); // Immediately after the command, the motor should be stopped vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); - TEST_ESP_OK(relay_chn_get_state_all(states)); + TEST_ESP_OK(relay_chn_get_state_all(s_states)); test_set_expected_state_all(RELAY_CHN_STATE_REVERSE_PENDING); - TEST_ASSERT_EQUAL_UINT_ARRAY(expect_states, states, CONFIG_RELAY_CHN_COUNT); + TEST_ASSERT_EQUAL_UINT_ARRAY(s_expect_states, s_states, CONFIG_RELAY_CHN_COUNT); // Wait for the inertia period (after which the reverse command will be dispatched) vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); // Should now be in reverse state - TEST_ESP_OK(relay_chn_get_state_all(states)); + TEST_ESP_OK(relay_chn_get_state_all(s_states)); test_set_expected_state_all(RELAY_CHN_STATE_REVERSE); - TEST_ASSERT_EQUAL_UINT_ARRAY(expect_states, states, CONFIG_RELAY_CHN_COUNT); + TEST_ASSERT_EQUAL_UINT_ARRAY(s_expect_states, s_states, CONFIG_RELAY_CHN_COUNT); } // TEST_CASE: Test transition from reverse to forward with inertia and state checks @@ -258,22 +258,22 @@ TEST_CASE("Reverse to Forward transition with opposite inertia", "[relay_chn][co // 1. Start in reverse direction relay_chn_run_reverse_all(); vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); - TEST_ESP_OK(relay_chn_get_state_all(states)); + TEST_ESP_OK(relay_chn_get_state_all(s_states)); test_set_expected_state_all(RELAY_CHN_STATE_REVERSE); - TEST_ASSERT_EQUAL_UINT_ARRAY(expect_states, states, CONFIG_RELAY_CHN_COUNT); + TEST_ASSERT_EQUAL_UINT_ARRAY(s_expect_states, s_states, CONFIG_RELAY_CHN_COUNT); // 2. Issue forward command relay_chn_run_forward_all(); vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); - TEST_ESP_OK(relay_chn_get_state_all(states)); + TEST_ESP_OK(relay_chn_get_state_all(s_states)); test_set_expected_state_all(RELAY_CHN_STATE_FORWARD_PENDING); - TEST_ASSERT_EQUAL_UINT_ARRAY(expect_states, states, CONFIG_RELAY_CHN_COUNT); + TEST_ASSERT_EQUAL_UINT_ARRAY(s_expect_states, s_states, CONFIG_RELAY_CHN_COUNT); // Wait for inertia vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); - TEST_ESP_OK(relay_chn_get_state_all(states)); + TEST_ESP_OK(relay_chn_get_state_all(s_states)); test_set_expected_state_all(RELAY_CHN_STATE_FORWARD); - TEST_ASSERT_EQUAL_UINT_ARRAY(expect_states, states, CONFIG_RELAY_CHN_COUNT); + TEST_ASSERT_EQUAL_UINT_ARRAY(s_expect_states, s_states, CONFIG_RELAY_CHN_COUNT); } // TEST_CASE: Test issuing the same run command while already running (no inertia expected) @@ -283,18 +283,18 @@ TEST_CASE("Running in same direction does not incur inertia", "[relay_chn][core] // 1. Start in forward direction relay_chn_run_forward_all(); vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); - TEST_ESP_OK(relay_chn_get_state_all(states)); + TEST_ESP_OK(relay_chn_get_state_all(s_states)); test_set_expected_state_all(RELAY_CHN_STATE_FORWARD); - TEST_ASSERT_EQUAL_UINT_ARRAY(expect_states, states, CONFIG_RELAY_CHN_COUNT); + TEST_ASSERT_EQUAL_UINT_ARRAY(s_expect_states, s_states, CONFIG_RELAY_CHN_COUNT); // 2. Issue the same forward command again relay_chn_run_forward_all(); // 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_ESP_OK(relay_chn_get_state_all(states)); + TEST_ESP_OK(relay_chn_get_state_all(s_states)); test_set_expected_state_all(RELAY_CHN_STATE_FORWARD); - TEST_ASSERT_EQUAL_UINT_ARRAY(expect_states, states, CONFIG_RELAY_CHN_COUNT); + TEST_ASSERT_EQUAL_UINT_ARRAY(s_expect_states, s_states, CONFIG_RELAY_CHN_COUNT); } // ### Direction Flipping Tests @@ -336,44 +336,44 @@ TEST_CASE("All channels direction can be flipped simultaneously", "[relay_chn][c vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); // 2. Verify all channels are flipped - TEST_ESP_OK(relay_chn_get_direction_all(directions)); + TEST_ESP_OK(relay_chn_get_direction_all(s_directions)); test_set_expected_direction_all(RELAY_CHN_DIRECTION_FLIPPED); - TEST_ASSERT_EQUAL_UINT_ARRAY(expect_directions, directions, CONFIG_RELAY_CHN_COUNT); + TEST_ASSERT_EQUAL_UINT_ARRAY(s_expect_directions, s_directions, CONFIG_RELAY_CHN_COUNT); // 3. Flip all back relay_chn_flip_direction_all(); vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); // 4. Verify all channels are back to default - TEST_ESP_OK(relay_chn_get_direction_all(directions)); + TEST_ESP_OK(relay_chn_get_direction_all(s_directions)); test_set_expected_direction_all(RELAY_CHN_DIRECTION_DEFAULT); - TEST_ASSERT_EQUAL_UINT_ARRAY(expect_directions, directions, CONFIG_RELAY_CHN_COUNT); + TEST_ASSERT_EQUAL_UINT_ARRAY(s_expect_directions, s_directions, CONFIG_RELAY_CHN_COUNT); } TEST_CASE("Flipping a running channel stops it and flips direction", "[relay_chn][core][direction]") { // 1. Start channel running and verify state relay_chn_run_forward_all(); - TEST_ESP_OK(relay_chn_get_state_all(states)); + TEST_ESP_OK(relay_chn_get_state_all(s_states)); test_set_expected_state_all(RELAY_CHN_STATE_FORWARD); - TEST_ASSERT_EQUAL_UINT_ARRAY(expect_states, states, CONFIG_RELAY_CHN_COUNT); + TEST_ASSERT_EQUAL_UINT_ARRAY(s_expect_states, s_states, CONFIG_RELAY_CHN_COUNT); // 2. Flip the direction while running relay_chn_flip_direction_all(); // 3. The channel should stop as part of the flip process - TEST_ESP_OK(relay_chn_get_state_all(states)); + TEST_ESP_OK(relay_chn_get_state_all(s_states)); test_set_expected_state_all(RELAY_CHN_STATE_STOPPED); - TEST_ASSERT_EQUAL_UINT_ARRAY(expect_states, states, CONFIG_RELAY_CHN_COUNT); + TEST_ASSERT_EQUAL_UINT_ARRAY(s_expect_states, s_states, CONFIG_RELAY_CHN_COUNT); // 4. Wait for the flip inertia to pass, after which it should be idle and FLIPPED vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); - TEST_ESP_OK(relay_chn_get_state_all(states)); + TEST_ESP_OK(relay_chn_get_state_all(s_states)); test_set_expected_state_all(RELAY_CHN_STATE_IDLE); - TEST_ASSERT_EQUAL_UINT_ARRAY(expect_states, states, CONFIG_RELAY_CHN_COUNT); + TEST_ASSERT_EQUAL_UINT_ARRAY(s_expect_states, s_states, CONFIG_RELAY_CHN_COUNT); - TEST_ESP_OK(relay_chn_get_direction_all(directions)); + TEST_ESP_OK(relay_chn_get_direction_all(s_directions)); test_set_expected_direction_all(RELAY_CHN_DIRECTION_FLIPPED); - TEST_ASSERT_EQUAL_UINT_ARRAY(expect_directions, directions, CONFIG_RELAY_CHN_COUNT); + TEST_ASSERT_EQUAL_UINT_ARRAY(s_expect_directions, s_directions, CONFIG_RELAY_CHN_COUNT); } TEST_CASE("Direction flip handles invalid channel ID gracefully", "[relay_chn][core][direction]") @@ -387,7 +387,7 @@ TEST_CASE("Direction flip handles invalid channel ID gracefully", "[relay_chn][c TEST_CASE("get_state_all retrieves all channel states", "[relay_chn][core][batch]") { // 1. All should be IDLE initially - TEST_ESP_OK(relay_chn_get_state_all(states)); + TEST_ESP_OK(relay_chn_get_state_all(s_states)); test_set_expected_state_all(RELAY_CHN_STATE_IDLE); // 2. Set some states @@ -403,30 +403,30 @@ TEST_CASE("get_state_all retrieves all channel states", "[relay_chn][core][batch // 3. Get all states and verify for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { if (i % 2 == 0) { - expect_states[i] = RELAY_CHN_STATE_FORWARD; + s_expect_states[i] = RELAY_CHN_STATE_FORWARD; } else { - expect_states[i] = RELAY_CHN_STATE_REVERSE; + s_expect_states[i] = RELAY_CHN_STATE_REVERSE; } } - TEST_ESP_OK(relay_chn_get_state_all(states)); - TEST_ASSERT_EQUAL_UINT_ARRAY(expect_states, states, CONFIG_RELAY_CHN_COUNT); + TEST_ESP_OK(relay_chn_get_state_all(s_states)); + TEST_ASSERT_EQUAL_UINT_ARRAY(s_expect_states, s_states, CONFIG_RELAY_CHN_COUNT); } TEST_CASE("get_direction_all retrieves all channel directions", "[relay_chn][core][direction][batch]") { // 1. All should be default initially - TEST_ESP_OK(relay_chn_get_direction_all(directions)); + TEST_ESP_OK(relay_chn_get_direction_all(s_directions)); test_set_expected_direction_all(RELAY_CHN_DIRECTION_DEFAULT); - TEST_ASSERT_EQUAL_UINT_ARRAY(expect_directions, directions, CONFIG_RELAY_CHN_COUNT); + TEST_ASSERT_EQUAL_UINT_ARRAY(s_expect_directions, s_directions, CONFIG_RELAY_CHN_COUNT); // 2. Flip all relay_chn_flip_direction_all(); vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); // 3. Get all directions and verify - TEST_ESP_OK(relay_chn_get_direction_all(directions)); + TEST_ESP_OK(relay_chn_get_direction_all(s_directions)); test_set_expected_direction_all(RELAY_CHN_DIRECTION_FLIPPED); - TEST_ASSERT_EQUAL_UINT_ARRAY(expect_directions, directions, CONFIG_RELAY_CHN_COUNT); + TEST_ASSERT_EQUAL_UINT_ARRAY(s_expect_directions, s_directions, CONFIG_RELAY_CHN_COUNT); } TEST_CASE("get_all functions handle NULL arguments", "[relay_chn][core][batch]")