meshx_light_cwww_client.c File Reference

Implementation of the CW-WW (Cool White - Warm White) client model for BLE Mesh. More...

#include "meshx_common.h"
#include "meshx_control_task.h"
#include "meshx_nvs.h"
#include "meshx_api.h"
#include "meshx_light_cwww_client_element.h"
#include "meshx_config_server.h"

Include dependency graph for meshx_light_cwww_client.c:

Go to the source code of this file.

Macros
#define	CONFIG_SERVER_CB_MASK
	Configuration server callback event mask for cwww server.
#define	MOD_LCC   MODULE_ID_ELEMENT_LIGHT_CWWWW_CLIENT
#define	CWWW_CLI_MESHX_ONOFF_ENABLE_CB   true
#define	CWWW_CLI_EL_STATE_CH_EVT_MASK   CONTROL_TASK_MSG_EVT_EL_STATE_CH_SET_ON_OFF | CONTROL_TASK_MSG_EVT_EL_STATE_CH_SET_CTL
#define	IS_EL_IN_RANGE(_element_id)
#define	GET_RELATIVE_EL_IDX(_element_id)
#define	CWWW_CLI_EL(_el_id)

Functions
static meshx_err_t	meshx_element_struct_init (uint16_t n_max)
	Initializes the CW-WW client model.
static meshx_err_t	meshx_element_struct_deinit (uint16_t n_max)
	Deinitializes the CW-WW client model.
static meshx_err_t	meshx_dev_create_cwww_model_space (dev_struct_t const *pdev, uint16_t n_max)
	Creates a CW-WW model space for the given device.
static meshx_err_t	meshx_add_cwww_cli_model_to_element_list (dev_struct_t *pdev, uint16_t *start_idx, uint16_t n_max)
	This function adds the CW-WW client models to the element list of the specified device. It initializes the necessary structures and configurations for each model.
static meshx_err_t	meshx_cwww_cli_reg_app_req_cb ()
	Registers a callback handler for CW-WW application requests.
static meshx_err_t	meshx_cwww_cli_el_state_change_reg_cb ()
meshx_err_t	meshx_cwww_el_get_state (uint16_t element_id, cwww_cli_sig_id_t model_id)
	Retrieves the current state of the CW/WW (Cool White/Warm White) light element for the specified element ID.
meshx_err_t	create_cwww_client_elements (dev_struct_t *pdev, uint16_t element_cnt)
	Create Dynamic CW-WW Model Elements.
	REG_MESHX_ELEMENT_FN (cwww_cli_el, MESHX_ELEMENT_TYPE_LIGHT_CWWW_CLIENT, create_cwww_client_elements)

Variables
static meshx_cwww_client_elements_ctrl_t	cwww_client_element_init_ctrl

Detailed Description

Implementation of the CW-WW (Cool White - Warm White) client model for BLE Mesh.

Copyright © 2024 - 2025 MeshX

This file contains the implementation of the CW-WW client model, including initialization, configuration, and message handling functions. The CW-WW client model is used to control and manage CW-WW lighting devices in a BLE Mesh network.

Note

This implementation supports configuration server callbacks and generic client callbacks. It also includes functions to create and add CW-WW client models to the device's element list.

The CW-WW client model supports the following features:

• Initialization and allocation of resources for CW-WW models.
• Handling of configuration server events such as model publication and application key binding.
• Handling of generic client callback events for CW-WW models.
• Sending CW-WW messages to the server.

Author

Pranjal Chanda

Definition in file meshx_light_cwww_client.c.

Macro Definition Documentation

CONFIG_SERVER_CB_MASK

#define CONFIG_SERVER_CB_MASK

Value:

        CONTROL_TASK_MSG_EVT_PUB_ADD \
    |   CONTROL_TASK_MSG_EVT_SUB_ADD \
    |   CONTROL_TASK_MSG_EVT_APP_KEY_BIND

Configuration server callback event mask for cwww server.

Definition at line 38 of file meshx_light_cwww_client.c.

#define CONFIG_SERVER_CB_MASK        \
        CONTROL_TASK_MSG_EVT_PUB_ADD \
    |   CONTROL_TASK_MSG_EVT_SUB_ADD \
    |   CONTROL_TASK_MSG_EVT_APP_KEY_BIND

CWWW_CLI_EL

#define CWWW_CLI_EL

(

_el_id

)

Value:

cwww_client_element_init_ctrl.el_list[_el_id]

Definition at line 59 of file meshx_light_cwww_client.c.

CWWW_CLI_EL_STATE_CH_EVT_MASK

#define CWWW_CLI_EL_STATE_CH_EVT_MASK   CONTROL_TASK_MSG_EVT_EL_STATE_CH_SET_ON_OFF | CONTROL_TASK_MSG_EVT_EL_STATE_CH_SET_CTL

Definition at line 55 of file meshx_light_cwww_client.c.

CWWW_CLI_MESHX_ONOFF_ENABLE_CB

#define CWWW_CLI_MESHX_ONOFF_ENABLE_CB   true

Definition at line 54 of file meshx_light_cwww_client.c.

GET_RELATIVE_EL_IDX

#define GET_RELATIVE_EL_IDX

(

_element_id

)

Value:

((_element_id) - cwww_client_element_init_ctrl.element_id_start)

Definition at line 58 of file meshx_light_cwww_client.c.

IS_EL_IN_RANGE

#define IS_EL_IN_RANGE

(

_element_id

)

Value:

((_element_id) >= cwww_client_element_init_ctrl.element_id_start && (_element_id) < cwww_client_element_init_ctrl.element_id_end)

Definition at line 57 of file meshx_light_cwww_client.c.

MOD_LCC

#define MOD_LCC   MODULE_ID_ELEMENT_LIGHT_CWWWW_CLIENT

Definition at line 53 of file meshx_light_cwww_client.c.

Function Documentation

create_cwww_client_elements()

meshx_err_t create_cwww_client_elements	(	dev_struct_t *	pdev,
		uint16_t	element_cnt )

Create Dynamic CW-WW Model Elements.

Parameters

[in]	pdev	Pointer to device structure
[in]	element_cnt	Maximum number of CW-WW models

Returns

meshx_err_t

Definition at line 998 of file meshx_light_cwww_client.c.

{
    meshx_err_t err;
 
    err = meshx_dev_create_cwww_model_space(pdev, element_cnt);
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "CWWW Model space create failed: (%d)", err);
        return err;
    }
 
    err = meshx_add_cwww_cli_model_to_element_list(pdev, (uint16_t *)&pdev->element_idx, element_cnt);
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "CWWW Model add to element create failed: (%d)", err);
        return err;
    }
 
    err = meshx_on_off_client_init();
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "meshx_onoff_client_init failed: (%d)", err);
        return err;
    }
 
    err = meshx_light_ctl_client_init();
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "meshx_light_ctl_client_init failed: (%d)", err);
        return err;
    }
 
#if CONFIG_ENABLE_CONFIG_SERVER
    err = meshx_config_server_cb_reg(
        (config_srv_cb_t) &cwww_client_config_srv_cb,
        CONFIG_SERVER_CB_MASK);
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "Light CWWW config server callback reg failed: (%d)", err);
        return err;
    }
#endif /* CONFIG_ENABLE_CONFIG_SERVER */
 
#if defined(__MESHX_CONTROL_TASK__)
    /* Register control task callback */
    err = meshx_cwww_cli_reg_app_req_cb();
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "control task callback reg failed: (%d)", err);
        return err;
    }
    /* Register element state change callback */
    err = meshx_cwww_cli_el_state_change_reg_cb();
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "element state change callback reg failed: (%d)", err);
        return err;
    }
    /* Register freshboot control task callback */
    err = meshx_prov_srv_reg_el_client_cb(
        (prov_srv_cb_t)&cwww_cli_prov_srv_msg_handle);
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "control task callback reg failed: (%d)", err);
        return err;
    }
 
#endif /* __MESHX_CONTROL_TASK__ */
#if CONFIG_ENABLE_UNIT_TEST
    err = register_unit_test(MODULE_ID_ELEMENT_LIGHT_CWWWW_CLIENT, &cwww_cli_unit_test_cb_handler);
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "unit_test reg failed: (%d)", err);
        return err;
    }
#endif /* CONFIG_ENABLE_UNIT_TEST */
 
    return MESHX_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

meshx_add_cwww_cli_model_to_element_list()

static meshx_err_t meshx_add_cwww_cli_model_to_element_list ( dev_struct_t * pdev, uint16_t * start_idx, uint16_t n_max )

static

This function adds the CW-WW client models to the element list of the specified device. It initializes the necessary structures and configurations for each model.

Parameters

[in]	pdev	Pointer to the device structure.
[in]	start_idx	Pointer to the element index.
[in]	n_max	Maximum number of elements that can be created in the model space.

Returns

• MESHX_SUCCESS: Success
• MESHX_NO_MEM: Memory allocation failure
• MESHX_INVALID_ARG: Invalid arguments

Definition at line 854 of file meshx_light_cwww_client.c.

{
    if (!pdev || !start_idx || !n_max)
        return MESHX_INVALID_ARG;
 
    if ((n_max + *start_idx) > CONFIG_MAX_ELEMENT_COUNT)
    {
        MESHX_LOGE(MOD_LCC, "No of elements limit reached");
        return MESHX_NO_MEM;
    }
    meshx_err_t err = MESHX_SUCCESS;
 
    cwww_client_element_init_ctrl.element_id_start = *start_idx;
 
    for (uint16_t i = *start_idx; i < (n_max + *start_idx) && (i - *start_idx) < CWWW_CLI_MODEL_SIG_CNT; i++)
    {
        if (i == 0)
            continue;
        err = meshx_plat_add_element_to_composition(
            i,
            pdev->elements,
            CWWW_CLI_EL(i - *start_idx).cwww_cli_sig_model_list,
            NULL,
            CWWW_CLI_MODEL_SIG_CNT,
            CWWW_CLI_MODEL_VEN_CNT);
        if (err)
        {
            MESHX_LOGE(MOD_LCC, "Failed to add element to composition: (%d)", err);
            return err;
        }
        err = meshx_nvs_element_ctx_get(i,
                                        CWWW_CLI_EL(i - *start_idx).cwww_cli_ctx,
                                        sizeof(meshx_cwww_client_model_ctx_t));
        if (err != MESHX_SUCCESS)
        {
            MESHX_LOGW(MOD_LCC, "Failed to get cwww cli element context: (0x%x)", err);
        }
    }
    /* Increment the index for further registrations */
    cwww_client_element_init_ctrl.element_id_end = *start_idx += n_max;
    return MESHX_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

meshx_cwww_cli_el_state_change_reg_cb()

static meshx_err_t meshx_cwww_cli_el_state_change_reg_cb ( )

static

Definition at line 913 of file meshx_light_cwww_client.c.

{
    return control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_EL_STATE_CH,
        CWWW_CLI_EL_STATE_CH_EVT_MASK,
        (control_task_msg_handle_t)&meshx_cwww_client_element_state_change_handler
    );
}

Here is the call graph for this function:

Here is the caller graph for this function:

meshx_cwww_cli_reg_app_req_cb()

static meshx_err_t meshx_cwww_cli_reg_app_req_cb ( )

static

Registers a callback handler for CW-WW application requests.

This function subscribes the provided callback to control task messages related to BLE events. It ensures the callback is valid before subscribing.

Definition at line 904 of file meshx_light_cwww_client.c.

{
    return control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_TO_BLE,
        CONTROL_TASK_MSG_CODE_EVT_MASK,
        (control_task_msg_handle_t)&meshx_cwww_client_element_to_ble_handler
    );
}

Here is the call graph for this function:

Here is the caller graph for this function:

meshx_cwww_el_get_state()

meshx_err_t meshx_cwww_el_get_state	(	uint16_t	element_id,
		cwww_cli_sig_id_t	model_id )

Retrieves the current state of the CW/WW (Cool White/Warm White) light element for the specified element ID.

This function queries the state of a light element identified by the given element_id.

Parameters

[in]	element_id	The unique identifier of the light element whose state is to be retrieved.
[in]	model_id	The model ID to specify which model's state to retrieve. If set to CWWW_CLI_SIG_ID_MAX, it retrieves the state for all models.

Returns

meshx_err_t Returns MESHX_OK on success, or an appropriate error code on failure.

Definition at line 931 of file meshx_light_cwww_client.c.

{
    if (!IS_EL_IN_RANGE(element_id))
    {
        MESHX_LOGE(MOD_LCC, "Invalid element id: %d", element_id);
        return MESHX_INVALID_ARG;
    }
    meshx_cwww_client_msg_t msg = {0};
    msg.ack = CWWW_CLI_MSG_ACK;
    msg.set_get = CWWW_CLI_MSG_GET;
    msg.element_id = element_id;
 
    if (model_id != CWWW_CLI_SIG_ID_MAX)
    {
        MESHX_LOGD(MOD_LCC, "Sending GET for model: %d", model_id);
        if(model_id == CWWW_CLI_SIG_L_CTL_MODEL_ID)
        {
            control_task_msg_publish(
                CONTROL_TASK_MSG_CODE_TO_BLE,
                CONTROL_TASK_MSG_EVT_TO_BLE_SET_CTL,
                &msg,
                sizeof(msg));
        }
        else
        {
            control_task_msg_publish(
                CONTROL_TASK_MSG_CODE_TO_BLE,
                CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF,
                &msg,
                sizeof(msg));
        }
    }
    else
    {
        for(model_id = CWWW_CLI_SIG_ONOFF_MODEL_ID; model_id < CWWW_CLI_SIG_ID_MAX; model_id++)
        {
 
            MESHX_LOGD(MOD_LCC, "Sending GET for model: %d", model_id);
            if(model_id == CWWW_CLI_SIG_L_CTL_MODEL_ID)
            {
                control_task_msg_publish(
                    CONTROL_TASK_MSG_CODE_TO_BLE,
                    CONTROL_TASK_MSG_EVT_TO_BLE_SET_CTL,
                    &msg,
                    sizeof(msg));
            }
            else
            {
                control_task_msg_publish(
                    CONTROL_TASK_MSG_CODE_TO_BLE,
                    CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF,
                    &msg,
                    sizeof(msg));
            }
        }
    }
    return MESHX_SUCCESS;
}

Here is the call graph for this function:

meshx_dev_create_cwww_model_space()

static meshx_err_t meshx_dev_create_cwww_model_space ( dev_struct_t const * pdev, uint16_t n_max )

static

Creates a CW-WW model space for the given device.

This function initializes and allocates resources for a CW-WW (Cool White - Warm White) model space for the specified device. It sets up the necessary structures and configurations to manage the CW-WW model.

Parameters

[in]	pdev	Pointer to the device structure.
[in]	n_max	Maximum number of elements that can be created in the model space.

Returns

• MESHX_SUCCESS: Success
• MESHX_NO_MEM: Memory allocation failure
• MESHX_INVALID_ARG: Invalid arguments

Definition at line 825 of file meshx_light_cwww_client.c.

{
    if (!pdev)
        return MESHX_INVALID_STATE;
 
    meshx_err_t err = meshx_element_struct_init(n_max);
    if (err)
    {
        MESHX_LOGE(MOD_LCC, "Failed to initialize cwww element structures: (%d)", err);
        meshx_element_struct_deinit(n_max);
        return err;
    }
    return MESHX_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

meshx_element_struct_deinit()

static meshx_err_t meshx_element_struct_deinit ( uint16_t n_max )

static

Deinitializes the CW-WW client model.

This function deinitializes the CW-WW client model by freeing the memory allocated for the CW-WW client context, client list, publish list, and CW-WW client model list.

Parameters

[in]

n_max

Maximum number of elements that can be created in the model space.

Definition at line 782 of file meshx_light_cwww_client.c.

{
    if (!cwww_client_element_init_ctrl.element_cnt || !cwww_client_element_init_ctrl.el_list)
    {
        MESHX_LOGE(MOD_LCC, "CWWW element list not initialized");
        return MESHX_INVALID_STATE;
    }
 
    if (cwww_client_element_init_ctrl.el_list)
    {
        for (size_t i = 0; i < n_max; i++)
        {
            if (CWWW_CLI_EL(i).cwww_cli_ctx)
            {
                MESHX_FREE(CWWW_CLI_EL(i).cwww_cli_ctx);
                CWWW_CLI_EL(i).cwww_cli_ctx = NULL;
            }
        }
        MESHX_FREE(cwww_client_element_init_ctrl.el_list);
        cwww_client_element_init_ctrl.el_list = NULL;
    }
    cwww_client_element_init_ctrl.element_cnt = 0;
    cwww_client_element_init_ctrl.element_id_end = 0;
    cwww_client_element_init_ctrl.element_id_start = 0;
 
    return MESHX_SUCCESS;
}

meshx_element_struct_init()

static meshx_err_t meshx_element_struct_init ( uint16_t n_max )

static

Initializes the CW-WW client model.

This function initializes the CW-WW client model by allocating memory for the CW-WW client context, client list, publish list, and CW-WW client model list.

Parameters

[in]

n_max

Maximum number of elements that can be created in the model space.

Returns

• MESHX_SUCCESS: Success
• MESHX_NO_MEM: Memory allocation failure
• MESHX_INVALID_ARG: Invalid arguments

Definition at line 724 of file meshx_light_cwww_client.c.

{
    if(!n_max)
        return MESHX_INVALID_ARG;
 
    meshx_err_t err = MESHX_SUCCESS;
 
    cwww_client_element_init_ctrl.element_cnt = n_max;
    cwww_client_element_init_ctrl.element_id_end = 0;
    cwww_client_element_init_ctrl.element_id_start = 0;
 
    cwww_client_element_init_ctrl.el_list =
        (meshx_cwww_client_elements_t *)MESHX_CALOC(cwww_client_element_init_ctrl.element_cnt, sizeof(meshx_cwww_client_elements_t));
    if (!cwww_client_element_init_ctrl.el_list)
    {
        MESHX_LOGE(MOD_LCC, "Failed to allocate memory for cwww client elements");
        return MESHX_NO_MEM;
    }
 
    for (size_t i = 0; i < cwww_client_element_init_ctrl.element_cnt; i++)
    {
        CWWW_CLI_EL(i).cwww_cli_ctx = (meshx_cwww_client_model_ctx_t *)MESHX_CALOC(n_max, sizeof(meshx_cwww_client_model_ctx_t));
        if (!CWWW_CLI_EL(i).cwww_cli_ctx)
        {
            MESHX_LOGE(MOD_LCC, "Failed to allocate memory for cwww client context");
            return MESHX_NO_MEM;
        }
        err = meshx_on_off_client_create(&CWWW_CLI_EL(i).onoff_cli_model,
                                         &CWWW_CLI_EL(i).cwww_cli_sig_model_list[CWWW_CLI_SIG_ONOFF_MODEL_ID]);
        if (err)
        {
            MESHX_LOGE(MOD_LCC, "Meshx On Off Client create failed (Err : 0x%x)", err);
            return err;
        }
        CWWW_CLI_EL(i).onoff_cli_model->meshx_sig
            = &CWWW_CLI_EL(i).cwww_cli_sig_model_list[CWWW_CLI_SIG_ONOFF_MODEL_ID];
 
        err = meshx_light_ctl_client_create(&CWWW_CLI_EL(i).ctl_cli_model,
                                            &CWWW_CLI_EL(i).cwww_cli_sig_model_list[CWWW_CLI_SIG_L_CTL_MODEL_ID]);
        if (err)
        {
            MESHX_LOGE(MOD_LCC, "Meshx CTL Client create failed (Err : 0x%x)", err);
            return err;
        }
        CWWW_CLI_EL(i).ctl_cli_model->meshx_sig
            = &CWWW_CLI_EL(i).cwww_cli_sig_model_list[CWWW_CLI_SIG_L_CTL_MODEL_ID];
    }
    return MESHX_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

REG_MESHX_ELEMENT_FN()

REG_MESHX_ELEMENT_FN	(	cwww_cli_el	,
		MESHX_ELEMENT_TYPE_LIGHT_CWWW_CLIENT	,
		create_cwww_client_elements	)

Here is the call graph for this function:

Variable Documentation

cwww_client_element_init_ctrl

meshx_cwww_client_elements_ctrl_t cwww_client_element_init_ctrl

static

Definition at line 61 of file meshx_light_cwww_client.c.