meshx_control_task.c

Go to the documentation of this file.

 
#include <meshx_control_task.h>
 
static void control_task_handler(void *args);

static meshx_msg_q_t control_task_queue =
{
    .max_msg_length = CONFIG_CONTROL_TASK_QUEUE_LEN,
    .max_msg_depth  = sizeof(control_task_msg_t)
};

static control_task_evt_cb_reg_t *control_task_msg_code_list_heads[CONTROL_TASK_MSG_CODE_MAX];

meshx_err_t create_control_task(dev_struct_t *pdev)
{
 
    meshx_task_t task_handle = {
        .arg = pdev,
        .task_cb = control_task_handler,
        .priority = CONFIG_CONTROL_TASK_PRIO,
        .task_name = CONFIG_CONTROL_TASK_NAME,
        .stack_size = CONFIG_CONTROL_TASK_STACK_SIZE,
    };
 
    return meshx_task_create(&task_handle);
}
 
/* @brief Publish a control task message.
 *
 * This function allows you to publish a control task message with the given
 * message code, event, and event parameters.
 * The message will be sent to the control task for processing.
 *
 * @param[in] msg_code              The message code to publish.
 * @param[in] msg_evt               The event associated with the message.
 * @param[in] msg_evt_params        Pointer to the event parameters.
 * @param[in] sizeof_msg_evt_params Size of the event parameters.
 * @return MESHX_SUCCESS on success, or an error code on failure.
 */
meshx_err_t control_task_msg_publish(control_task_msg_code_t msg_code,
                                   control_task_msg_evt_t msg_evt,
                                   const void *msg_evt_params,
                                   size_t sizeof_msg_evt_params)
{
    control_task_msg_t send_msg;
    if (msg_code >= CONTROL_TASK_MSG_CODE_MAX)
    {
        MESHX_LOGE(MODULE_ID_COMMON, "Invalid message code or event");
        return MESHX_INVALID_ARG;
    }
#if CONFIG_MESHX_DEFAULT_LOG_LEVEL <= MESHX_LOG_DEBUG
    void *caller_addr0 = __builtin_return_address(0);
#endif /* CONFIG_MESHX_DEFAULT_LOG_LEVEL <= MESHX_LOG_DEBUG */
    MESHX_LOGD(MODULE_ID_COMMON, "fn_address|msg|evt: %p|%p|%p", caller_addr0, (void *)msg_code, (void *)msg_evt);
 
    if (sizeof_msg_evt_params != 0)
    {
        meshx_err_t err = meshx_rtos_malloc(&send_msg.msg_evt_params, sizeof_msg_evt_params);
        if (err)
            return err;
        /* Copy the params to allocated space */
        memcpy(send_msg.msg_evt_params, msg_evt_params, sizeof_msg_evt_params);
    }
    else
    {
        send_msg.msg_evt_params = NULL;
    }
 
    send_msg.msg_code = msg_code;
    send_msg.msg_evt = msg_evt;
 
    meshx_err_t send_err = meshx_msg_q_send(&control_task_queue, &send_msg, sizeof(send_msg), UINT32_MAX);
    if (send_err != MESHX_SUCCESS && send_msg.msg_evt_params)
    {
        meshx_rtos_free(&send_msg.msg_evt_params);
    }
    return send_err;
}

meshx_err_t control_task_msg_subscribe(control_task_msg_code_t msg_code,
                                     control_task_msg_evt_t evt_bmap,
                                     control_task_msg_handle_t callback)
{
    if (callback == NULL || msg_code >= CONTROL_TASK_MSG_CODE_MAX)
        return MESHX_INVALID_ARG; // Invalid arguments
 
    control_task_evt_cb_reg_t *new_node = NULL;
    meshx_err_t err = meshx_rtos_malloc((void**)&new_node, sizeof(control_task_evt_cb_reg_t));
    if (err || !new_node)
        return err; // Memory allocation failed
 
    new_node->cb = callback;
    new_node->msg_evt_bmap = evt_bmap;
    new_node->next = control_task_msg_code_list_heads[msg_code];
    control_task_msg_code_list_heads[msg_code] = new_node;
 
    return MESHX_SUCCESS;
}

meshx_err_t control_task_msg_unsubscribe(control_task_msg_code_t msg_code,
                                       control_task_msg_evt_t evt_bmap,
                                       control_task_msg_handle_t callback)
{
    if (callback == NULL || msg_code >= CONTROL_TASK_MSG_CODE_MAX)
        return MESHX_INVALID_ARG; // Invalid arguments
 
    control_task_evt_cb_reg_t *prev = NULL;
    control_task_evt_cb_reg_t *curr = control_task_msg_code_list_heads[msg_code];
 
    while (curr)
    {
        if (curr->cb == callback && curr->msg_evt_bmap == evt_bmap)
        {
            if (prev == NULL)
                control_task_msg_code_list_heads[msg_code] = curr->next;
            else
                prev->next = curr->next;
 
            return meshx_rtos_free((void**)&curr);
        }
        prev = curr;
        curr = curr->next;
    }
 
    return MESHX_NOT_FOUND;
}

static meshx_err_t control_task_msg_dispatch(
    dev_struct_t *pdev,
    control_task_msg_code_t msg_code,
    control_task_msg_evt_t evt,
    void *params)
{
    if (!pdev)
        return MESHX_INVALID_ARG;
 
    control_task_evt_cb_reg_t *ptr = control_task_msg_code_list_heads[msg_code];
    bool evt_handled = false;
 
    if (ptr == NULL)
    {
        MESHX_LOGW(MODULE_ID_COMMON, "No control task msg callback registered for msg: %p", (void *)msg_code);
        return MESHX_INVALID_STATE;
    }
 
    MESHX_LOGD(MODULE_ID_COMMON, "msg|evt: %p|%p", (void *)msg_code, (void *)evt);
 
    while (ptr)
    {
        if (((evt == 0x00) || (evt & ptr->msg_evt_bmap)) && (ptr->cb != NULL))
        {
            ptr->cb(pdev, evt, params); // Call the registered callback
            evt_handled = true;
        }
        ptr = ptr->next; // Move to the next registration
    }
    if (!evt_handled)
        MESHX_LOGD(MODULE_ID_COMMON, "No handler reg for EVT %p", (void *)evt);
 
    return MESHX_SUCCESS;
}

static meshx_err_t create_control_task_msg_q(void)
{
    return meshx_msg_q_create(&control_task_queue);
}

static void control_task_handler(void *args)
{
    meshx_err_t err;
    static control_task_msg_t recv_msg;
    dev_struct_t *pdev = (dev_struct_t *)args;
 
    MESHX_LOGI(MODULE_ID_COMMON, "Control Task Initialised");
    err = create_control_task_msg_q();
    if (err)
        MESHX_LOGE(MODULE_ID_COMMON, "Failed to initialise Control Task Msg Q Err: 0x%x", err);
 
    while (true)
    {
        if (meshx_msg_q_recv(&control_task_queue, &recv_msg, UINT32_MAX) == MESHX_SUCCESS)
        {
            err = control_task_msg_dispatch(pdev, recv_msg.msg_code, recv_msg.msg_evt, recv_msg.msg_evt_params);
            if (err)
                MESHX_LOGE(MODULE_ID_COMMON, "Err: 0x%x", err);
            if (recv_msg.msg_evt_params)
            {
                /* If Params were passed Free the allocated memory */
                meshx_rtos_free(&recv_msg.msg_evt_params);
            }
        }
    }
}