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

Fix static variable names

Browse Source 
Fixed static variable names according to the ESP-IDF C code formatting guide.

Refs #1085 and fixes #1103
This commit is contained in:
Ismail Sahillioglu
2025-09-04 18:20:51 +03:00
parent bf5e3a4426
commit 86cc29a33b
8 changed files with 210 additions and 210 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
src/relay_chn_nvs.c
View File

@@ -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);
}