meshx_os_timer.c

Go to the documentation of this file.

 
#include "meshx_os_timer.h"
 
#define OS_TIMER_INIT_MAGIC 0x3892
#define OS_TIMER_CONTROL_TASK_EVT_MASK (CONTROL_TASK_MSG_EVT_SYSTEM_TIMER_DISARM | \
                                        CONTROL_TASK_MSG_EVT_SYSTEM_TIMER_ARM |    \
                                        CONTROL_TASK_MSG_EVT_SYSTEM_TIMER_REARM |  \
                                        CONTROL_TASK_MSG_EVT_SYSTEM_TIMER_PERIOD | \
                                        CONTROL_TASK_MSG_EVT_SYSTEM_TIMER_FIRE)

SLIST_HEAD(meshx_os_timer_reg_head, meshx_os_timer);

static struct meshx_os_timer_reg_head meshx_os_timer_reg_table_head = SLIST_HEAD_INITIALIZER(os_timer_reg_table_head);
 
#if CONFIG_ENABLE_UNIT_TEST

typedef enum
{
    OS_TIMER_CLI_CMD_CREATE,
    OS_TIMER_CLI_CMD_ARM,
    OS_TIMER_CLI_CMD_REARM,
    OS_TIMER_CLI_CMD_DISARM,
    OS_TIMER_CLI_CMD_DELETE,
    OS_TIMER_CLI_CMD_PERIOD_SET,
    OS_TIMER_CLI_CMD_MAX
} meshx_os_timer_cli_cmd_t;

static void meshx_os_timer_ut_cb_handler(const meshx_os_timer_t *p_timer)
{
    MESHX_LOGI(MODULE_ID_COMPONENT_OS_TIMER, "%s|%ld", OS_TMER_GET_TIMER_NAME(p_timer), p_timer->period);
}

static meshx_err_t meshx_os_timer_unit_test_cb_handler(int cmd_id, int argc, char **argv)
{
    meshx_err_t err = MESHX_SUCCESS;
    meshx_os_timer_cli_cmd_t cmd = (meshx_os_timer_cli_cmd_t)cmd_id;
 
    uint32_t ut_period = 0;
    bool ut_reload = false;
    static meshx_os_timer_t *ut_os_timer;
 
    MESHX_LOGD(MODULE_ID_COMPONENT_OS_TIMER, "argc|cmd_id: %d|%d", argc, cmd_id);
    if (cmd_id >= OS_TIMER_CLI_CMD_MAX)
    {
        MESHX_LOGE(MODULE_ID_COMPONENT_OS_TIMER, "Invalid number of arguments");
        return MESHX_INVALID_ARG;
    }
 
    switch (cmd)
    {
    case OS_TIMER_CLI_CMD_CREATE:
        /* ut 2 0 2 [period_ms] [reload]*/
        ut_period = UT_GET_ARG(0, uint32_t, argv);
        ut_reload = UT_GET_ARG(1, uint32_t, argv) == 0 ? false : true;
        err = meshx_os_timer_create("OS_TIMER_UT", ut_period, ut_reload, meshx_os_timer_ut_cb_handler, &ut_os_timer);
        break;
    case OS_TIMER_CLI_CMD_ARM:
        /* ut 2 1 0 */
        err = meshx_os_timer_start(ut_os_timer);
        break;
    case OS_TIMER_CLI_CMD_REARM:
        /* ut 2 2 0 */
        err = meshx_os_timer_restart(ut_os_timer);
        break;
    case OS_TIMER_CLI_CMD_DISARM:
        /* ut 2 3 0 */
        err = meshx_os_timer_stop(ut_os_timer);
        break;
    case OS_TIMER_CLI_CMD_DELETE:
        /* ut 2 4 0 */
        err = meshx_os_timer_delete(&ut_os_timer);
        break;
    case OS_TIMER_CLI_CMD_PERIOD_SET:
        /* ut 2 5 1 [new period ms] */
        ut_period = UT_GET_ARG(0, uint32_t, argv);
        err = meshx_os_timer_set_period(ut_os_timer, ut_period);
        break;
    default:
        break;
    }
    if (err)
        MESHX_LOGE(MODULE_ID_COMPONENT_OS_TIMER, "err: 0x%x", err);
 
    return err;
}
 
#endif /* CONFIG_ENABLE_UNIT_TEST */
 
/*
 * @brief Callback function for the OS timer to control task.
 *
 * This function is called whenever a OS timer timeout occurs.
 *
 * @param timer_handle  Timer haandle callback param
 */
void meshx_os_timer_fire_cb(const void* timer_handle)
{
    meshx_os_timer_t *msg_params;
    SLIST_FOREACH(msg_params, &meshx_os_timer_reg_table_head, next)
    {
        if (msg_params->timer_handle.__timer_handle == timer_handle)
        {
            control_task_msg_publish(
                CONTROL_TASK_MSG_CODE_SYSTEM,
                CONTROL_TASK_MSG_EVT_SYSTEM_TIMER_FIRE,
                msg_params,
                OS_TIMER_SIZE);
            break;
        }
    }
}
 
/*
 * @brief Callback function for the OS timer control task.
 *
 * This function is called whenever a control task message is received.
 *
 * @param pdev      Pointer to the device structure.
 * @param evt       Event code.
 * @param params    Pointer to the event parameters.
 * @return MESHX_SUCCESS on success, or an error code on failure.
 */
static meshx_err_t meshx_os_timer_control_task_cb(const dev_struct_t *pdev, control_task_msg_evt_t evt, void *params)
{
    meshx_os_timer_t *msg_params = (meshx_os_timer_t *)params;
    meshx_err_t err = MESHX_SUCCESS;
 
    switch (evt)
    {
    case CONTROL_TASK_MSG_EVT_SYSTEM_TIMER_ARM:
        MESHX_LOGD(MODULE_ID_COMPONENT_OS_TIMER, "Starting timer %s", OS_TMER_GET_TIMER_NAME(msg_params));
        err = meshx_rtos_timer_start(&msg_params->timer_handle);
        break;
 
    case CONTROL_TASK_MSG_EVT_SYSTEM_TIMER_REARM:
        MESHX_LOGD(MODULE_ID_COMPONENT_OS_TIMER, "Rearming timer %s", OS_TMER_GET_TIMER_NAME(msg_params));
        err = meshx_rtos_timer_reset(&msg_params->timer_handle);
        break;
 
    case CONTROL_TASK_MSG_EVT_SYSTEM_TIMER_DISARM:
        MESHX_LOGD(MODULE_ID_COMPONENT_OS_TIMER, "Stopping timer %s", OS_TMER_GET_TIMER_NAME(msg_params));
        err = meshx_rtos_timer_stop(&msg_params->timer_handle);
        break;
 
    case CONTROL_TASK_MSG_EVT_SYSTEM_TIMER_PERIOD:
        MESHX_LOGD(MODULE_ID_COMPONENT_OS_TIMER, "Timer %s period set: %ld", OS_TMER_GET_TIMER_NAME(msg_params), msg_params->period);
        err = meshx_rtos_timer_change_period(&msg_params->timer_handle, msg_params->period);
        break;
 
    case CONTROL_TASK_MSG_EVT_SYSTEM_TIMER_FIRE:
        MESHX_LOGD(MODULE_ID_COMPONENT_OS_TIMER, "Timer %s fire", OS_TMER_GET_TIMER_NAME(msg_params));
        /* call respective callback */
        if (msg_params->cb)
            msg_params->cb(msg_params);
        break;
 
    default:
        err = MESHX_INVALID_ARG;
        break;
    }
 
    MESHX_UNUSED(pdev);
 
    return err;
}

meshx_err_t meshx_os_timer_init(void)
{
    meshx_err_t err;
#if CONFIG_ENABLE_UNIT_TEST
    err = register_unit_test(MODULE_ID_COMPONENT_OS_TIMER, &meshx_os_timer_unit_test_cb_handler);
    if (err)
    {
        MESHX_LOGE(MODULE_ID_COMPONENT_OS_TIMER, "unit_test reg failed: (%d)", err);
        return err;
    }
#endif /* CONFIG_ENABLE_UNIT_TEST */
    err = control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_SYSTEM,
        OS_TIMER_CONTROL_TASK_EVT_MASK,
        (control_task_msg_handle_t)&meshx_os_timer_control_task_cb);
 
    return err;
}

meshx_err_t meshx_os_timer_create(
    const char *name,
    uint32_t period,
    bool reload,
    meshx_os_timer_cb_t cb,
    meshx_os_timer_t **timer_handle)
{
    if (timer_handle == NULL)
    {
        return MESHX_INVALID_STATE;
    }
 
    if ((*timer_handle) != NULL && (*timer_handle)->init == OS_TIMER_INIT_MAGIC)
        return MESHX_INVALID_STATE;
 
    meshx_err_t err = MESHX_SUCCESS;
 
    *timer_handle = (meshx_os_timer_t *)MESHX_MALLOC(OS_TIMER_SIZE);
    if (*timer_handle == NULL)
        return MESHX_NO_MEM;
 
    (*timer_handle)->cb = cb;
    (*timer_handle)->period = period;
 
    err = meshx_rtos_timer_create(&(*timer_handle)->timer_handle,
        name,
        (meshx_rtos_timer_callback_t)&meshx_os_timer_fire_cb,
        *timer_handle,
        period,
        reload);
    if (err)
    {
        MESHX_FREE(*timer_handle);
        return err;
    }
 
    SLIST_INSERT_HEAD(&meshx_os_timer_reg_table_head, (*timer_handle), next);
    (*timer_handle)->init = OS_TIMER_INIT_MAGIC;
 
    return err;
}

meshx_err_t meshx_os_timer_start(const meshx_os_timer_t *timer_handle)
{
    if (timer_handle == NULL)
    {
        return MESHX_INVALID_STATE;
    }
    if (timer_handle->init != OS_TIMER_INIT_MAGIC)
        return MESHX_INVALID_STATE;
 
    return control_task_msg_publish(
        CONTROL_TASK_MSG_CODE_SYSTEM,
        CONTROL_TASK_MSG_EVT_SYSTEM_TIMER_ARM,
        timer_handle,
        OS_TIMER_SIZE);
}

meshx_err_t meshx_os_timer_restart(const meshx_os_timer_t *timer_handle)
{
    if (timer_handle == NULL)
    {
        return MESHX_INVALID_STATE;
    }
    if (timer_handle->init != OS_TIMER_INIT_MAGIC)
        return MESHX_INVALID_STATE;
 
    return control_task_msg_publish(
        CONTROL_TASK_MSG_CODE_SYSTEM,
        CONTROL_TASK_MSG_EVT_SYSTEM_TIMER_REARM,
        timer_handle,
        OS_TIMER_SIZE);
}

meshx_err_t meshx_os_timer_set_period(meshx_os_timer_t *timer_handle, const uint32_t period_ms)
{
    if (timer_handle == NULL)
    {
        return MESHX_INVALID_STATE;
    }
    if (timer_handle->init != OS_TIMER_INIT_MAGIC)
        return MESHX_INVALID_STATE;
 
    timer_handle->period = period_ms;
 
    return control_task_msg_publish(
        CONTROL_TASK_MSG_CODE_SYSTEM,
        CONTROL_TASK_MSG_EVT_SYSTEM_TIMER_PERIOD,
        timer_handle,
        OS_TIMER_SIZE);
}

meshx_err_t meshx_os_timer_stop(const meshx_os_timer_t *timer_handle)
{
    if (timer_handle == NULL)
    {
        return MESHX_INVALID_STATE;
    }
    if (timer_handle->init != OS_TIMER_INIT_MAGIC)
        return MESHX_INVALID_STATE;
 
    return control_task_msg_publish(
        CONTROL_TASK_MSG_CODE_SYSTEM,
        CONTROL_TASK_MSG_EVT_SYSTEM_TIMER_DISARM,
        timer_handle,
        OS_TIMER_SIZE);
}

 
meshx_err_t meshx_os_timer_delete(meshx_os_timer_t **timer_handle)
{
    meshx_err_t err;
 
    if (timer_handle == NULL)
    {
        return MESHX_INVALID_STATE;
    }
 
    if (*timer_handle == NULL || (*timer_handle)->init != OS_TIMER_INIT_MAGIC)
        return MESHX_INVALID_STATE;
 
    MESHX_LOGI(MODULE_ID_COMPONENT_OS_TIMER, "Deleting timer %s", OS_TMER_GET_TIMER_NAME((*timer_handle)));
 
    err = meshx_rtos_timer_delete(&(*timer_handle)->timer_handle);
    if (err)
        return err;
 
    (*timer_handle)->init = 0;
 
    SLIST_REMOVE(&meshx_os_timer_reg_table_head, *timer_handle, meshx_os_timer, next);
    MESHX_FREE(*timer_handle);
 
    return MESHX_SUCCESS;
}