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

Implement specific *all functions

Browse Source 
Specific `_*all` and `_*all_with` functions were implemented to make
the API more concise and clean, and to replace the use of
`RELAY_CHN_ID_ALL`, which caused confusion within the API.

Refs #1085
This commit is contained in:
Ismail Sahillioglu
2025-08-25 18:50:21 +03:00
parent be4a2ebef6
commit 3831384169
14 changed files with 578 additions and 221 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/relay_chn_core.c
View File

@@ -407,7 +407,7 @@ void relay_chn_issue_cmd(relay_chn_ctl_t* chn_ctl, relay_chn_cmd_t cmd)
#if CONFIG_RELAY_CHN_COUNT > 1
bool relay_chn_is_channel_id_valid(uint8_t chn_id)
{
bool valid = (chn_id < CONFIG_RELAY_CHN_COUNT) || chn_id == RELAY_CHN_ID_ALL;
bool valid = chn_id < CONFIG_RELAY_CHN_COUNT;
if (!valid) {
ESP_LOGE(TAG, "Invalid channel ID: %d", chn_id);
}

175
src/relay_chn_ctl_multi.c
View File

@@ -72,20 +72,33 @@ void relay_chn_ctl_deinit()
relay_chn_state_t relay_chn_ctl_get_state(uint8_t chn_id)
{
if (!relay_chn_is_channel_id_valid(chn_id) || chn_id == RELAY_CHN_ID_ALL) {
return RELAY_CHN_STATE_UNDEFINED;
return relay_chn_is_channel_id_valid(chn_id) ?
chn_ctls[chn_id].state : RELAY_CHN_STATE_UNDEFINED;
}
esp_err_t relay_chn_ctl_get_state_all(relay_chn_state_t *states)
{
ESP_RETURN_ON_FALSE(states != NULL, ESP_ERR_INVALID_ARG, TAG, "states cannot be NULL");
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
relay_chn_state_t *dest_state = &states[i];
if (dest_state == NULL) {
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;
}
return chn_ctls[chn_id].state;
return ESP_OK;
}
char *relay_chn_ctl_get_state_str(uint8_t chn_id)
{
if (!relay_chn_is_channel_id_valid(chn_id) || chn_id == RELAY_CHN_ID_ALL) {
return relay_chn_state_str(RELAY_CHN_STATE_UNDEFINED);
}
return relay_chn_state_str(chn_ctls[chn_id].state);
return relay_chn_is_channel_id_valid(chn_id)
? relay_chn_state_str(chn_ctls[chn_id].state)
: relay_chn_state_str(RELAY_CHN_STATE_UNDEFINED);
}
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++) {
@@ -95,94 +108,142 @@ static void relay_chn_ctl_issue_cmd_on_all_channels(relay_chn_cmd_t cmd)
void relay_chn_ctl_run_forward(uint8_t chn_id)
{
if (!relay_chn_is_channel_id_valid(chn_id)) return;
if (relay_chn_is_channel_id_valid(chn_id))
relay_chn_issue_cmd(&chn_ctls[chn_id], RELAY_CHN_CMD_FORWARD);
}
if (chn_id == RELAY_CHN_ID_ALL) {
relay_chn_ctl_issue_cmd_on_all_channels(RELAY_CHN_CMD_FORWARD);
return;
}
relay_chn_issue_cmd(&chn_ctls[chn_id], RELAY_CHN_CMD_FORWARD);
void relay_chn_ctl_run_forward_all()
{
relay_chn_ctl_issue_cmd_on_all_channels(RELAY_CHN_CMD_FORWARD);
}
void relay_chn_ctl_run_reverse(uint8_t chn_id)
{
if (!relay_chn_is_channel_id_valid(chn_id)) return;
if (relay_chn_is_channel_id_valid(chn_id))
relay_chn_issue_cmd(&chn_ctls[chn_id], RELAY_CHN_CMD_REVERSE);
}
if (chn_id == RELAY_CHN_ID_ALL) {
relay_chn_ctl_issue_cmd_on_all_channels(RELAY_CHN_CMD_REVERSE);
return;
}
relay_chn_issue_cmd(&chn_ctls[chn_id], RELAY_CHN_CMD_REVERSE);
void relay_chn_ctl_run_reverse_all()
{
relay_chn_ctl_issue_cmd_on_all_channels(RELAY_CHN_CMD_REVERSE);
}
void relay_chn_ctl_stop(uint8_t chn_id)
{
if (!relay_chn_is_channel_id_valid(chn_id)) return;
if (relay_chn_is_channel_id_valid(chn_id))
relay_chn_issue_cmd(&chn_ctls[chn_id], RELAY_CHN_CMD_STOP);
}
if (chn_id == RELAY_CHN_ID_ALL) {
relay_chn_ctl_issue_cmd_on_all_channels(RELAY_CHN_CMD_STOP);
return;
}
relay_chn_issue_cmd(&chn_ctls[chn_id], RELAY_CHN_CMD_STOP);
void relay_chn_ctl_stop_all()
{
relay_chn_ctl_issue_cmd_on_all_channels(RELAY_CHN_CMD_STOP);
}
void relay_chn_ctl_flip_direction(uint8_t chn_id)
{
if (!relay_chn_is_channel_id_valid(chn_id)) return;
if (relay_chn_is_channel_id_valid(chn_id))
relay_chn_issue_cmd(&chn_ctls[chn_id], RELAY_CHN_CMD_FLIP);
}
if (chn_id == RELAY_CHN_ID_ALL) {
relay_chn_ctl_issue_cmd_on_all_channels(RELAY_CHN_CMD_FLIP);
return;
}
relay_chn_issue_cmd(&chn_ctls[chn_id], RELAY_CHN_CMD_FLIP);
void relay_chn_ctl_flip_direction_all()
{
relay_chn_ctl_issue_cmd_on_all_channels(RELAY_CHN_CMD_FLIP);
}
relay_chn_direction_t relay_chn_ctl_get_direction(uint8_t chn_id)
{
if (!relay_chn_is_channel_id_valid(chn_id)) {
return RELAY_CHN_DIRECTION_DEFAULT;
return relay_chn_is_channel_id_valid(chn_id)
? relay_chn_output_get_direction(chn_ctls[chn_id].output)
: RELAY_CHN_DIRECTION_DEFAULT;
}
esp_err_t relay_chn_ctl_get_direction_all(relay_chn_direction_t *directions)
{
ESP_RETURN_ON_FALSE(directions != NULL, ESP_ERR_INVALID_ARG, TAG, "directions cannot be NULL");
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
relay_chn_direction_t *dest_direction = &directions[i];
if (dest_direction == NULL) {
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);
}
relay_chn_ctl_t *chn_ctl = &chn_ctls[chn_id];
return relay_chn_output_get_direction(chn_ctl->output);
return ESP_OK;
}
#if CONFIG_RELAY_CHN_ENABLE_RUN_LIMIT
uint16_t relay_chn_ctl_get_run_limit(uint8_t chn_id)
{
if (!relay_chn_is_channel_id_valid(chn_id) || chn_id == RELAY_CHN_ID_ALL) {
ESP_LOGE(TAG, "get_run_limit: Invalid channel ID: %d", chn_id);
return 0;
}
return chn_ctls[chn_id].run_limit_sec;
return relay_chn_is_channel_id_valid(chn_id) ? chn_ctls[chn_id].run_limit_sec : 0;
}
void relay_chn_ctl_set_run_limit(uint8_t chn_id, uint16_t time_sec)
esp_err_t relay_chn_ctl_get_run_limit_all(uint16_t *limits_sec)
{
if (!relay_chn_is_channel_id_valid(chn_id) || chn_id == RELAY_CHN_ID_ALL) {
ESP_RETURN_ON_FALSE(limits_sec != NULL, ESP_ERR_INVALID_ARG, TAG, "limits_sec cannot be NULL");
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
uint16_t *dest_limit_sec = &limits_sec[i];
if (dest_limit_sec == NULL) {
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;
}
return ESP_OK;
}
static void relay_chn_ctl_set_run_limit_common(uint8_t chn_id, uint16_t limit_sec)
{
// Check for boundaries
if (limit_sec > CONFIG_RELAY_CHN_RUN_LIMIT_MAX_SEC)
limit_sec = CONFIG_RELAY_CHN_RUN_LIMIT_MAX_SEC;
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;
#if CONFIG_RELAY_CHN_ENABLE_NVS
relay_chn_nvs_set_run_limit(chn_id, limit_sec);
#endif
}
void relay_chn_ctl_set_run_limit(uint8_t chn_id, uint16_t limit_sec)
{
if (!relay_chn_is_channel_id_valid(chn_id)) {
ESP_LOGE(TAG, "set_run_limit: Invalid channel ID: %d", chn_id);
return;
}
// Check for boundaries
if (time_sec > CONFIG_RELAY_CHN_RUN_LIMIT_MAX_SEC)
time_sec = CONFIG_RELAY_CHN_RUN_LIMIT_MAX_SEC;
else if (time_sec < CONFIG_RELAY_CHN_RUN_LIMIT_MIN_SEC)
time_sec = CONFIG_RELAY_CHN_RUN_LIMIT_MIN_SEC;
relay_chn_ctl_set_run_limit_common(chn_id, limit_sec);
}
chn_ctls[chn_id].run_limit_sec = time_sec;
esp_err_t relay_chn_ctl_set_run_limit_all(uint16_t *limits_sec)
{
ESP_RETURN_ON_FALSE(limits_sec != NULL, ESP_ERR_INVALID_ARG, TAG, "limits_sec cannot be NULL");
#if CONFIG_RELAY_CHN_ENABLE_NVS
relay_chn_nvs_set_run_limit(chn_id, time_sec);
#endif
}
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
uint16_t *src_limit_sec = &limits_sec[i];
if (src_limit_sec == NULL) {
ESP_LOGW(TAG, "set_run_limit_all: Run limits have been set until channel %d since limits_sec[%d] is NULL", i, i);
break;
}
relay_chn_ctl_set_run_limit_common(i, *src_limit_sec);
}
return ESP_OK;
}
esp_err_t relay_chn_ctl_set_run_limit_all_with(uint16_t limit_sec)
{
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
relay_chn_ctl_set_run_limit_common(i, limit_sec);
}
return ESP_OK;
}
#endif
relay_chn_ctl_t *relay_chn_ctl_get(uint8_t chn_id)
{
if (!relay_chn_is_channel_id_valid(chn_id)) {
return NULL;
}
return &chn_ctls[chn_id];
return relay_chn_is_channel_id_valid(chn_id) ? &chn_ctls[chn_id] : NULL;
}
relay_chn_ctl_t *relay_chn_ctl_get_all(void)

1
src/relay_chn_output.c
View File

@@ -6,7 +6,6 @@
#include "esp_check.h"
#include "esp_log.h"
#include "relay_chn_defs.h"
#include "relay_chn_output.h"
#include "relay_chn_core.h"

160
src/relay_chn_tilt.c
View File

@@ -106,6 +106,7 @@ static void relay_chn_tilt_issue_cmd(relay_chn_tilt_ctl_t *tilt_ctl, relay_chn_t
// Set the command that will be processed
tilt_ctl->cmd = cmd;
ESP_LOGI(TAG, "relay_chn_tilt_issue_cmd: Command-chn: %d-%d", cmd, tilt_ctl->chn_ctl->id); // TODO delete
switch (tilt_ctl->chn_ctl->state) {
case RELAY_CHN_STATE_IDLE:
// Relay channel is free, tilt can be issued immediately
@@ -176,78 +177,67 @@ static void relay_chn_tilt_issue_auto(relay_chn_tilt_ctl_t *tilt_ctl)
}
}
#if CONFIG_RELAY_CHN_COUNT > 1
void relay_chn_tilt_auto(uint8_t chn_id)
{
if (!relay_chn_is_channel_id_valid(chn_id)) {
return;
}
// Execute for all channels
if (chn_id == RELAY_CHN_ID_ALL) {
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
relay_chn_tilt_issue_auto(&tilt_ctls[i]);
}
}
// Execute for a single channel
else {
relay_chn_tilt_ctl_t* tilt_ctl = &tilt_ctls[chn_id];
relay_chn_tilt_issue_auto(tilt_ctl);
}
}
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];
ESP_LOGI(TAG, "issue_cmd_on_all_channels: Command|chn|ctl.id: %d|%d|%d", cmd, i, tilt_ctl->chn_ctl->id); // TODO delete
relay_chn_tilt_issue_cmd(tilt_ctl, 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]);
}
}
void relay_chn_tilt_auto_all()
{
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
relay_chn_tilt_issue_auto(&tilt_ctls[i]);
}
}
void relay_chn_tilt_forward(uint8_t chn_id)
{
if (!relay_chn_is_channel_id_valid(chn_id)) {
return;
}
if (chn_id == RELAY_CHN_ID_ALL)
relay_chn_tilt_issue_cmd_on_all_channels(RELAY_CHN_TILT_CMD_FORWARD);
else {
relay_chn_tilt_ctl_t* tilt_ctl = &tilt_ctls[chn_id];
relay_chn_tilt_issue_cmd(tilt_ctl, RELAY_CHN_TILT_CMD_FORWARD);
if (relay_chn_is_channel_id_valid(chn_id)) {
relay_chn_tilt_issue_cmd(&tilt_ctls[chn_id], RELAY_CHN_TILT_CMD_FORWARD);
}
}
void relay_chn_tilt_forward_all()
{
relay_chn_tilt_issue_cmd_on_all_channels(RELAY_CHN_TILT_CMD_FORWARD);
}
void relay_chn_tilt_reverse(uint8_t chn_id)
{
if (!relay_chn_is_channel_id_valid(chn_id)) {
return;
if (relay_chn_is_channel_id_valid(chn_id)) {
relay_chn_tilt_issue_cmd(&tilt_ctls[chn_id], RELAY_CHN_TILT_CMD_REVERSE);
}
if (chn_id == RELAY_CHN_ID_ALL)
}
void relay_chn_tilt_reverse_all()
{
relay_chn_tilt_issue_cmd_on_all_channels(RELAY_CHN_TILT_CMD_REVERSE);
else {
relay_chn_tilt_ctl_t* tilt_ctl = &tilt_ctls[chn_id];
relay_chn_tilt_issue_cmd(tilt_ctl, RELAY_CHN_TILT_CMD_REVERSE);
}
}
void relay_chn_tilt_stop(uint8_t chn_id)
{
if (!relay_chn_is_channel_id_valid(chn_id)) {
return;
}
if (chn_id == RELAY_CHN_ID_ALL) {
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
relay_chn_tilt_dispatch_cmd(&tilt_ctls[i], RELAY_CHN_TILT_CMD_STOP);
}
}
else {
relay_chn_tilt_dispatch_cmd(&tilt_ctls[chn_id], RELAY_CHN_TILT_CMD_STOP);
}
}
void relay_chn_tilt_stop_all()
{
relay_chn_tilt_issue_cmd_on_all_channels(RELAY_CHN_TILT_CMD_STOP);
}
#else // CONFIG_RELAY_CHN_COUNT > 1
void relay_chn_tilt_auto()
@@ -317,45 +307,61 @@ static void relay_chn_tilt_compute_set_sensitivity(relay_chn_tilt_ctl_t *tilt_ct
#if CONFIG_RELAY_CHN_COUNT > 1
void relay_chn_tilt_set_sensitivity(uint8_t chn_id, uint8_t sensitivity)
{
if (!relay_chn_is_channel_id_valid(chn_id)) {
return;
}
if (chn_id == RELAY_CHN_ID_ALL) {
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
relay_chn_tilt_compute_set_sensitivity(&tilt_ctls[i], sensitivity);
}
}
else {
if (relay_chn_is_channel_id_valid(chn_id)) {
relay_chn_tilt_compute_set_sensitivity(&tilt_ctls[chn_id], sensitivity);
}
#if CONFIG_RELAY_CHN_ENABLE_NVS
relay_chn_nvs_set_tilt_sensitivity(chn_id, sensitivity);
relay_chn_nvs_set_tilt_sensitivity(chn_id, sensitivity);
#endif // CONFIG_RELAY_CHN_ENABLE_NVS
}
}
esp_err_t relay_chn_tilt_get_sensitivity(uint8_t chn_id, uint8_t *sensitivity, size_t length)
esp_err_t relay_chn_tilt_set_sensitivity_all(uint8_t *sensitivities)
{
if (!relay_chn_is_channel_id_valid(chn_id)) {
return ESP_ERR_INVALID_ARG;
}
if (sensitivity == NULL) {
ESP_LOGD(TAG, "relay_chn_tilt_get_sensitivity: sensitivity is NULL");
return ESP_ERR_INVALID_ARG;
}
if (chn_id == RELAY_CHN_ID_ALL) {
if (length < CONFIG_RELAY_CHN_COUNT) {
ESP_LOGD(TAG, "relay_chn_tilt_get_sensitivity: length is too short to store all sensitivity values");
return ESP_ERR_INVALID_ARG;
ESP_RETURN_ON_FALSE(sensitivities != NULL, ESP_ERR_INVALID_ARG, TAG, "set_sensitivity_all: sensitivities is NULL");
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
uint8_t *src_sensitivity = &sensitivities[i];
if (src_sensitivity == NULL) {
ESP_LOGW(TAG, "set_sensitivity_all: Run limits have been set until channel %d since sensitivities[%d] is NULL", i, i);
break;
}
relay_chn_tilt_compute_set_sensitivity(&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
}
return ESP_OK;
}
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
sensitivity[i] = tilt_ctls[i].tilt_timing.sensitivity;
}
return ESP_OK;
void relay_chn_tilt_set_sensitivity_all_with(uint8_t sensitivity)
{
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
relay_chn_tilt_compute_set_sensitivity(&tilt_ctls[i], sensitivity);
#if CONFIG_RELAY_CHN_ENABLE_NVS
relay_chn_nvs_set_tilt_sensitivity(i, sensitivity);
#endif // CONFIG_RELAY_CHN_ENABLE_NVS
}
}
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;
}
esp_err_t relay_chn_tilt_get_sensitivity_all(uint8_t *sensitivities)
{
ESP_RETURN_ON_FALSE(sensitivities != NULL, ESP_ERR_INVALID_ARG, TAG, "get_sensitivity_all: sensitivities is NULL");
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
uint8_t *dest_sensitivity = &sensitivities[i];
if (dest_sensitivity == NULL) {
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;
}
*sensitivity = tilt_ctls[chn_id].tilt_timing.sensitivity;
return ESP_OK;
}
@@ -547,6 +553,7 @@ static void relay_chn_tilt_execute_pause(relay_chn_tilt_ctl_t *tilt_ctl)
esp_err_t relay_chn_tilt_dispatch_cmd(relay_chn_tilt_ctl_t *tilt_ctl, relay_chn_tilt_cmd_t cmd)
{
ESP_LOGD(TAG, "relay_chn_tilt_dispatch_cmd: Command: %d", cmd);
ESP_LOGI(TAG, "tilt_dispatch_cmd: Command-chn: %d-%d", cmd, tilt_ctl->chn_ctl->id); // TODO delete
switch(cmd) {
case RELAY_CHN_TILT_CMD_STOP:
@@ -666,8 +673,9 @@ esp_err_t relay_chn_tilt_init(relay_chn_ctl_t *chn_ctls)
#if CONFIG_RELAY_CHN_COUNT > 1
for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
esp_err_t ret;
#if CONFIG_RELAY_CHN_ENABLE_NVS
esp_err_t ret = relay_chn_tilt_load_sensitivity(i, &sensitivity);
ret = relay_chn_tilt_load_sensitivity(i, &sensitivity);
ESP_RETURN_ON_ERROR(ret, TAG, "Failed to load tilt sensitivity for channel %d", i);
ret = relay_chn_tilt_load_tilt_count(i, &tilt_count);
ESP_RETURN_ON_ERROR(ret, TAG, "Failed to load tilt count for channel %d", i);