meshXCWWWClientElement Class Reference

#include <meshx_cwww_element.hpp>

Inheritance diagram for meshXCWWWClientElement:

Public Member Functions
	meshXCWWWClientElement (uint16_t element_idx)
	Constructs a new meshXCWWWClientElement instance. The meshXCWWWClientElement represents a CWWW client element in the MeshX BLE mesh network. It automatically initializes and configures all required SIG models for the CWWW element. The CWWW element combines Generic OnOff and Light CTL client models.
	meshXCWWWClientElement ()=delete
uint8_t	get_onoff ()
meshx_light_ctl_model_state_t &	get_ctl ()
meshx_cwww_cli_el_ctx_t &	get_ctx ()
Public Member Functions inherited from meshXElementClient
	meshXElementClient ()=default
	meshXElementClient (uint16_t element_idx, uint8_t no_of_sig_models=0, uint8_t no_of_ven_models=0)
Public Member Functions inherited from meshXElement< meshx_cli_model_send_param_header_t >
void	set_element_type (meshxElementType_t type)
meshxElementType_t	get_element_type (void) const final
	Get the element type.
void	set_element_variant (meshx_element_type_t variant)
meshx_element_type_t	get_element_variant (void) const final
	Get the element variant.
void	set_no_of_sig_models (uint8_t cnt)
uint8_t	get_no_of_sig_models (void) const final
	Get the number of SIG models supported by the element.
void	set_no_of_ven_models (uint8_t cnt)
uint8_t	get_no_of_ven_models (void) const final
	Get the number of Vendor models supported by the element.
std::vector< std::unique_ptr< meshXModelIF > > &	get_sig_models (void) final
	Get the SIG models vector.
std::vector< std::unique_ptr< meshXModelIF > > &	get_ven_models (void) final
	Get the Vendor models vector.
const char *	get_element_name (void) const override
	Get the name of the element.
void	register_element_ctx (meshx_ptr_t ctx, size_t ctx_size)
	Register element context structure.
meshx_ptr_t	get_element_ctx (void) const override
	Get the element context structure.
size_t	get_element_ctx_size (void) const override
	Get the size of the element context structure.
meshx_err_t	sig_plat_model_array_allocate (void)
	Allocate memory for SIG model platform array.
meshx_err_t	ven_plat_model_array_allocate (void)
	Allocate memory for Vendor model platform array.
std::vector< uint8_t > &	get_sig_model_array (void)
	Get the SIG model array.
std::vector< uint8_t > &	get_ven_model_array (void)
	Get the Vendor model array.
meshx_err_t	add_sig_model (ConstructorsArgs &&... args)
	Add a SIG model to the element.
meshx_err_t	add_ven_model (ConstructorsArgs &&... args)
	Add a Vendor model to the element.
uint8_t	get_sig_model_count (void) const
	Get the number of SIG models currently added to the element.
uint8_t	get_ven_model_count (void) const
	Get the number of Vendor models currently added to the element.
meshx_err_t	add_sig_models (void)
	Add multiple SIG models to the element.
meshx_err_t	add_ven_models (void)
	Add multiple Vendor models to the element.
meshx_err_t	add_models (void)
	Add both SIG and Vendor models to the element.
MESHX_MODEL *	get_sig_plat_model_array (void)
	Get the platform model array for SIG models.
MESHX_MODEL *	get_ven_plat_model_array (void)
	Get the platform model array for Vendor models.
	meshXElement (void)
	Default constructor for meshXElement.
meshx_err_t	initialize (void) override
	Initialize the element.
meshx_err_t	reset (void) override
	Reset the element.
bool	is_initialized (void) const override
	Check if the element is initialized.
meshx_err_t	restore_nvs_context (void) override
	Restore the element's context from NVS.
bool	has_model (uint16_t model_id) const override
	Check if the element contains a specific model by ID.
void	on_baked (uint16_t index) override
	Called when the composition is baked to update the element's index.
	~meshXElement () override
Public Member Functions inherited from meshXElementIF
void	set_element_idx (uint16_t idx)
uint16_t	get_element_idx (void) const
	meshXElementIF ()=delete
	meshXElementIF (uint16_t element_idx)
virtual	~meshXElementIF ()=default

Private Member Functions
uint8_t	list_sig_models () override
	Lists and creates all required SIG models for the element.
uint8_t	list_ven_models () override
	Lists Vendor models for CWWW Client Element (none required).
const char *	get_element_name (void) const override
	Get the name of the element.
meshx_err_t	element_state_change_notify (meshx_ptr_t param, size_t param_size) override
	Notify element of state change from child model.
void	sync (control_task_msg_evt_t evt) override
	Synchronize element state (GET requests).
void	handle_config (control_task_msg_evt_t evt, const meshx_config_srv_cb_param_t *params) override
	Handle configuration server events.

Static Private Member Functions
static meshx_err_t	s_to_ble_cb (const dev_struct_t *pdev, control_task_msg_evt_t evt, const void *params)

Private Attributes
meshx_cwww_cli_el_ctx_t	element_ctx

Additional Inherited Members
Static Public Member Functions inherited from meshXElement< meshx_cli_model_send_param_header_t >
static meshx_err_t	static_prov_srv_cb (const dev_struct_t *pdev, control_task_msg_evt_t evt, const void *params)
	Global static provisioning callback for Server elements.
static meshx_err_t	static_prov_cli_cb (const dev_struct_t *pdev, control_task_msg_evt_t evt, const void *params)
	Global static provisioning callback for Client elements.
static meshx_err_t	static_config_cb (const dev_struct_t *pdev, control_task_msg_evt_t evt, const meshx_config_srv_cb_param_t *params)
	Global static configuration callback.
static void	register_global_callbacks (void)
	Register the global callbacks with the provisioning server.

Constructor & Destructor Documentation

meshXCWWWClientElement() [1/2]

meshXCWWWClientElement::meshXCWWWClientElement ( uint16_t element_idx )

explicit

Constructs a new meshXCWWWClientElement instance. The meshXCWWWClientElement represents a CWWW client element in the MeshX BLE mesh network. It automatically initializes and configures all required SIG models for the CWWW element. The CWWW element combines Generic OnOff and Light CTL client models.

Parameters

element_idx

The index of the element within the node.

    : meshXElementClient(element_idx)
{
    memset(&element_ctx, 0, sizeof(meshx_cwww_cli_el_ctx_t));
    element_ctx.pub_addr = MESHX_ADDR_UNASSIGNED;
 
    /* Restore from NVS if available */
    meshx_nvs_element_ctx_get(element_idx, MESHX_ELEMENT_TYPE_LIGHT_CWWW_CLIENT, &element_ctx, sizeof(meshx_cwww_cli_el_ctx_t));
 
    this->register_element_ctx(&element_ctx, sizeof(meshx_cwww_cli_el_ctx_t));
    this->set_element_variant(MESHX_ELEMENT_TYPE_LIGHT_CWWW_CLIENT);
 
    /* Subscribe to BLE events for this element type */
    control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_TO_BLE,
        CWWW_CLI_TO_BLE_EVT_MASK,
        (control_task_msg_handle_t)&meshXCWWWClientElement::s_to_ble_cb);
 
#if CONFIG_ENABLE_UNIT_TEST
    register_unit_test(MODULE_ID_ELEMENT_LIGHT_CWWW_CLIENT, cwww_cli_ut_handler);
#endif
}

meshXCWWWClientElement() [2/2]

meshXCWWWClientElement::meshXCWWWClientElement ( )

delete

Member Function Documentation

element_state_change_notify()

meshx_err_t meshXCWWWClientElement::element_state_change_notify ( meshx_ptr_t param, size_t param_size )

overrideprivatevirtual

Notify element of state change from child model.

Discriminates ONOFF vs CTL via header->model.model_id. Updates element_ctx and notifies app.

Reimplemented from meshXElement< meshx_cli_model_send_param_header_t >.

{
    if (!param) return MESHX_INVALID_ARG;
 
    auto *header    = static_cast<meshx_cli_model_send_param_header_t *>(param);
    uint16_t el_id  = header->model.el_id;
    uint16_t mid    = header->model.model_id;
    uint16_t func_id = 0;
    meshx_api_light_cwww_client_evt_t app_evt = {};
    app_evt.err_code = header->err_code;
 
    if (mid == MESHX_MODEL_ID_GEN_ONOFF_CLI)
    {
        auto *msg = static_cast<meshx_on_off_cli_el_msg_t *>(param);
        element_ctx.gen_on_off_state.on_off  = msg->state.on_off;
        app_evt.state_change.on_off.state    = msg->state.on_off;
        func_id = MESHX_ELEMENT_FUNC_ID_LIGHT_CWWW_CLIENT_ONN_OFF;
    }
    else if (mid == MESHX_MODEL_ID_LIGHT_CTL_CLI)
    {
        auto *msg = static_cast<meshx_light_ctl_cli_el_msg_t *>(param);
        element_ctx.light_ctl_state = msg->state;
        app_evt.state_change.ctl = {
            .lightness      = msg->state.lightness,
            .temperature    = msg->state.temperature,
            .delta_uv       = (uint16_t)msg->state.delta_uv,
            .temp_range_min = msg->state.temp_range_min,
            .temp_range_max = msg->state.temp_range_max,
        };
        func_id = MESHX_ELEMENT_FUNC_ID_LIGHT_CWWW_CLIENT_CTL;
    }
    else
    {
        return MESHX_INVALID_ARG;
    }
 
    return meshx_send_msg_to_app(el_id, MESHX_ELEMENT_TYPE_LIGHT_CWWW_CLIENT,
                                 func_id, sizeof(app_evt), &app_evt);
}

get_ctl()

meshx_light_ctl_model_state_t & meshXCWWWClientElement::get_ctl ( )

inline

{ return element_ctx.light_ctl_state; }

get_ctx()

meshx_cwww_cli_el_ctx_t & meshXCWWWClientElement::get_ctx ( )

inline

{ return element_ctx; }

get_element_name()

const char * meshXCWWWClientElement::get_element_name ( void ) const

overrideprivatevirtual

Get the name of the element.

Returns

String literal representing the element name.

Implements meshXElementIF.

{
    return "CWWW Client";
}

get_onoff()

uint8_t meshXCWWWClientElement::get_onoff ( )

inline

{ return element_ctx.gen_on_off_state.on_off; }

handle_config()

void meshXCWWWClientElement::handle_config ( control_task_msg_evt_t evt, const meshx_config_srv_cb_param_t * params )

overrideprivatevirtual

Handle configuration server events.

Implements meshXElementIF.

{
    MESHX_LOGD(MODULE_ID_ELEMENT_LIGHT_CWWW_CLIENT, "CWWW Client [%d] Config Evt: %d", get_element_idx(), evt);
}

list_sig_models()

uint8_t meshXCWWWClientElement::list_sig_models ( void )

overrideprivatevirtual

Lists and creates all required SIG models for the element.

This function is responsible for creating and populating the sig_models vector with all essential SIG models that the element must have.

The function can be extended to include additional models based on configuration flags or specific requirements.

Returns

uint8_t The total number of SIG models created and added to the root_sig_models vector

Reimplemented from meshXElement< meshx_cli_model_send_param_header_t >.

{
    auto onoff_model = std::make_unique<meshXGenericOnOffClientModel>(
        this, &element_ctx.gen_on_off_state,
        (uint16_t)static_cast<int>(
            meshxCWWWClientElementComposition::MESHX_CWWW_CLIENT_ELEMENT_COMP_GENERIC_ONOFF_CLIENT));
    this->get_sig_models().push_back(std::move(onoff_model));
 
 
    auto ctl_model = std::make_unique<meshXLightCTLClientModel>(
        this, &element_ctx.light_ctl_state,
        (uint16_t)static_cast<int>(
            meshxCWWWClientElementComposition::MESHX_CWWW_CLIENT_ELEMENT_COMP_LIGHT_CTL_CLIENT));
    this->get_sig_models().push_back(std::move(ctl_model));
 
    return (uint8_t)this->get_sig_models().size();
}

list_ven_models()

uint8_t meshXCWWWClientElement::list_ven_models ( void )

overrideprivatevirtual

Lists Vendor models for CWWW Client Element (none required).

Reimplemented from meshXElement< meshx_cli_model_send_param_header_t >.

{
    return 0; /* No vendor models for CWWW client */
}

s_to_ble_cb()

meshx_err_t meshXCWWWClientElement::s_to_ble_cb ( const dev_struct_t * pdev, control_task_msg_evt_t evt, const void * params )

staticprivate

{
    if (!pdev || !params) return MESHX_INVALID_ARG;
 
    if (evt == CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF)
    {
        const auto *msg = static_cast<const meshx_gen_on_off_cli_msg_t *>(params);
        auto *el = meshXElementRegistry::get_instance().find_and_cast<meshXCWWWClientElement>(
            msg->element_id, MESHX_ELEMENT_TYPE_LIGHT_CWWW_CLIENT);
        if (!el) return MESHX_SUCCESS;
 
        if (el->element_ctx.pub_addr == MESHX_ADDR_UNASSIGNED)
            return MESHX_INVALID_STATE;
 
        /* Route through the model's request_onoff to leverage the centralized logic */
        auto &models = el->get_sig_models();
#if CONFIG_ENABLE_GEN_ONOFF_CLIENT
        auto *onoff  = static_cast<meshXGenericOnOffClientModel *>(models[0].get());
        return onoff->request_onoff(msg);
#else
        return MESHX_SUCCESS;
#endif
    }
    else if (evt == CONTROL_TASK_MSG_EVT_TO_BLE_SET_CTL)
    {
        const auto *msg = static_cast<const meshx_light_ctl_cli_msg_t *>(params);
        auto *el = meshXElementRegistry::get_instance().find_and_cast<meshXCWWWClientElement>(
            msg->element_id, MESHX_ELEMENT_TYPE_LIGHT_CWWW_CLIENT);
        if (!el) return MESHX_SUCCESS;
 
        if (el->element_ctx.pub_addr == MESHX_ADDR_UNASSIGNED)
            return MESHX_INVALID_STATE;
 
        auto &models = el->get_sig_models();
#if CONFIG_ENABLE_LIGHT_CTL_CLIENT
        auto *ctl    = static_cast<meshXLightCTLClientModel *>(models[1].get());
        return ctl->request_ctl(msg->lightness, msg->temperature, msg->delta_uv, ++el->element_ctx.ctl_tid);
#else
        return MESHX_SUCCESS;
#endif
    }
    return MESHX_SUCCESS;
}

sync()

void meshXCWWWClientElement::sync ( control_task_msg_evt_t evt )

overrideprivatevirtual

Synchronize element state (GET requests).

Implements meshXElementIF.

{
    if (evt == CONTROL_TASK_MSG_EVT_SYSTEM_FRESH_BOOT)
    {
        if (!meshx_prov_srv_is_provisioned()) return;
        if (element_ctx.pub_addr == MESHX_ADDR_UNASSIGNED) return;
 
        auto &models = this->get_sig_models();
        auto *onoff  = static_cast<meshXGenericOnOffClientModel *>(models[0].get());
        auto *ctl    = static_cast<meshXLightCTLClientModel *>(models[1].get());
 
#if CONFIG_ENABLE_GEN_ONOFF_CLIENT
        meshx_gen_on_off_cli_msg_t msg = {
            .ack        = 1,
            .set_get    = MESHX_GEN_ON_OFF_CLI_MSG_GET,
            .on_off     = 0,
            .reserved   = 0,
            .element_id = this->get_element_idx()
        };
        onoff->request_onoff(&msg);
#endif
 
#if CONFIG_ENABLE_LIGHT_CTL_CLIENT
        meshx_model_t model_ref = { .el_id    = this->get_element_idx(),
                                    .model_id = (uint16_t)ctl->get_model_id(),
                                    .pub_addr = element_ctx.pub_addr,
                                    .p_model  = (MESHX_MODEL*)ctl->get_plat_model() };
        meshx_ctx_t ctl_ctx = { .app_idx  = element_ctx.app_id,
                                .net_idx  = meshx_get_net_key_id(),
                                .opcode   = MESHX_MODEL_OP_LIGHT_CTL_GET,
                                .src_addr = 0,
                                .dst_addr = element_ctx.pub_addr,
                                .p_ctx    = nullptr };
        meshx_light_ctl_send_params_t cp = {
            .model = &model_ref, .ctx = &ctl_ctx,
            .tid = 0,
            .state = { .lightness   = element_ctx.light_ctl_state.lightness,
                       .temperature = element_ctx.light_ctl_state.temperature,
                       .delta_uv    = element_ctx.light_ctl_state.delta_uv,
                       .temp_range_min = 0,
                       .temp_range_max = 0 } };
        ctl->model_send(&cp);
#endif
    }
}

Field Documentation

element_ctx

meshx_cwww_cli_el_ctx_t meshXCWWWClientElement::element_ctx

private

---

The documentation for this class was generated from the following files:

• meshx_cwww_element.hpp
• meshx_cwww_element.cpp