meshXRelayServerElement Class Reference

#include <meshx_relay_element.hpp>

Inheritance diagram for meshXRelayServerElement:

Public Member Functions
	meshXRelayServerElement (uint16_t element_idx)
	Constructs a new meshXRelayServerElement instance. The meshXRelayServerElement represents a relay element in the MeshX BLE mesh network. It automatically initializes and configures all required SIG models for the relay element.
	meshXRelayServerElement (void)=delete
uint8_t	get_state () const
	Get the current OnOff state of the relay server.
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 Relay Server Element.
uint8_t	list_ven_models (void) override
	Lists Vendor models for Relay 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_relay_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

meshXRelayServerElement() [1/2]

meshXRelayServerElement::meshXRelayServerElement ( uint16_t element_idx )

explicit

Constructs a new meshXRelayServerElement instance. The meshXRelayServerElement represents a relay element in the MeshX BLE mesh network. It automatically initializes and configures all required SIG models for the relay element.

Register class-level callbacks (called exactly once via once_flag).

Parameters

element_idx

The index of the element within the node.

Constructs a new meshXRelayServerElement instance.

    : meshXElementServer(element_idx)
{
    memset(&element_ctx, 0, sizeof(meshx_relay_srv_el_ctx_t));
    element_ctx.pub_addr = MESHX_ADDR_UNASSIGNED;
    element_ctx.gen_on_off_state.on_off = 0;
    element_ctx.gen_on_off_state.next_on_off = 1;
 
    /* Restore from NVS if available */
    meshx_nvs_element_ctx_get(element_idx, MESHX_ELEMENT_TYPE_RELAY_SERVER, &element_ctx, sizeof(meshx_relay_srv_el_ctx_t));
 
    this->register_element_ctx(&element_ctx, sizeof(meshx_relay_srv_el_ctx_t));
    this->set_element_variant(MESHX_ELEMENT_TYPE_RELAY_SERVER);
 
    control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_TO_BLE,
        RELAY_SRV_TO_BLE_EVT_MASK,
        (control_task_msg_handle_t)&meshXRelayServerElement::s_to_ble_cb);
 
#if CONFIG_ENABLE_UNIT_TEST
    register_unit_test(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, relay_srv_ut_handler);
#endif
}

meshXRelayServerElement() [2/2]

meshXRelayServerElement::meshXRelayServerElement ( void )

delete

Member Function Documentation

element_state_change_notify()

meshx_err_t meshXRelayServerElement::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_on_off_srv_el_msg_t *>(param);
    uint16_t element_id = msg->header.model.el_id;
 
    /* Update local context */
    element_ctx.gen_on_off_state = msg->state;
 
    /* Task B — NVS persistence */
    meshx_err_t err = meshx_nvs_element_ctx_set(
        element_id, get_element_variant(), &element_ctx, sizeof(element_ctx));
    if (err)
    {
        MESHX_LOGW(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER,
                   "Relay Srv [%d]: NVS save failed: %d", element_id, err);
    }
 
    /* Task B — App notification */
    meshx_api_relay_server_evt_t app_evt = {
        .on_off = element_ctx.gen_on_off_state.on_off
    };
    MESHX_LOGD(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Relay state changed to: %d", app_evt.on_off);
    return meshx_send_msg_to_app(
        element_id,
        MESHX_ELEMENT_TYPE_RELAY_SERVER,
        MESHX_ELEMENT_FUNC_ID_RELAY_SERVER_ONN_OFF,
        sizeof(app_evt),
        &app_evt);
}

get_element_name()

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

get_state()

uint8_t meshXRelayServerElement::get_state ( ) const

inline

Get the current OnOff state of the relay server.

Returns

uint8_t 0 for OFF, 1 for ON.

{ return element_ctx.gen_on_off_state.on_off; }

handle_config()

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

list_sig_models()

uint8_t meshXRelayServerElement::list_sig_models ( void )

overrideprivatevirtual

Lists and initializes SIG models for Relay Server Element.

Reimplemented from meshXElement< meshx_srv_model_send_param_header_t >.

{
    auto relay_model = std::make_unique<meshXGenericOnOffServerModel>(
        this,
        &element_ctx.gen_on_off_state.on_off,
        (uint16_t)static_cast<int>(
            meshxRelayServerElementComposition::MESHX_RELAY_SERVER_ELEMENT_COMP_GENERIC_ONOFF_SERVER)
    );
    this->get_sig_models().push_back(std::move(relay_model));
    return (uint8_t)this->get_sig_models().size();
}

list_ven_models()

uint8_t meshXRelayServerElement::list_ven_models ( void )

overrideprivatevirtual

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

Reimplemented from meshXElement< meshx_srv_model_send_param_header_t >.

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

s_to_ble_cb()

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

staticprivate

{
    /* Server-side TO_BLE: re-publish current state on demand.
       The payload is meshx_gen_srv_send_msg_t with the element_id. */
    MESHX_UNUSED(params);
    MESHX_UNUSED(pdev);
    MESHX_UNUSED(evt);
    /* No-op for server elements in relay; the app-driven send goes via client elements */
    return MESHX_SUCCESS;
}

sync()

void meshXRelayServerElement::sync ( control_task_msg_evt_t evt )

overrideprivatevirtual

Synchronize element state (Status broadcast).

Implements meshXElementIF.

{
    MESHX_LOGD(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Relay 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;
 
        auto &models = this->get_sig_models();
        auto *onoff  = static_cast<meshXGenericOnOffServerModel *>(models[0].get());
        onoff->request_status();
    }
}

Field Documentation

element_ctx

meshx_relay_srv_el_ctx_t meshXRelayServerElement::element_ctx

private

---

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

• meshx_relay_element.hpp
• meshx_relay_element.cpp