meshx_control_task.c File Reference

Implementation of control task for event handling and messaging. More...

#include <meshx_control_task.h>

Macros
#define	CONFIG_CT_DEBUG_LOG   0

Functions
static void	control_task_handler (void *args)
	Task handler function for processing control task messages.
static meshx_err_t	create_control_task_msg_q (void)
	Create the control task message queue.
meshx_err_t	control_task_init (void)
	Initialize the control task messaging system.
meshx_err_t	create_control_task (dev_struct_t *pdev)
	Create the control task.
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)
	Publish a control task message.
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)
	Subscribe to a control task message.
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)
	Deregister a callback for a specific message code and event bitmap.
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, const void *params)
	Dispatch a message to the registered callbacks.

Variables
static meshx_msg_q_t	control_task_queue
	Queue handle for control task messages.
static control_task_evt_cb_reg_t *	control_task_msg_code_list_heads [CONTROL_TASK_MSG_CODE_MAX]
	Linked list heads for registered callbacks per message code.

Detailed Description

Implementation of control task for event handling and messaging.

Copyright © 2024 - 2025 MeshX

This file contains the implementation of a control task, including functions for creating the task, sending messages, registering message handlers, and handling events. The control task uses FreeRTOS for inter-task communication and event-driven architecture.

Author

Pranjal Chanda

Macro Definition Documentation

CONFIG_CT_DEBUG_LOG

#define CONFIG_CT_DEBUG_LOG   0

Function Documentation

control_task_handler()

void control_task_handler ( void * args )

static

Task handler function for processing control task messages.

This function runs in a loop, receiving messages from the queue and dispatching them to registered handlers. Allocated memory for message parameters is freed after processing.

Parameters

[in]

args

Pointer to the device structure (dev_struct_t) passed during task creation.

{
    meshx_err_t err;
    static control_task_msg_t recv_msg;
    dev_struct_t *pdev = (dev_struct_t *)args;
 
    MESHX_LOGD(MODULE_ID_COMMON, "Control Task Initialised");
    MESHX_UNUSED(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);
            }
        }
    }
}

control_task_init()

meshx_err_t control_task_init

(

void

)

Initialize the control task messaging system.

This function initializes the message queue used by the control task. It must be called before any component attempts to publish messages.

Returns

MESHX_SUCCESS on success, or an error code on failure.

{
    return create_control_task_msg_q();
}

control_task_msg_dispatch()

meshx_err_t control_task_msg_dispatch ( dev_struct_t * pdev, control_task_msg_code_t msg_code, control_task_msg_evt_t evt, const void * params )

static

Dispatch a message to the registered callbacks.

This function dispatches a message to the registered handlers based on the message code and event type.

Parameters

[in]	pdev	Pointer to the device structure (dev_struct_t).
[in]	msg_code	The message code of the received message.
[in]	evt	The event type of the received message.
[in]	params	Pointer to the message parameters.

Returns

MESHX_SUCCESS on success, or an error code on failure.

{
    if (!pdev || msg_code >= CONTROL_TASK_MSG_CODE_MAX)
        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;
    }
 
#if CONFIG_CT_DEBUG_LOG
    MESHX_LOGD(MODULE_ID_COMMON, "msg|evt: %p|%p", (void *)msg_code, (void *)evt);
#endif /* CONFIG_CT_DEBUG_LOG */
 
    while (ptr)
    {
        bool is_match = false;
        if (msg_code == CONTROL_TASK_MSG_CODE_FRM_BLE)
        {
            /* For messages from BLE, the event is the Model ID (value), not a bitmap */
            is_match = (evt == ptr->msg_evt_bmap);
        }
        else
        {
            /* Other codes use bitmaps or 0x00 as wildcard */
            is_match = ((evt == 0x00) || (evt & ptr->msg_evt_bmap));
        }
 
        if (is_match && (ptr->cb != NULL))
        {
            ptr->cb(pdev, evt, (void*)params); // Call the registered callback
            evt_handled = true;
        }
        ptr = ptr->next;
    }
    if (!evt_handled)
        MESHX_LOGW(MODULE_ID_COMMON, "No handler reg for EVT %p", (void *)evt);
 
    return MESHX_SUCCESS;
}

control_task_msg_publish()

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 )

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.

Parameters

[in]	msg_code	The message code to publish.
[in]	msg_evt	The event associated with the message.
[in]	msg_evt_params	Pointer to the event parameters.
[in]	sizeof_msg_evt_params	Size of the event parameters.

Returns

MESHX_SUCCESS on success, or an error code on failure.

{
    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_CT_DEBUG_LOG
#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);
#endif /* CONFIG_CT_DEBUG_LOG */
 
    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;
}

control_task_msg_subscribe()

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 )

Subscribe to a control task message.

This function allows you to subscribe to a specific control task message identified by the given message code. When the message is received, the specified callback function will be invoked.

Parameters

[in]	msg_code	The message code to subscribe to.
[in]	evt_bmap	The event bitmap associated with the message.
[in]	callback	The callback function to be called when the message is received.

Returns

• MESHX_SUCCESS: Success
• MESHX_INVALID_ARG: Invalid argument
• MESHX_FAIL: Other failures

{
    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;
}

control_task_msg_unsubscribe()

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 )

Deregister a callback for a specific message code and event bitmap.

This function allows deregistering a callback handler for a specific message code and event type.

Parameters

[in]	msg_code	The message code to deregister the handler for.
[in]	evt_bmap	Bitmap of events to deregister for.
[in]	callback	Callback function to deregister.

Returns

MESHX_SUCCESS on success, or an error code on failure.

{
    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;
}

create_control_task()

meshx_err_t create_control_task

(

dev_struct_t *

pdev

)

Create the control task.

This function creates a FreeRTOS task to handle control events.

Parameters

[in]

pdev

Pointer to the device structure (dev_struct_t).

Returns

MESHX_SUCCESS on success, or an error code on failure.

{
 
    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);
}

create_control_task_msg_q()

meshx_err_t create_control_task_msg_q ( void )

static

Create the control task message queue.

This function initializes the FreeRTOS queue for handling control task messages.

Returns

MESHX_SUCCESS on success, or an error code on failure.

{
    return meshx_msg_q_create(&control_task_queue);
}

Variable Documentation

control_task_msg_code_list_heads

control_task_evt_cb_reg_t* control_task_msg_code_list_heads[CONTROL_TASK_MSG_CODE_MAX]

static

Linked list heads for registered callbacks per message code.

control_task_queue

meshx_msg_q_t control_task_queue

static

Initial value:

                                        =
{
    .max_msg_length = 10 ,
    .max_msg_depth  = sizeof(control_task_msg_t)
}

Queue handle for control task messages.

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