meshXSensorElement Class Reference

#include <meshx_sensor_element.hpp>

Inheritance diagram for meshXSensorElement:

Public Member Functions
	meshXSensorElement (uint16_t element_id)
	Constructs a new meshXSensorElement instance.
	~meshXSensorElement () override=default
	meshXSensorElement (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 initializes SIG models for Sensor Server Element.
uint8_t	list_ven_models (void) override
	Lists Vendor models for Sensor 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_sensor_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

meshXSensorElement() [1/2]

meshXSensorElement::meshXSensorElement ( uint16_t element_id )

explicit

Constructs a new meshXSensorElement instance.

    : meshXElementServer(element_id)
{
    memset(&element_ctx, 0, sizeof(element_ctx));
    this->register_element_ctx(&element_ctx, sizeof(element_ctx));
    this->set_element_variant(MESHX_ELEMENT_TYPE_SENSOR_SERVER);
 
    /* Subscribe to BLE events for this element type */
    control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_TO_BLE,
        SENSOR_SRV_TO_BLE_EVT_MASK,
        (control_task_msg_handle_t)&meshXSensorElement::s_to_ble_cb);
}

~meshXSensorElement()

meshXSensorElement::~meshXSensorElement ( )

overridedefault

meshXSensorElement() [2/2]

meshXSensorElement::meshXSensorElement ( void )

delete

Member Function Documentation

element_state_change_notify()

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

overrideprivatevirtual

Notify element of state change from child model.

Overrides base class stub. Updates element_ctx, saves to NVS, and dispatches app notification via meshx_send_msg_to_app().

Reimplemented from meshXElement< meshx_srv_model_send_param_header_t >.

{
    if (!param) return MESHX_INVALID_ARG;
 
    auto *msg = static_cast<meshx_sensor_srv_el_msg_t *>(param);
    uint16_t el_id  = msg->header.model.el_id;
    uint16_t mid    = msg->header.model.model_id;
    uint16_t func_id = 0;
    meshx_api_sensor_server_evt_t app_evt = {};
 
    if (mid == MESHX_MODEL_ID_SENSOR_SRV)
    {
        /* Update local context */
        element_ctx.sensor_srv_state = msg->state.sensor_status;
 
        /* Task B — NVS persistence */
        meshx_nvs_element_ctx_set(el_id, get_element_variant(), &element_ctx, sizeof(element_ctx));
 
        /* Prepare App notification */
        app_evt.state_change.sensor_status.property_id = msg->state.sensor_status.property_id;
        app_evt.state_change.sensor_status.data_len    = msg->state.sensor_status.data_len;
        memcpy(app_evt.state_change.sensor_status.data, msg->state.sensor_status.data,
               std::min((uint16_t)sizeof(app_evt.state_change.sensor_status.data), msg->state.sensor_status.data_len));
 
        func_id = MESHX_ELEMENT_FUNC_ID_SENSOR_SERVER_DATA;
    }
    else
    {
        return MESHX_INVALID_ARG;
    }
 
    return meshx_send_msg_to_app(
        el_id,
        MESHX_ELEMENT_TYPE_SENSOR_SERVER,
        func_id,
        sizeof(app_evt),
        &app_evt);
}

get_element_name()

const char * meshXSensorElement::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 "Sensor Server";
}

handle_config()

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

list_sig_models()

uint8_t meshXSensorElement::list_sig_models ( void )

overrideprivatevirtual

Lists and initializes SIG models for Sensor Server Element.

Reimplemented from meshXElement< meshx_srv_model_send_param_header_t >.

{
    auto sensor_srv = std::make_unique<meshXSensorServerModel>(
        this, &element_ctx.sensor_srv_state,
        (uint16_t)static_cast<int>(
            meshXSensorElementComposition::MESHX_SENSOR_ELEMENT_COMP_SENSOR_SERVER));
    this->get_sig_models().push_back(std::move(sensor_srv));
 
    return (uint8_t)this->get_sig_models().size();
}

list_ven_models()

uint8_t meshXSensorElement::list_ven_models ( void )

overrideprivatevirtual

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

Reimplemented from meshXElement< meshx_srv_model_send_param_header_t >.

{
    return 0;
}

s_to_ble_cb()

meshx_err_t meshXSensorElement::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 != SENSOR_SRV_TO_BLE_EVT_MASK) return MESHX_SUCCESS;
 
    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<meshXSensorElement>(
        app_msg->element_id, MESHX_ELEMENT_TYPE_SENSOR_SERVER);
 
    if (!el) return MESHX_NOT_FOUND;
 
    if (app_msg->func_id == MESHX_ELEMENT_FUNC_ID_SENSOR_SERVER_DATA)
    {
        auto &models = el->get_sig_models();
        if (models.empty()) return MESHX_INVALID_STATE;
 
        auto *sensor_srv = static_cast<meshXSensorServerModel *>(models[0].get());
 
        meshx_model_t model_ref = {
            .el_id    = app_msg->element_id,
            .model_id = MESHX_MODEL_ID_SENSOR_SRV,
            .pub_addr = el->element_ctx.pub_addr,
            .p_model  = nullptr
        };
 
        meshx_ctx_t ctx = {
            .app_idx  = el->element_ctx.app_id,
            .net_idx  = pdev->meshx_store.net_key_id,
            .opcode   = MESHX_MODEL_OP_SENSOR_STATUS,
            .src_addr = 0,
            .dst_addr = el->element_ctx.pub_addr,
            .p_ctx    = nullptr
        };
 
        meshx_sensor_server_send_params_t send_params = {
            .model = &model_ref,
            .ctx   = &ctx,
            .state = {
                .sensor_status = {
                    .property_id = app_payload->sensor_server_evt.state_change.sensor_status.property_id,
                    .data_len    = app_payload->sensor_server_evt.state_change.sensor_status.data_len,
                    .data        = {0}
                }
            }
        };
        memcpy(send_params.state.sensor_status.data, app_payload->sensor_server_evt.state_change.sensor_status.data,
               std::min((uint16_t)sizeof(send_params.state.sensor_status.data), app_payload->sensor_server_evt.state_change.sensor_status.data_len));
 
        return sensor_srv->model_send(&send_params);
    }
 
    return MESHX_SUCCESS;
}

sync()

void meshXSensorElement::sync ( control_task_msg_evt_t evt )

overrideprivatevirtual

Synchronize element state (Status broadcast).

Implements meshXElementIF.

{
    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();
        auto *sensor = static_cast<meshXSensorServerModel *>(models[0].get());
 
        sensor->request_status();
    }
}

Field Documentation

element_ctx

meshx_sensor_srv_el_ctx_t meshXSensorElement::element_ctx

private

---

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

• meshx_sensor_element.hpp
• meshx_sensor_element.cpp