ismail
61f8ed440e
The addition of a single-channel mode implied further modularisation of the component. This commit has broken the component down into the following modules to avoid a huge single source file and to make unit testing easier. The modules: - Separation of public and private code - *types and *defs - public relay_chn API - *adapter - *output - *run_info - *core - *ctl (control) - *tilt Closes #957.
634 lines
23 KiB
C
634 lines
23 KiB
C
/*
|
|
* SPDX-FileCopyrightText: 2025 Kozmotronik Tech
|
|
*
|
|
* SPDX-License-Identifier: MIT
|
|
*/
|
|
|
|
#include "esp_check.h"
|
|
#include "relay_chn_core.h"
|
|
#include "relay_chn_output.h"
|
|
#include "relay_chn_run_info.h"
|
|
#include "relay_chn_tilt.h"
|
|
|
|
|
|
static const char *TAG = "RELAY_CHN_TILT";
|
|
|
|
/**@{*/
|
|
/*
|
|
* Tilt Pattern Timing Definitions
|
|
*
|
|
* The min and max timing definitions as well as the default timing definitions.
|
|
* These definitions are used to define and adjust the tilt sensitivity.
|
|
*/
|
|
#define RELAY_CHN_TILT_RUN_MIN_MS 50
|
|
#define RELAY_CHN_TILT_RUN_MAX_MS 10
|
|
#define RELAY_CHN_TILT_PAUSE_MIN_MS 450
|
|
#define RELAY_CHN_TILT_PAUSE_MAX_MS 90
|
|
|
|
#define RELAY_CHN_TILT_DEFAULT_RUN_MS 15
|
|
#define RELAY_CHN_TILT_DEFAULT_PAUSE_MS 150
|
|
|
|
#define RELAY_CHN_TILT_DEFAULT_SENSITIVITY \
|
|
( (RELAY_CHN_TILT_DEFAULT_RUN_MS - RELAY_CHN_TILT_RUN_MIN_MS) \
|
|
* 100 / (RELAY_CHN_TILT_RUN_MAX_MS - RELAY_CHN_TILT_RUN_MIN_MS) )
|
|
/**@}*/
|
|
|
|
ESP_EVENT_DEFINE_BASE(RELAY_CHN_TILT_CMD_EVENT_BASE);
|
|
|
|
|
|
/// @brief Tilt steps.
|
|
typedef enum {
|
|
RELAY_CHN_TILT_STEP_NONE, /*!< No step */
|
|
RELAY_CHN_TILT_STEP_PENDING, /*!< Pending step */
|
|
RELAY_CHN_TILT_STEP_MOVE, /*!< Move step. Tilt is driving either for forward or reverse */
|
|
RELAY_CHN_TILT_STEP_PAUSE /*!< Pause step. Tilt is paused */
|
|
} relay_chn_tilt_step_t;
|
|
|
|
/// @brief Tilt timing structure to manage tilt pattern timing.
|
|
typedef struct {
|
|
uint8_t sensitivity; /*!< Tilt sensitivity in percentage (%) */
|
|
uint32_t move_time_ms; /*!< Move time in milliseconds */
|
|
uint32_t pause_time_ms; /*!< Pause time in milliseconds */
|
|
} relay_chn_tilt_timing_t;
|
|
|
|
/// @brief Tilt counter structure to manage tilt count.
|
|
typedef struct {
|
|
uint32_t tilt_forward_count; /*!< Tilt forward count */
|
|
uint32_t tilt_reverse_count; /*!< Tilt reverse count */
|
|
} relay_chn_tilt_counter_t;
|
|
|
|
/// @brief Tilt control structure to manage tilt operations.
|
|
typedef struct relay_chn_tilt_ctl {
|
|
relay_chn_ctl_t *chn_ctl; /*!< The relay channel control structure */
|
|
relay_chn_tilt_cmd_t cmd; /*!< The tilt command in process */
|
|
relay_chn_tilt_step_t step; /*!< Current tilt step */
|
|
relay_chn_tilt_timing_t tilt_timing; /*!< Tilt timing structure */
|
|
relay_chn_tilt_counter_t tilt_counter; /*!< Tilt counter structure */
|
|
esp_timer_handle_t tilt_timer; /*!< Tilt timer handle */
|
|
} relay_chn_tilt_ctl_t;
|
|
|
|
|
|
#if RELAY_CHN_COUNT > 1
|
|
static relay_chn_tilt_ctl_t tilt_ctls[RELAY_CHN_COUNT];
|
|
#else
|
|
static relay_chn_tilt_ctl_t tilt_ctl;
|
|
#endif
|
|
|
|
|
|
esp_err_t relay_chn_tilt_dispatch_cmd(relay_chn_tilt_ctl_t *tilt_ctl, relay_chn_tilt_cmd_t cmd)
|
|
{
|
|
if (cmd == RELAY_CHN_TILT_CMD_NONE) return ESP_ERR_INVALID_ARG;
|
|
|
|
// Since the event_loop library creates a deep copy of the event data,
|
|
// and we need to pass the pointer of the relevant tilt control, here we need
|
|
// to pass the pointer to the pointer of the tilt_control (&tilt_ctl) so that
|
|
// the pointer value is preserved in the event data.
|
|
return esp_event_post_to(relay_chn_event_loop,
|
|
RELAY_CHN_TILT_CMD_EVENT_BASE,
|
|
cmd,
|
|
&tilt_ctl,
|
|
sizeof(tilt_ctl), portMAX_DELAY);
|
|
}
|
|
|
|
// Returns the required timing before tilting depending on the last run.
|
|
static uint32_t relay_chn_tilt_get_required_timing_before_tilting(relay_chn_tilt_ctl_t *tilt_ctl, relay_chn_tilt_cmd_t cmd)
|
|
{
|
|
relay_chn_cmd_t last_run_cmd = relay_chn_run_info_get_last_run_cmd(tilt_ctl->chn_ctl->run_info);
|
|
if (cmd == RELAY_CHN_TILT_CMD_FORWARD && last_run_cmd == RELAY_CHN_CMD_REVERSE)
|
|
return 0;
|
|
else if (cmd == RELAY_CHN_TILT_CMD_REVERSE && last_run_cmd == RELAY_CHN_CMD_FORWARD)
|
|
return 0;
|
|
|
|
uint32_t last_run_cmd_time_ms = relay_chn_run_info_get_last_run_cmd_time_ms(tilt_ctl->chn_ctl->run_info);
|
|
uint32_t inertia_time_passed_ms = (uint32_t) (esp_timer_get_time() / 1000) - last_run_cmd_time_ms;
|
|
return RELAY_CHN_OPPOSITE_INERTIA_MS - inertia_time_passed_ms;
|
|
}
|
|
|
|
// 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)
|
|
{
|
|
if (relay_chn_run_info_get_last_run_cmd(tilt_ctl->chn_ctl->run_info) == RELAY_CHN_CMD_NONE) {
|
|
// Do not tilt if the channel hasn't been run before
|
|
ESP_LOGD(TAG, "relay_chn_tilt_issue_cmd: Tilt will not be executed since the channel hasn't been run yet");
|
|
return;
|
|
}
|
|
|
|
if (tilt_ctl->cmd == cmd) {
|
|
ESP_LOGD(TAG, "relay_chn_tilt_issue_cmd: There is already a tilt command in progress!");
|
|
return;
|
|
}
|
|
|
|
// Set the command that will be processed
|
|
tilt_ctl->cmd = cmd;
|
|
switch (tilt_ctl->chn_ctl->state) {
|
|
case RELAY_CHN_STATE_IDLE:
|
|
// Relay channel is free, tilt can be issued immediately
|
|
relay_chn_tilt_dispatch_cmd(tilt_ctl, cmd);
|
|
break;
|
|
|
|
case RELAY_CHN_STATE_FORWARD_PENDING:
|
|
case RELAY_CHN_STATE_REVERSE_PENDING:
|
|
// Issue a stop command first so that the timer and pending cmd get cleared
|
|
relay_chn_dispatch_cmd(tilt_ctl->chn_ctl, RELAY_CHN_CMD_STOP);
|
|
// break not put intentionally
|
|
case RELAY_CHN_STATE_STOPPED: {
|
|
// Check if channel needs timing before tilting
|
|
uint32_t req_timing_ms = relay_chn_tilt_get_required_timing_before_tilting(tilt_ctl, cmd);
|
|
if (req_timing_ms == 0) {
|
|
relay_chn_tilt_dispatch_cmd(tilt_ctl, cmd);
|
|
} else {
|
|
// Channel needs timing before running tilting action, schedule it
|
|
tilt_ctl->step = RELAY_CHN_TILT_STEP_PENDING;
|
|
relay_chn_start_esp_timer_once(tilt_ctl->tilt_timer, req_timing_ms);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case RELAY_CHN_STATE_FORWARD:
|
|
if (cmd == RELAY_CHN_TILT_CMD_FORWARD) {
|
|
// Stop the running channel first
|
|
relay_chn_dispatch_cmd(tilt_ctl->chn_ctl, RELAY_CHN_CMD_STOP);
|
|
// Schedule for tilting
|
|
tilt_ctl->step = RELAY_CHN_TILT_STEP_PENDING;
|
|
relay_chn_start_esp_timer_once(tilt_ctl->tilt_timer, RELAY_CHN_OPPOSITE_INERTIA_MS);
|
|
} else if (cmd == RELAY_CHN_TILT_CMD_REVERSE) {
|
|
// Stop the running channel first
|
|
relay_chn_dispatch_cmd(tilt_ctl->chn_ctl, RELAY_CHN_CMD_STOP);
|
|
// If the tilt cmd is TILT_REVERSE then dispatch it immediately
|
|
relay_chn_tilt_dispatch_cmd(tilt_ctl, cmd);
|
|
}
|
|
break;
|
|
|
|
case RELAY_CHN_STATE_REVERSE:
|
|
if (cmd == RELAY_CHN_TILT_CMD_REVERSE) {
|
|
// Stop the running channel first
|
|
relay_chn_dispatch_cmd(tilt_ctl->chn_ctl, RELAY_CHN_CMD_STOP);
|
|
// Schedule for tilting
|
|
tilt_ctl->step = RELAY_CHN_TILT_STEP_PENDING;
|
|
relay_chn_start_esp_timer_once(tilt_ctl->tilt_timer, RELAY_CHN_OPPOSITE_INERTIA_MS);
|
|
} else if (cmd == RELAY_CHN_TILT_CMD_FORWARD) {
|
|
// Stop the running channel first
|
|
relay_chn_dispatch_cmd(tilt_ctl->chn_ctl, RELAY_CHN_CMD_STOP);
|
|
// If the tilt cmd is TILT_FORWARD then dispatch it immediately
|
|
relay_chn_tilt_dispatch_cmd(tilt_ctl, cmd);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
ESP_LOGD(TAG, "relay_chn_tilt_issue_cmd: Unexpected relay channel state: %s!", relay_chn_state_str(tilt_ctl->chn_ctl->state));
|
|
}
|
|
}
|
|
|
|
static void relay_chn_tilt_issue_auto(relay_chn_tilt_ctl_t *tilt_ctl)
|
|
{
|
|
relay_chn_cmd_t last_run_cmd = relay_chn_run_info_get_last_run_cmd(tilt_ctl->chn_ctl->run_info);
|
|
if (last_run_cmd == RELAY_CHN_CMD_FORWARD || tilt_ctl->chn_ctl->state == RELAY_CHN_STATE_FORWARD) {
|
|
relay_chn_tilt_issue_cmd(tilt_ctl, RELAY_CHN_TILT_CMD_FORWARD);
|
|
}
|
|
else if (last_run_cmd == RELAY_CHN_CMD_REVERSE || tilt_ctl->chn_ctl->state == RELAY_CHN_STATE_REVERSE) {
|
|
relay_chn_tilt_issue_cmd(tilt_ctl, RELAY_CHN_TILT_CMD_REVERSE);
|
|
}
|
|
}
|
|
|
|
#if 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 < 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 < RELAY_CHN_COUNT; i++) {
|
|
relay_chn_tilt_ctl_t* tilt_ctl = &tilt_ctls[i];
|
|
relay_chn_tilt_issue_cmd(tilt_ctl, cmd);
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
void relay_chn_tilt_reverse(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_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 < 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);
|
|
}
|
|
}
|
|
|
|
#else // RELAY_CHN_COUNT > 1
|
|
|
|
void relay_chn_tilt_auto()
|
|
{
|
|
relay_chn_tilt_issue_auto(&tilt_ctl);
|
|
}
|
|
|
|
void relay_chn_tilt_forward()
|
|
{
|
|
relay_chn_tilt_issue_cmd(&tilt_ctl, RELAY_CHN_TILT_CMD_FORWARD);
|
|
}
|
|
|
|
void relay_chn_tilt_reverse()
|
|
{
|
|
relay_chn_tilt_issue_cmd(&tilt_ctl, RELAY_CHN_TILT_CMD_REVERSE);
|
|
}
|
|
|
|
void relay_chn_tilt_stop()
|
|
{
|
|
relay_chn_tilt_dispatch_cmd(&tilt_ctl, RELAY_CHN_TILT_CMD_STOP);
|
|
}
|
|
#endif // RELAY_CHN_COUNT > 1
|
|
|
|
static void relay_chn_tilt_set_timing_values(relay_chn_tilt_timing_t *tilt_timing,
|
|
uint8_t sensitivity,
|
|
uint32_t run_time_ms,
|
|
uint32_t pause_time_ms)
|
|
{
|
|
tilt_timing->sensitivity = sensitivity;
|
|
tilt_timing->move_time_ms = run_time_ms;
|
|
tilt_timing->pause_time_ms = pause_time_ms;
|
|
}
|
|
|
|
static void _relay_chn_tilt_sensitivity_set(relay_chn_tilt_ctl_t *tilt_ctl, uint8_t sensitivity)
|
|
{
|
|
if (sensitivity >= 100) {
|
|
relay_chn_tilt_set_timing_values(&tilt_ctl->tilt_timing,
|
|
100,
|
|
RELAY_CHN_TILT_RUN_MAX_MS,
|
|
RELAY_CHN_TILT_PAUSE_MAX_MS);
|
|
}
|
|
else if (sensitivity == 0) {
|
|
relay_chn_tilt_set_timing_values(&tilt_ctl->tilt_timing,
|
|
0,
|
|
RELAY_CHN_TILT_RUN_MIN_MS,
|
|
RELAY_CHN_TILT_PAUSE_MIN_MS);
|
|
}
|
|
else {
|
|
// Compute the new timing values from the sensitivity percent value by using linear interpolation
|
|
uint32_t tilt_run_time_ms = 0, tilt_pause_time_ms = 0;
|
|
tilt_run_time_ms = RELAY_CHN_TILT_RUN_MIN_MS + (sensitivity * (RELAY_CHN_TILT_RUN_MAX_MS - RELAY_CHN_TILT_RUN_MIN_MS) / 100);
|
|
tilt_pause_time_ms = RELAY_CHN_TILT_PAUSE_MIN_MS + (sensitivity * (RELAY_CHN_TILT_PAUSE_MAX_MS - RELAY_CHN_TILT_PAUSE_MIN_MS) / 100);
|
|
|
|
relay_chn_tilt_set_timing_values(&tilt_ctl->tilt_timing,
|
|
sensitivity,
|
|
tilt_run_time_ms,
|
|
tilt_pause_time_ms);
|
|
}
|
|
}
|
|
|
|
#if 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 < RELAY_CHN_COUNT; i++) {
|
|
_relay_chn_tilt_sensitivity_set(&tilt_ctls[i], sensitivity);
|
|
}
|
|
}
|
|
else {
|
|
_relay_chn_tilt_sensitivity_set(&tilt_ctls[chn_id], sensitivity);
|
|
}
|
|
}
|
|
|
|
esp_err_t relay_chn_tilt_get_sensitivity(uint8_t chn_id, uint8_t *sensitivity, size_t length)
|
|
{
|
|
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 < 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;
|
|
}
|
|
|
|
for (int i = 0; i < RELAY_CHN_COUNT; i++) {
|
|
sensitivity[i] = tilt_ctls[i].tilt_timing.sensitivity;
|
|
}
|
|
return ESP_OK;
|
|
}
|
|
*sensitivity = tilt_ctls[chn_id].tilt_timing.sensitivity;
|
|
return ESP_OK;
|
|
}
|
|
|
|
#else
|
|
|
|
void relay_chn_tilt_set_sensitivity(uint8_t sensitivity)
|
|
{
|
|
_relay_chn_tilt_sensitivity_set(&tilt_ctl, sensitivity);
|
|
}
|
|
|
|
uint8_t relay_chn_tilt_get_sensitivity()
|
|
{
|
|
return tilt_ctl.tilt_timing.sensitivity;
|
|
}
|
|
#endif // RELAY_CHN_COUNT > 1
|
|
|
|
void relay_chn_tilt_reset_count(relay_chn_tilt_ctl_t *tilt_ctl)
|
|
{
|
|
tilt_ctl->tilt_counter.tilt_forward_count = 0;
|
|
tilt_ctl->tilt_counter.tilt_reverse_count = 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Update tilt count automatically and return the current value.
|
|
*
|
|
* This helper function updates the relevant tilt count depending on the
|
|
* last run info and helps the tilt module in deciding whether the requested
|
|
* tilt should execute or not.
|
|
* This is useful to control reverse tilting particularly. For example:
|
|
* - If the channel's last run was FORWARD and a TILT_FORWARD is requested,
|
|
* then the tilt counter will count up on the
|
|
* relay_chn_tilt_counter_type::tilt_forward_count and the function will
|
|
* return the actual count.
|
|
* - If the channel's last run was FORWARD and a TILT_REVERSE is requested,
|
|
* then the relay_chn_tilt_counter_type::tilt_forward_count will be checked
|
|
* against zero first, and then it will count down and return the actual count
|
|
* if it is greater than 0, else the function will return 0.
|
|
* - If the tilt command is irrelevant then the function will return 0.
|
|
* - If the last run is irrelevant then the function will return 0.
|
|
*
|
|
* @param tilt_ctl The relay channel handle.
|
|
* @return uint32_t The actual value of the relevant counter.
|
|
* @return 0 if:
|
|
* - related counter is already 0.
|
|
* - tilt command is irrelevant.
|
|
* - last run info is irrelevant.
|
|
*/
|
|
static uint32_t relay_chn_tilt_count_update(relay_chn_tilt_ctl_t *tilt_ctl)
|
|
{
|
|
relay_chn_cmd_t last_run_cmd = relay_chn_run_info_get_last_run_cmd(tilt_ctl->chn_ctl->run_info);
|
|
if (last_run_cmd == RELAY_CHN_CMD_FORWARD) {
|
|
if (tilt_ctl->cmd == RELAY_CHN_TILT_CMD_FORWARD) {
|
|
return ++tilt_ctl->tilt_counter.tilt_forward_count;
|
|
}
|
|
else if (tilt_ctl->cmd == RELAY_CHN_TILT_CMD_REVERSE) {
|
|
if (tilt_ctl->tilt_counter.tilt_forward_count > 0) {
|
|
--tilt_ctl->tilt_counter.tilt_forward_count;
|
|
// Still should do one more move, return non-zero value
|
|
return 1;
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
else {
|
|
relay_chn_tilt_reset_count(tilt_ctl);
|
|
return 0;
|
|
}
|
|
}
|
|
else if (last_run_cmd == RELAY_CHN_CMD_REVERSE) {
|
|
if (tilt_ctl->cmd == RELAY_CHN_TILT_CMD_REVERSE) {
|
|
return ++tilt_ctl->tilt_counter.tilt_reverse_count;
|
|
}
|
|
else if (tilt_ctl->cmd == RELAY_CHN_TILT_CMD_FORWARD) {
|
|
if (tilt_ctl->tilt_counter.tilt_reverse_count > 0) {
|
|
--tilt_ctl->tilt_counter.tilt_reverse_count;
|
|
// Still should do one more move, return non-zero value
|
|
return 1;
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
else {
|
|
relay_chn_tilt_reset_count(tilt_ctl);
|
|
return 0;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void relay_chn_tilt_execute_stop(relay_chn_tilt_ctl_t *tilt_ctl)
|
|
{
|
|
// Stop the channel's timer if active
|
|
esp_timer_stop(tilt_ctl->tilt_timer);
|
|
// Invalidate tilt cmd and step
|
|
tilt_ctl->cmd = RELAY_CHN_TILT_CMD_NONE;
|
|
tilt_ctl->step = RELAY_CHN_TILT_STEP_NONE;
|
|
// Stop the channel
|
|
if (relay_chn_output_stop(tilt_ctl->chn_ctl->output) != ESP_OK) {
|
|
ESP_LOGE(TAG, "relay_chn_tilt_execute_stop: Failed to output stop for relay channel #%d!", tilt_ctl->chn_ctl->id);
|
|
}
|
|
relay_chn_dispatch_cmd(tilt_ctl->chn_ctl, RELAY_CHN_CMD_STOP);
|
|
}
|
|
|
|
static void relay_chn_tilt_execute_forward(relay_chn_tilt_ctl_t *tilt_ctl)
|
|
{
|
|
if (relay_chn_output_reverse(tilt_ctl->chn_ctl->output) != ESP_OK) {
|
|
ESP_LOGE(TAG, "relay_chn_tilt_execute_forward: Failed to output reverse for relay channel #%d!", tilt_ctl->chn_ctl->id);
|
|
// Stop tilting because of the error
|
|
relay_chn_tilt_dispatch_cmd(tilt_ctl, RELAY_CHN_TILT_CMD_STOP);
|
|
return;
|
|
}
|
|
// Set the move time timer
|
|
relay_chn_start_esp_timer_once(tilt_ctl->tilt_timer, tilt_ctl->tilt_timing.move_time_ms);
|
|
// Set to pause step
|
|
tilt_ctl->step = RELAY_CHN_TILT_STEP_PAUSE;
|
|
}
|
|
|
|
static void relay_chn_tilt_execute_reverse(relay_chn_tilt_ctl_t *tilt_ctl)
|
|
{
|
|
if (relay_chn_output_forward(tilt_ctl->chn_ctl->output) != ESP_OK) {
|
|
ESP_LOGE(TAG, "relay_chn_tilt_execute_reverse: Failed to output forward for relay channel #%d!", tilt_ctl->chn_ctl->id);
|
|
// Stop tilting because of the error
|
|
relay_chn_tilt_dispatch_cmd(tilt_ctl, RELAY_CHN_TILT_CMD_STOP);
|
|
return;
|
|
}
|
|
// Set the move time timer
|
|
relay_chn_start_esp_timer_once(tilt_ctl->tilt_timer, tilt_ctl->tilt_timing.move_time_ms);
|
|
// Set to pause step
|
|
tilt_ctl->step = RELAY_CHN_TILT_STEP_PAUSE;
|
|
}
|
|
|
|
static void relay_chn_tilt_execute_pause(relay_chn_tilt_ctl_t *tilt_ctl)
|
|
{
|
|
// Pause the channel
|
|
if (relay_chn_output_stop(tilt_ctl->chn_ctl->output) != ESP_OK) {
|
|
ESP_LOGE(TAG, "relay_chn_tilt_execute_pause: Failed to output stop for relay channel #%d!", tilt_ctl->chn_ctl->id);
|
|
// Stop tilting because of the error
|
|
relay_chn_tilt_dispatch_cmd(tilt_ctl, RELAY_CHN_TILT_CMD_STOP);
|
|
return;
|
|
}
|
|
|
|
// Update the tilt counter before the next move and expect the return value to be greater than 0
|
|
if (relay_chn_tilt_count_update(tilt_ctl) == 0) {
|
|
ESP_LOGD(TAG, "relay_chn_tilt_execute_pause: Relay channel cannot tilt anymore");
|
|
// Stop tilting since the tilting limit has been reached
|
|
relay_chn_tilt_dispatch_cmd(tilt_ctl, RELAY_CHN_TILT_CMD_STOP);
|
|
return;
|
|
}
|
|
|
|
// Set the pause time timer
|
|
relay_chn_start_esp_timer_once(tilt_ctl->tilt_timer, tilt_ctl->tilt_timing.pause_time_ms);
|
|
// Set to move step
|
|
tilt_ctl->step = RELAY_CHN_TILT_STEP_MOVE;
|
|
}
|
|
|
|
static void relay_chn_tilt_event_handler(void *handler_arg, esp_event_base_t event_base, int32_t event_id, void *event_data)
|
|
{
|
|
relay_chn_tilt_ctl_t* tilt_ctl = *(relay_chn_tilt_ctl_t**) event_data;
|
|
ESP_RETURN_VOID_ON_FALSE(tilt_ctl != NULL, TAG, "event_data is NULL");
|
|
ESP_LOGD(TAG, "relay_chn_event_handler: Command: %s", relay_chn_cmd_str(event_id));
|
|
|
|
switch(event_id) {
|
|
case RELAY_CHN_TILT_CMD_STOP:
|
|
relay_chn_tilt_execute_stop(tilt_ctl);
|
|
break;
|
|
case RELAY_CHN_TILT_CMD_FORWARD:
|
|
relay_chn_tilt_execute_forward(tilt_ctl);
|
|
// Update channel state
|
|
relay_chn_update_state(tilt_ctl->chn_ctl, RELAY_CHN_STATE_TILT_FORWARD);
|
|
break;
|
|
case RELAY_CHN_TILT_CMD_REVERSE:
|
|
relay_chn_tilt_execute_reverse(tilt_ctl);
|
|
// Update channel state
|
|
relay_chn_update_state(tilt_ctl->chn_ctl, RELAY_CHN_STATE_TILT_REVERSE);
|
|
break;
|
|
default:
|
|
ESP_LOGW(TAG, "Unexpected relay channel tilt command: %ld!", event_id);
|
|
}
|
|
}
|
|
|
|
// Timer callback for the relay_chn_tilt_control_t::tilt_timer
|
|
static void relay_chn_tilt_timer_cb(void *arg)
|
|
{
|
|
relay_chn_tilt_ctl_t* tilt_ctl = (relay_chn_tilt_ctl_t*) arg;
|
|
ESP_RETURN_VOID_ON_FALSE(tilt_ctl != NULL, TAG, "relay_chn_tilt_timer_cb: event_data is NULL");
|
|
|
|
switch (tilt_ctl->step)
|
|
{
|
|
case RELAY_CHN_TILT_STEP_MOVE:
|
|
if (tilt_ctl->cmd == RELAY_CHN_TILT_CMD_FORWARD) {
|
|
relay_chn_tilt_execute_forward(tilt_ctl);
|
|
}
|
|
else if (tilt_ctl->cmd == RELAY_CHN_TILT_CMD_REVERSE) {
|
|
relay_chn_tilt_execute_reverse(tilt_ctl);
|
|
}
|
|
break;
|
|
|
|
case RELAY_CHN_TILT_STEP_PAUSE:
|
|
relay_chn_tilt_execute_pause(tilt_ctl);
|
|
break;
|
|
|
|
case RELAY_CHN_TILT_STEP_PENDING:
|
|
// Just dispatch the pending tilt command
|
|
relay_chn_tilt_dispatch_cmd(tilt_ctl, tilt_ctl->cmd);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
esp_err_t relay_chn_tilt_ctl_init(relay_chn_tilt_ctl_t *tilt_ctl, relay_chn_ctl_t *chn_ctl)
|
|
{
|
|
tilt_ctl->cmd = RELAY_CHN_TILT_CMD_NONE;
|
|
tilt_ctl->step = RELAY_CHN_TILT_STEP_NONE;
|
|
tilt_ctl->tilt_timing.sensitivity = RELAY_CHN_TILT_DEFAULT_SENSITIVITY;
|
|
tilt_ctl->tilt_timing.move_time_ms = RELAY_CHN_TILT_DEFAULT_RUN_MS;
|
|
tilt_ctl->tilt_timing.pause_time_ms = RELAY_CHN_TILT_DEFAULT_PAUSE_MS;
|
|
relay_chn_tilt_reset_count(tilt_ctl);
|
|
|
|
tilt_ctl->chn_ctl = chn_ctl;
|
|
tilt_ctl->chn_ctl->tilt_ctl = tilt_ctl; //
|
|
|
|
// Create tilt timer for the channel
|
|
char timer_name[32];
|
|
snprintf(timer_name, sizeof(timer_name), "relay_chn_%2d_tilt_timer", chn_ctl->id);
|
|
esp_timer_create_args_t timer_args = {
|
|
.callback = relay_chn_tilt_timer_cb,
|
|
.arg = tilt_ctl,
|
|
.name = timer_name
|
|
};
|
|
return esp_timer_create(&timer_args, &tilt_ctl->tilt_timer);
|
|
}
|
|
|
|
esp_err_t relay_chn_tilt_init(relay_chn_ctl_t *chn_ctls)
|
|
{
|
|
#if RELAY_CHN_COUNT > 1
|
|
for (int i = 0; i < RELAY_CHN_COUNT; i++) {
|
|
relay_chn_tilt_ctl_init(&tilt_ctls[i], &chn_ctls[i]);
|
|
}
|
|
#else
|
|
relay_chn_tilt_ctl_init(&tilt_ctl, chn_ctls);
|
|
#endif // RELAY_CHN_COUNT > 1
|
|
|
|
return esp_event_handler_register_with(relay_chn_event_loop,
|
|
RELAY_CHN_TILT_CMD_EVENT_BASE,
|
|
ESP_EVENT_ANY_ID,
|
|
relay_chn_tilt_event_handler, NULL);
|
|
}
|
|
|
|
void relay_chn_tilt_ctl_deinit(relay_chn_tilt_ctl_t *tilt_ctl)
|
|
{
|
|
if (tilt_ctl->tilt_timer != NULL) {
|
|
esp_timer_delete(tilt_ctl->tilt_timer);
|
|
tilt_ctl->tilt_timer = NULL;
|
|
}
|
|
}
|
|
|
|
void relay_chn_tilt_deinit()
|
|
{
|
|
#if RELAY_CHN_COUNT > 1
|
|
for (int i = 0; i < RELAY_CHN_COUNT; i++) {
|
|
relay_chn_tilt_ctl_deinit(&tilt_ctls[i]);
|
|
}
|
|
#else
|
|
relay_chn_tilt_ctl_deinit(&tilt_ctl);
|
|
#endif // RELAY_CHN_COUNT > 1
|
|
esp_event_handler_unregister_with(relay_chn_event_loop,
|
|
RELAY_CHN_TILT_CMD_EVENT_BASE,
|
|
ESP_EVENT_ANY_ID,
|
|
relay_chn_tilt_event_handler);
|
|
} |