meshXRelayClientElement Class Reference

#include <meshx_relay_element.hpp>

Inheritance diagram for meshXRelayClientElement:

Public Member Functions
	meshXRelayClientElement (uint16_t element_idx)
	Constructs a new meshXRelayClientElement instance. The meshXRelayClientElement represents a relay client element in the MeshX BLE mesh network. It automatically initializes and configures all required SIG models for the relay client element.
	meshXRelayClientElement (void)=delete
uint8_t	get_state () const
	Get the current OnOff state of the relay client.
void	set_target_onoff (uint8_t on_off)
	Set the target OnOff state for the next publication.
meshx_relay_cli_el_ctx_t &	get_ctx ()
	Get the element context (Internal use).
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.
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 Client Element.
uint8_t	list_ven_models (void) override
	Lists Vendor models for Relay 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 request).
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_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

meshXRelayClientElement() [1/2]

meshXRelayClientElement::meshXRelayClientElement ( uint16_t element_idx )

explicit

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

Constructs a new meshXRelayClientElement instance.

Parameters

element_idx

The index of the element within the node.

    : meshXElementClient(element_idx)
{
    memset(&element_ctx, 0, sizeof(meshx_relay_cli_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_CLIENT, &element_ctx, sizeof(meshx_relay_cli_el_ctx_t));
 
    this->register_element_ctx(&element_ctx, sizeof(meshx_relay_cli_el_ctx_t));
    this->set_element_variant(MESHX_ELEMENT_TYPE_RELAY_CLIENT);
 
    control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_TO_BLE,
        RELAY_CLI_TO_BLE_EVT_MASK,
        (control_task_msg_handle_t)&meshXRelayClientElement::s_to_ble_cb);
 
#if CONFIG_ENABLE_UNIT_TEST
    register_unit_test(MODULE_ID_ELEMENT_SWITCH_RELAY_CLIENT, relay_cli_ut_handler);
#endif
}

meshXRelayClientElement() [2/2]

meshXRelayClientElement::meshXRelayClientElement ( void )

delete

Member Function Documentation

element_state_change_notify()

meshx_err_t meshXRelayClientElement::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_cli_model_send_param_header_t >.

{
    if (!param)
        return MESHX_INVALID_ARG;
 
    auto *msg       = static_cast<meshx_on_off_cli_el_msg_t *>(param);
    uint16_t element_id = msg->header.model.el_id;
 
    /* Update local context */
    element_ctx.gen_on_off_state = msg->state;
 
    /* App notification */
    meshx_api_relay_client_evt_t app_evt = {
        .err_code = msg->header.err_code,
        .on_off   = element_ctx.gen_on_off_state.on_off
    };
    return meshx_send_msg_to_app(
        element_id,
        MESHX_ELEMENT_TYPE_RELAY_CLIENT,
        MESHX_ELEMENT_FUNC_ID_RELAY_SERVER_ONN_OFF,
        sizeof(app_evt),
        &app_evt);
}

get_ctx()

meshx_relay_cli_el_ctx_t & meshXRelayClientElement::get_ctx ( )

inline

Get the element context (Internal use).

{ return element_ctx; }

get_element_name()

const char * meshXRelayClientElement::get_element_name ( void ) const

overrideprivatevirtual

Get the name of the element.

Returns

String literal representing the element name.

Reimplemented from meshXElement< meshx_cli_model_send_param_header_t >.

{
    return "Relay Client";
}

get_state()

uint8_t meshXRelayClientElement::get_state ( ) const

inline

Get the current OnOff state of the relay client.

Returns

uint8_t 0 for OFF, 1 for ON.

{ return element_ctx.gen_on_off_state.on_off; }

handle_config()

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

list_sig_models()

uint8_t meshXRelayClientElement::list_sig_models ( void )

overrideprivatevirtual

Lists and initializes SIG models for Relay Client Element.

Reimplemented from meshXElement< meshx_cli_model_send_param_header_t >.

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

list_ven_models()

uint8_t meshXRelayClientElement::list_ven_models ( void )

overrideprivatevirtual

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

Reimplemented from meshXElement< meshx_cli_model_send_param_header_t >.

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

s_to_ble_cb()

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

staticprivate

{
    MESHX_LOGD(MODULE_ID_ELEMENT_SWITCH_RELAY_CLIENT, "Entering C++ Relay Client TO_BLE Callback: evt=0x%x", (unsigned int)evt);
    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);
        MESHX_LOGD(MODULE_ID_ELEMENT_SWITCH_RELAY_CLIENT, "Entering C++ Relay Client TO_BLE Callback: target_el_id=%d", msg->element_id);
 
        auto *el = meshXElementRegistry::get_instance().find_and_cast<meshXRelayClientElement>(
            msg->element_id, MESHX_ELEMENT_TYPE_RELAY_CLIENT);
        if (!el) {
            // Check if the element exists at all but is of a different variant
            if (!meshXElementRegistry::get_instance().find_element(msg->element_id)) {
                MESHX_LOGW(MODULE_ID_ELEMENT_SWITCH_RELAY_CLIENT, "Relay Client [%d] not found in registry!", msg->element_id);
                auto all = meshXElementRegistry::get_instance().get_all_elements();
                for (auto const& [id, ptr] : all) {
                    MESHX_LOGI(MODULE_ID_ELEMENT_SWITCH_RELAY_CLIENT, "  Registry contains ID [%d], variant %d", id, ptr->get_element_variant());
                }
            }
            return MESHX_SUCCESS;
        }
 
        MESHX_LOGI(MODULE_ID_ELEMENT_SWITCH_RELAY_CLIENT, "Relay Cli [%d]: pub_addr=0x%04x, app_id=%d",
                   msg->element_id, el->element_ctx.pub_addr, el->element_ctx.app_id);
 
        if (el->element_ctx.pub_addr == MESHX_ADDR_UNASSIGNED)
        {
            MESHX_LOGW(MODULE_ID_ELEMENT_SWITCH_RELAY_CLIENT,
                       "Relay Cli [%d]: no pub addr", msg->element_id);
            return MESHX_INVALID_STATE;
        }
 
        /* Route through the model's request_onoff to leverage the centralized logic */
        auto &models = el->get_sig_models();
        if (models.empty()) return MESHX_INVALID_STATE;
 
        auto *onoff_model = static_cast<meshXGenericOnOffClientModel *>(models[0].get());
        return onoff_model->request_onoff(msg);
    }
    return MESHX_SUCCESS;
}

set_target_onoff()

void meshXRelayClientElement::set_target_onoff ( uint8_t on_off )

inline

Set the target OnOff state for the next publication.

Parameters

on_off

0 for OFF, 1 for ON.

{ element_ctx.gen_on_off_state.next_on_off = on_off; }

sync()

void meshXRelayClientElement::sync ( control_task_msg_evt_t evt )

overrideprivatevirtual

Synchronize element state (GET request).

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

Implements meshXElementIF.

{
    MESHX_LOGD(MODULE_ID_ELEMENT_SWITCH_RELAY_CLIENT, "Relay Client [%d] sync event: %d", get_element_idx(), evt);
    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());
        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);
    }
}

Field Documentation

element_ctx

meshx_relay_cli_el_ctx_t meshXRelayClientElement::element_ctx

private

---

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

• meshx_relay_element.hpp
• meshx_relay_element.cpp