relay_chn/include/relay_chn_adapter.h

/*
 * SPDX-FileCopyrightText: 2025 Kozmotronik Tech
 *
 * SPDX-License-Identifier: MIT
 * 
 * An adapter header to expose the appropriate API functions to the public API
 * depending on the RELAY_CHN_COUNT value which determines single or multi mode.
 */

#pragma once

#ifdef __cplusplus
extern "C" {
#endif

#if RELAY_CHN_COUNT > 1
/**
 * @brief Get the current state of a relay channel.
 *
 * @param[in] chn_id Channel ID to get state for.
 * @return Current state of the specified channel, or RELAY_CHN_STATE_UNDEFINED if invalid.
 */
extern relay_chn_state_t relay_chn_ctl_get_state(uint8_t chn_id);

/**
 * @brief Get string representation of a relay channel's state.
 *
 * @param[in] chn_id Channel ID to get state string for.
 * @return String representation of channel state, or "UNDEFINED" if invalid.
 */
extern char *relay_chn_ctl_get_state_str(uint8_t chn_id);

/**
 * @brief Run a relay channel in forward direction.
 *
 * @param[in] chn_id Channel ID to run forward, or RELAY_CHN_ID_ALL for all channels.
 */
extern void relay_chn_ctl_run_forward(uint8_t chn_id);

/**
 * @brief Run a relay channel in reverse direction.
 *
 * @param[in] chn_id Channel ID to run reverse, or RELAY_CHN_ID_ALL for all channels.
 */
extern void relay_chn_ctl_run_reverse(uint8_t chn_id);

/**
 * @brief Stop a relay channel.
 *
 * @param[in] chn_id Channel ID to stop, or RELAY_CHN_ID_ALL for all channels.
 */
extern void relay_chn_ctl_stop(uint8_t chn_id);

/**
 * @brief Flip the running direction of a relay channel.
 *
 * @param[in] chn_id Channel ID to flip direction for, or RELAY_CHN_ID_ALL for all channels.
 */
extern void relay_chn_ctl_flip_direction(uint8_t chn_id);

/**
 * @brief Get the current direction of a relay channel.
 *
 * @param[in] chn_id Channel ID to get direction for.
 * @return Current direction of the specified channel, or RELAY_CHN_DIRECTION_DEFAULT if invalid.
 */
extern relay_chn_direction_t relay_chn_ctl_get_direction(uint8_t chn_id);

static inline relay_chn_state_t relay_chn_get_state(uint8_t chn_id)
{
    return relay_chn_ctl_get_state(chn_id);
}

static inline char *relay_chn_get_state_str(uint8_t chn_id)
{
    return relay_chn_ctl_get_state_str(chn_id);
}

static inline void relay_chn_run_forward(uint8_t chn_id)
{
    relay_chn_ctl_run_forward(chn_id);
}

static inline void relay_chn_run_reverse(uint8_t chn_id)
{
    relay_chn_ctl_run_reverse(chn_id);
}

static inline void relay_chn_stop(uint8_t chn_id)
{
    relay_chn_ctl_stop(chn_id);
}

static inline void relay_chn_flip_direction(uint8_t chn_id)
{
    relay_chn_ctl_flip_direction(chn_id);
}

static inline relay_chn_direction_t relay_chn_get_direction(uint8_t chn_id)
{
    return relay_chn_ctl_get_direction(chn_id);
}

#if RELAY_CHN_ENABLE_RUN_LIMIT == 1
/**
 * @brief Get the run limit for the specified channel
 *
 * @param chn_id The ID of the relay channel to query.
 * 
 * @return The run limit value for the relevant channel if the channel ID is valid.
 *         0 if the channel ID is invalid.
 */
extern uint16_t relay_chn_ctl_get_run_limit(uint8_t chn_id);

/**
 * @brief Set the run limit for the specified channel
 *
 * @param chn_id The ID of the relay channel to query.
 * @param time_sec The run limit time in seconds.
 */
extern void relay_chn_ctl_set_run_limit(uint8_t chn_id, uint16_t time_sec);

static inline uint16_t relay_chn_get_run_limit(uint8_t chn_id)
{
    return relay_chn_ctl_get_run_limit(chn_id);
}

static inline void relay_chn_set_run_limit(uint8_t chn_id, uint16_t time_sec)
{
    relay_chn_ctl_set_run_limit(chn_id, time_sec);
}
#endif // RELAY_CHN_ENABLE_RUN_LIMIT == 1

#else

/**
 * @brief Get the current state of the relay channel.
 *
 * @return Current state of the channel.
 */
extern relay_chn_state_t relay_chn_ctl_get_state(void);

/**
 * @brief Get string representation of the relay channel's state.
 *
 * @return String representation of channel state.
 */
extern char *relay_chn_ctl_get_state_str(void);

/**
 * @brief Run the relay channel in forward direction.
 */
extern void relay_chn_ctl_run_forward(void);

/**
 * @brief Run the relay channel in reverse direction.
 */
extern void relay_chn_ctl_run_reverse(void);

/**
 * @brief Stop the relay channel.
 */
extern void relay_chn_ctl_stop(void);

/**
 * @brief Flip the running direction of the relay channel.
 */
extern void relay_chn_ctl_flip_direction(void);

/**
 * @brief Get the current direction of the relay channel.
 *
 * @return Current direction of the channel.
 */
extern relay_chn_direction_t relay_chn_ctl_get_direction(void);

static inline relay_chn_state_t relay_chn_get_state(void)
{
    return relay_chn_ctl_get_state();
}

static inline char *relay_chn_get_state_str(void)
{
    return relay_chn_ctl_get_state_str();
}

static inline void relay_chn_run_forward(void)
{
    relay_chn_ctl_run_forward();
}

static inline void relay_chn_run_reverse(void)
{
    relay_chn_ctl_run_reverse();
}

static inline void relay_chn_stop(void)
{
    relay_chn_ctl_stop();
}

static inline void relay_chn_flip_direction(void)
{
    relay_chn_ctl_flip_direction();
}

static inline relay_chn_direction_t relay_chn_get_direction(void)
{
    return relay_chn_ctl_get_direction();
}

#if RELAY_CHN_ENABLE_RUN_LIMIT == 1
/**
 * @brief Get the run limit for the channel
 * 
 * @return The run limit value for the channel.
 */
extern uint16_t relay_chn_ctl_get_run_limit(void);

/**
 * @brief Set the run limit for the channel
 *
 * @param time_sec The run limit time in seconds.
 */
extern void relay_chn_ctl_set_run_limit(uint16_t time_sec);

static inline uint16_t relay_chn_get_run_limit(void)
{
    return relay_chn_ctl_get_run_limit();
}

static inline void relay_chn_set_run_limit(uint16_t time_sec)
{
    relay_chn_ctl_set_run_limit(time_sec);
}
#endif // RELAY_CHN_ENABLE_RUN_LIMIT == 1

#endif // RELAY_CHN_COUNT > 1

#ifdef __cplusplus
}
#endif