meshXRGBServerElement Class Reference

#include <meshx_rgb_element.hpp>

Inheritance diagram for meshXRGBServerElement:

Public Member Functions
	meshXRGBServerElement (uint16_t element_idx)
	Constructs a new meshXRGBServerElement instance.
	meshXRGBServerElement (void)=delete
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.
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 (void) override
	Lists and creates all required SIG models for the element.
uint8_t	list_ven_models (void) override
	Lists and creates all required Vendor models for the element.
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_rgb_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

meshXRGBServerElement() [1/2]

meshXRGBServerElement::meshXRGBServerElement ( uint16_t element_idx )

explicit

Constructs a new meshXRGBServerElement instance.

Parameters

element_idx

The index of the element within the node.

    : meshXElementServer(element_idx)
{
    memset(&element_ctx, 0, sizeof(element_ctx));
    element_ctx.pub_addr = MESHX_ADDR_UNASSIGNED;
 
    /* Restore from NVS if available */
    meshx_nvs_element_ctx_get(element_idx, MESHX_ELEMENT_TYPE_LIGHT_HSL_SERVER, &element_ctx, sizeof(element_ctx));
 
    register_element_ctx(&element_ctx, sizeof(element_ctx));
    set_element_variant(MESHX_ELEMENT_TYPE_LIGHT_HSL_SERVER);
 
    /* Add models:
       1. Generic OnOff Server (mapped to HSL OnOff)
       2. Light HSL Server
    */
#if CONFIG_ENABLE_GEN_ONOFF_SERVER
    auto onoff_srv = std::make_unique<meshXGenericOnOffServerModel>(
        this,
        &element_ctx.gen_on_off_state,
        (uint16_t)MESHX_ELEMENT_FUNC_ID_LIGHT_HSL_SERVER_ONN_OFF
    );
    this->get_sig_models().push_back(std::move(onoff_srv));
#endif
#if CONFIG_ENABLE_LIGHT_HSL_SERVER
    auto hsl_srv = std::make_unique<meshXLightHSLServerModel>(
        this,
        &element_ctx.light_hsl_state,
        (uint16_t)MESHX_ELEMENT_FUNC_ID_LIGHT_HSL_SERVER_HSL
    );
    this->get_sig_models().push_back(std::move(hsl_srv));
#endif
 
    set_no_of_sig_models(get_sig_model_count());
    set_no_of_ven_models(get_ven_model_count());
 
    sig_plat_model_array_allocate();
    ven_plat_model_array_allocate();
}

meshXRGBServerElement() [2/2]

meshXRGBServerElement::meshXRGBServerElement ( void )

delete

Member Function Documentation

element_state_change_notify()

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

overrideprivatevirtual

Notify element of state change from child model.

Reimplemented from meshXElement< meshx_srv_model_send_param_header_t >.

{
    MESHX_UNUSED(param_size);
    if (!param) return MESHX_INVALID_ARG;
 
    auto *header = static_cast<meshx_srv_model_send_param_header_t *>(param);
    uint16_t element_id = get_element_idx();
    uint32_t model_id = header->model.model_id;
 
    meshx_err_t err = MESHX_SUCCESS;
 
    if (model_id == 0x1000) /* Generic OnOff Server */
    {
#if CONFIG_ENABLE_GEN_ONOFF_SERVER
        auto *msg = static_cast<meshx_on_off_srv_el_msg_t *>(param);
        element_ctx.gen_on_off_state.on_off = msg->state.on_off;
 
        /* App notification */
        meshx_api_light_hsl_server_evt_t app_evt = {};
        app_evt.state_change.on_off.state = element_ctx.gen_on_off_state.on_off;
 
        err = meshx_send_msg_to_app(
            element_id,
            MESHX_ELEMENT_TYPE_LIGHT_HSL_SERVER,
            MESHX_ELEMENT_FUNC_ID_LIGHT_HSL_SERVER_ONN_OFF,
            sizeof(app_evt),
            &app_evt);
#endif
    }
    else if (model_id == 0x1307) /* Light HSL Server */
    {
        auto *msg = static_cast<meshx_light_hsl_srv_el_msg_t *>(param);
        element_ctx.light_hsl_state = msg->state;
 
        /* App notification */
        meshx_api_light_hsl_server_evt_t app_evt = {};
        app_evt.state_change.hsl.lightness = element_ctx.light_hsl_state.lightness;
        app_evt.state_change.hsl.hue = element_ctx.light_hsl_state.hue;
        app_evt.state_change.hsl.saturation = element_ctx.light_hsl_state.saturation;
 
        err = meshx_send_msg_to_app(
            element_id,
            MESHX_ELEMENT_TYPE_LIGHT_HSL_SERVER,
            MESHX_ELEMENT_FUNC_ID_LIGHT_HSL_SERVER_HSL,
            sizeof(app_evt),
            &app_evt);
    }
 
    /* NVS persistence */
    meshx_nvs_element_ctx_set(element_id, get_element_variant(), &element_ctx, sizeof(element_ctx));
 
    return err;
}

get_element_name()

const char * meshXRGBServerElement::get_element_name ( void ) const

overrideprivatevirtual

Get the name of the element.

Returns

String literal representing the element name.

Reimplemented from meshXElement< meshx_srv_model_send_param_header_t >.

{
    return "HSL Server";
}

handle_config()

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

list_sig_models()

uint8_t meshXRGBServerElement::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 >.

{
    return get_no_of_sig_models();
}

list_ven_models()

uint8_t meshXRGBServerElement::list_ven_models ( void )

overrideprivatevirtual

Lists and creates all required Vendor models for the element.

This function is responsible for creating and populating the ven_models vector with all essential Vendor 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 Vendor models created and added to the root_sig_models vector

Reimplemented from meshXElement< meshx_srv_model_send_param_header_t >.

{
    return 0;
}

s_to_ble_cb()

meshx_err_t meshXRGBServerElement::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);
    if (!params) return MESHX_INVALID_ARG;
 
    auto* app_msg = static_cast<const meshx_app_element_msg_header_t*>(params);
    auto* app_payload = reinterpret_cast<const meshx_data_payload_t*>(app_msg + 1);
 
    /* Look up the instance from the registry using the element_id */
    auto* el = meshXElementRegistry::get_instance().find_and_cast<meshXRGBServerElement>(
        app_msg->element_id, MESHX_ELEMENT_TYPE_LIGHT_HSL_SERVER);
 
    if (!el) return MESHX_NOT_FOUND;
 
    if (app_msg->func_id == MESHX_ELEMENT_FUNC_ID_LIGHT_HSL_SERVER_HSL)
    {
        el->element_ctx.light_hsl_state.hue = app_payload->light_hsl_server_evt.state_change.hsl.hue;
        el->element_ctx.light_hsl_state.saturation = app_payload->light_hsl_server_evt.state_change.hsl.saturation;
        el->element_ctx.light_hsl_state.lightness = app_payload->light_hsl_server_evt.state_change.hsl.lightness;
 
        /* Publish the new state */
        for (auto& m : el->get_sig_models())
        {
            if (m->get_model_id() == MESHX_MODEL_ID_LIGHT_HSL_SRV)
            {
#if CONFIG_ENABLE_LIGHT_HSL_SERVER
                auto* hsl_srv = static_cast<meshXLightHSLServerModel*>(m.get());
                meshx_model_t model_ref = {
                    .el_id = el->get_element_idx(),
                    .model_id = (uint16_t)hsl_srv->get_model_id(),
                    .pub_addr = el->element_ctx.pub_addr,
                    .p_model = hsl_srv->get_plat_model()
                };
 
                meshx_ctx_t ctx = {
                    .app_idx = el->element_ctx.app_id,
                    .net_idx = pdev->meshx_store.net_key_id,
                    .opcode = MESHX_MODEL_OP_LIGHT_HSL_STATUS,
                    .src_addr = 0,
                    .dst_addr = el->element_ctx.pub_addr,
                    .p_ctx = hsl_srv->get_pub_struct()
                };
 
                meshx_light_hsl_send_params_t send_params = {
                    .model = &model_ref,
                    .ctx = &ctx,
                    .tid = 0,
                    .state = el->element_ctx.light_hsl_state
                };
                hsl_srv->model_send(&send_params);
#endif
            }
        }
 
        /* Persist to NVS */
        meshx_nvs_element_ctx_set(el->get_element_idx(), MESHX_ELEMENT_TYPE_LIGHT_HSL_SERVER,
                                   &el->element_ctx, sizeof(el->element_ctx));
    }
 
    return MESHX_SUCCESS;
}

sync()

void meshXRGBServerElement::sync ( control_task_msg_evt_t evt )

overrideprivatevirtual

Synchronize element state (Status broadcast).

Implements meshXElementIF.

{
    MESHX_LOGD(MODULE_ID_ELEMENT_LIGHT_HSL_SERVER, "RGB Server [%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;
 
        for (auto& m : this->get_sig_models())
        {
            (void)m;
#if CONFIG_ENABLE_LIGHT_HSL_SERVER
            if (m->get_model_id() == MESHX_MODEL_ID_LIGHT_HSL_SRV)
            {
                auto* hsl_srv = static_cast<meshXLightHSLServerModel*>(m.get());
                hsl_srv->request_status();
            }
#endif
#if CONFIG_ENABLE_GEN_ONOFF_SERVER
            if (m->get_model_id() == MESHX_MODEL_ID_GEN_ONOFF_SRV)
            {
                auto* onoff = static_cast<meshXGenericOnOffServerModel*>(m.get());
                onoff->request_status();
            }
#endif
        }
    }
}

Field Documentation

element_ctx

meshx_rgb_srv_el_ctx_t meshXRGBServerElement::element_ctx

private

---

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

• meshx_rgb_element.hpp
• meshx_rgb_element.cpp