meshXCWWWServerElement Class Reference

#include <meshx_cwww_element.hpp>

Inheritance diagram for meshXCWWWServerElement:

Public Member Functions
	meshXCWWWServerElement (uint16_t element_idx)
	Constructs a new meshXCWWWServerElement instance. The meshXCWWWServerElement represents a CWWW server 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 server models.
	meshXCWWWServerElement ()=delete
uint8_t	get_onoff ()
meshx_light_ctl_model_state_t &	get_ctl ()
Public Member Functions inherited from meshXElementServer
	meshXElementServer ()=default
	meshXElementServer (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_srv_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 Server 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 (Status broadcast).
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_srv_el_ctx_t	element_ctx

Additional Inherited Members
Static Public Member Functions inherited from meshXElement< meshx_srv_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

meshXCWWWServerElement() [1/2]

meshXCWWWServerElement::meshXCWWWServerElement ( uint16_t element_idx )

explicit

Constructs a new meshXCWWWServerElement instance. The meshXCWWWServerElement represents a CWWW server 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 server models.

Parameters

element_idx

The index of the element within the node.

    : meshXElementServer(element_idx)
{
    memset(&element_ctx, 0, sizeof(meshx_cwww_srv_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_SERVER, &element_ctx, sizeof(meshx_cwww_srv_el_ctx_t));
 
    this->register_element_ctx(&element_ctx, sizeof(meshx_cwww_srv_el_ctx_t));
    this->set_element_variant(MESHX_ELEMENT_TYPE_LIGHT_CWWW_SERVER);
 
    /* Subscribe to BLE events for this element type */
    control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_TO_BLE,
        CWWW_SRV_TO_BLE_EVT_MASK,
        (control_task_msg_handle_t)&meshXCWWWServerElement::s_to_ble_cb);
 
#if CONFIG_ENABLE_UNIT_TEST
    register_unit_test(MODULE_ID_ELEMENT_LIGHT_CWWW_SERVER, cwww_srv_ut_handler);
#endif
}

meshXCWWWServerElement() [2/2]

meshXCWWWServerElement::meshXCWWWServerElement ( )

delete

Member Function Documentation

element_state_change_notify()

meshx_err_t meshXCWWWServerElement::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, saves to NVS, notifies app.

Reimplemented from meshXElement< meshx_srv_model_send_param_header_t >.

{
    if (!param) return MESHX_INVALID_ARG;
 
    auto *header    = static_cast<meshx_srv_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_server_evt_t app_evt = {};
    
    if (mid == MESHX_MODEL_ID_GEN_ONOFF_SRV)
    {
        auto *msg = static_cast<meshx_on_off_srv_el_msg_t *>(param);
        /* State is already updated by model layer via pointer, but we sync here for clarity */
        element_ctx.gen_on_off_state = msg->state;
        app_evt.state_change.on_off.state   = element_ctx.gen_on_off_state.on_off;
        func_id = MESHX_ELEMENT_FUNC_ID_LIGHT_CWWW_SERVER_ONN_OFF;
    }
    else if (mid == MESHX_MODEL_ID_LIGHT_CTL_SRV)
    {
        auto *msg = static_cast<meshx_light_ctl_srv_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_SERVER_CTL;
    }
    else
    {
        return MESHX_INVALID_ARG;
    }
 
    meshx_err_t err = meshx_nvs_element_ctx_set(el_id, get_element_variant(), &element_ctx, sizeof(element_ctx));
    if (err)
        MESHX_LOGW(MODULE_ID_ELEMENT_LIGHT_CWWW_SERVER, "CWWW Srv [%d]: NVS save failed: %d", el_id, err);
 
    return meshx_send_msg_to_app(el_id, MESHX_ELEMENT_TYPE_LIGHT_CWWW_SERVER,
                                 func_id, sizeof(app_evt), &app_evt);
}

get_ctl()

meshx_light_ctl_model_state_t & meshXCWWWServerElement::get_ctl ( )

inline

{ return element_ctx.light_ctl_state; }

get_element_name()

const char * meshXCWWWServerElement::get_element_name ( void ) const

overrideprivatevirtual

Get the name of the element.

Returns

String literal representing the element name.

Implements meshXElementIF.

{
    return "CWWW Server";
}

get_onoff()

uint8_t meshXCWWWServerElement::get_onoff ( )

inline

{ return element_ctx.gen_on_off_state.on_off; }

handle_config()

void meshXCWWWServerElement::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_SERVER, "CWWW Server [%d] Config Evt: %d", get_element_idx(), evt);
}

list_sig_models()

uint8_t meshXCWWWServerElement::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_srv_model_send_param_header_t >.

{
    auto onoff_model = std::make_unique<meshXGenericOnOffServerModel>(
        this, &element_ctx.gen_on_off_state,
        (uint16_t)static_cast<int>(
            meshxCWWWServerElementComposition::MESHX_CWWW_SERVER_ELEMENT_COMP_GENERIC_ONOFF_SERVER));
    this->get_sig_models().push_back(std::move(onoff_model));
 
 
    auto ctl_model = std::make_unique<meshXLightCTLServerModel>(
        this, &element_ctx.light_ctl_state,
        (uint16_t)static_cast<int>(
            meshxCWWWServerElementComposition::MESHX_CWWW_SERVER_ELEMENT_COMP_LIGHT_CTL_SERVER));
    this->get_sig_models().push_back(std::move(ctl_model));
 
    return (uint8_t)this->get_sig_models().size();
}

list_ven_models()

uint8_t meshXCWWWServerElement::list_ven_models ( void )

overrideprivatevirtual

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

Reimplemented from meshXElement< meshx_srv_model_send_param_header_t >.

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

s_to_ble_cb()

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

staticprivate

{
    MESHX_UNUSED(pdev); MESHX_UNUSED(evt); MESHX_UNUSED(params);
    return MESHX_SUCCESS;
}

sync()

void meshXCWWWServerElement::sync ( control_task_msg_evt_t evt )

overrideprivatevirtual

Synchronize element state (Status broadcast).

Implements meshXElementIF.

{
    MESHX_LOGD(MODULE_ID_ELEMENT_LIGHT_CWWW_SERVER, "CWWW Srv [%d] sync event: %d", get_element_idx(), evt);
    if (evt == CONTROL_TASK_MSG_EVT_SYSTEM_STACK_READY)
    {
        if (!meshx_prov_srv_is_provisioned()) return;
        if (element_ctx.pub_addr == MESHX_ADDR_UNASSIGNED) return;
 
        auto &models = this->get_sig_models();
 
#if CONFIG_ENABLE_GEN_ONOFF_SERVER
        auto *onoff  = static_cast<meshXGenericOnOffServerModel *>(models[0].get());
        onoff->request_status();
#endif
 
#if CONFIG_ENABLE_LIGHT_CTL_SERVER
        auto *ctl = static_cast<meshXLightCTLServerModel *>(models[1].get());
        ctl->request_status();
#endif
    }
}

Field Documentation

element_ctx

meshx_cwww_srv_el_ctx_t meshXCWWWServerElement::element_ctx

private

---

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

• meshx_cwww_element.hpp
• meshx_cwww_element.cpp