meshXConfigModel Class Reference

#include <meshx_model_config.hpp>

Inheritance diagram for meshXConfigModel:

Public Member Functions
meshx_err_t	model_send (meshx_config_send_params_t *params) override
	Send a packet to the MeshX stack based on the given parameters.
meshx_err_t	model_from_ble_cb (dev_struct_t *, control_task_msg_evt_t, meshx_ptr_t) override
	This function is the callback for the Config Server model.
meshx_err_t	prepare_element_msg (meshx_ptr_t *msg_ptr, size_t *msg_size) override
	Prepare message for element notification.
	meshXConfigModel (meshXElementIF *parent_element, meshx_ptr_t parent_element_state, uint16_t model_func_id)
	Constructor for meshXConfigModel class.
	~meshXConfigModel () override=default
Public Member Functions inherited from meshXServerModel< meshXBaseConfigServerModel, meshx_config_send_params_t >
	meshXServerModel (MESHX_MODEL *p_plat_model, uint32_t model_id, meshXElementIF *parent_element=nullptr, meshx_ptr_t parent_element_state=nullptr, uint16_t model_func_id=0)
	Construct a new Server Model.
Public Member Functions inherited from meshXModel< meshXBaseConfigServerModel, meshx_config_send_params_t >
void	set_plat_model (MESHX_MODEL *p_model) override
	Set the platform-specific model instance.
meshx_err_t	model_handle_from_ble_cb (dev_struct_t *p_dev, evt_model_id_t evt_model_id, meshx_ptr_t params)
	Handle upstream BLE Mesh events.
void	on_baked (void) override
	Called when the model's parent element is baked.
virtual	~meshXModel ()
	Destructor for meshXModel.
meshx_err_t	send_to_parent_element (meshx_ptr_t msg_ptr, size_t msg_size)
	Send message to parent element.
uint16_t	get_model_func_id (void) const
	Get the model function identifier.
void	set_model_func_id (uint16_t func_id)
	Set the model function identifier.
uint16_t	get_model_id (void) const override
	Get the model identifier.
bool	is_initialized (void) const override
	Check if the model is successfully initialized.
void	set_model_id (uint16_t id)
	Set the model identifier.
meshx_err_t	get_init_status (void) const
	Get the model initialization status.
meshXBaseConfigServerModel *	get_base_model (void) const
	Get the base model instance.
	meshXModel (MESHX_MODEL *p_plat_model, uint32_t model_id, meshXElementIF *parent_element=nullptr, uint16_t model_func_id=0)
	Constructs a new meshXModel instance.
Public Member Functions inherited from meshXModelIF
	meshXModelIF ()
	meshXModelIF (MESHX_MODEL *p_plat_model)
virtual	~meshXModelIF ()=default
MESHX_MODEL *	get_plat_model (void) const
	Get the platform-specific model instance.
meshx_ptr_t	get_pub_struct (void) const
	Get the publication structures.
meshx_ptr_t	get_gen_struct (void) const
	Get the generic structures.
void	set_pub_struct (meshx_ptr_t pub)
	Set the publication structures.
void	set_gen_struct (meshx_ptr_t gen)
	Set the generic structures.
void	set_parent_element (meshXElementIF *parent)
	Set the parent element for this model.
meshXElementIF *	get_parent_element (void) const
	Get the parent element of this model.
void	set_parent_element_state (meshx_ptr_t state)
	Set the parent element state pointer.
meshx_ptr_t	get_parent_element_state (void) const
	Get the parent element state pointer.

Private Member Functions
meshx_err_t	plat_model_create (MESHX_MODEL *p_plat_model_ptr=nullptr) override
	Creates and initializes a config server model instance.
meshx_err_t	plat_model_delete (void) override
	Deletes the Config Server model and its associated resources.
meshx_err_t	element_state_change_handle (void) override
	Handle state change request from element.

Private Attributes
meshx_config_model_state_t	model_state
meshx_config_srv_el_msg_t	element_msg

Additional Inherited Members
Protected Member Functions inherited from meshXServerModel< meshXBaseConfigServerModel, meshx_config_send_params_t >
void	update_element_state_change_header (meshx_err_t element_state_change, meshx_ptr_t msg_ptr) override
	Update element_state_change field in server message header.

Constructor & Destructor Documentation

meshXConfigModel()

meshXConfigModel::meshXConfigModel ( meshXElementIF * parent_element, meshx_ptr_t parent_element_state, uint16_t model_func_id )

explicit

Constructor for meshXConfigModel class.

Parameters

[in]	parent_element	Pointer to the parent element (meshXElementIF)
[in]	parent_element_state	Pointer to the parent element's state structure.
[in]	model_func_id	Functional ID for the model instance.

    : meshXServerModel(nullptr, MESHX_MODEL_ID_CONFIG_SRV, parent_element, parent_element_state, model_func_id)
{
}

~meshXConfigModel()

meshXConfigModel::~meshXConfigModel ( )

overridedefault

Member Function Documentation

element_state_change_handle()

meshx_err_t meshXConfigModel::element_state_change_handle ( void )

inlineoverrideprivatevirtual

Handle state change request from element.

Pure virtual function that derived classes must implement to handle state change requests from the parent element. The model validates the request, updates its internal state, and returns the result.

Returns

MESHX_SUCCESS on success, error code otherwise

Implements meshXModelIF.

    {
        /* Nothing to do here */
        return MESHX_SUCCESS;
    };

model_from_ble_cb()

meshx_err_t meshXConfigModel::model_from_ble_cb ( dev_struct_t * p_dev, control_task_msg_evt_t model_id, meshx_ptr_t params )

overridevirtual

This function is the callback for the Config Server model.

This function is triggered whenever a Config Server message is received from the MeshX stack. It handles the Config Server state change notifications from the MeshX stack and publishes the state change event to the element layer.

Parameters

[in]	p_dev	A pointer to the device structure.
[in]	model_id	The unique identifier of the BLE mesh model.
[in]	params	A pointer to the callback parameter structure containing the details of the received message.

Returns

• MESHX_SUCCESS: Success
• MESHX_INVALID_ARG: Invalid argument
• MESHX_FAIL: Other failures

< Config Model Publication Set

< Config Model App Bind

< Config Model App Unbind

< Config Model Publication Set

< Config AppKey Add

< Config NetKey Add

< Config Model Subscription Add

< Config Model Publication Set

< Config Model App Bind

< Config NetKey Delete

< Config AppKey Delete

< Config Model Subscription Delete

< Config Model App Unbind

Implements meshXModel< meshXBaseConfigServerModel, meshx_config_send_params_t >.

{
    if(!params || !p_dev)
    {
        MESHX_LOGE(MODULE_ID_MODEL_SERVER, "Invalid parameters");
        return MESHX_INVALID_ARG;
    }
    if(model_id != MESHX_MODEL_ID_CONFIG_SRV)
    {
        /* Callback triggered not for this model */
        return MESHX_SUCCESS;
    }
 
    auto const *param = static_cast<meshx_config_srv_cb_param_t *>(params);
 
    MESHX_LOGI(MODULE_ID_MODEL_SERVER, "Config Event: op=0x%04x, src=0x%04x, dst=0x%04x",
               param->ctx.opcode, param->ctx.src_addr, param->ctx.dst_addr);
 
    /* Sync publication address and app key index to the targeted element's context */
    uint16_t target_addr = 0;
    uint16_t new_pub_addr = MESHX_ADDR_UNASSIGNED;
    uint16_t new_app_idx = 0;
    bool sync_required = false;
 
    if (param->ctx.opcode == MESHX_MODEL_OP_MODEL_PUB_SET)
    {
        target_addr  = param->state_change.mod_pub_set.element_addr;
        new_pub_addr = param->state_change.mod_pub_set.pub_addr;
        new_app_idx  = param->state_change.mod_pub_set.app_idx;
        sync_required = true;
        MESHX_LOGI(MODULE_ID_MODEL_SERVER, "  Syncing PubAddr: el_addr=0x%04x -> pub=0x%04x, app_idx=%d",
                   target_addr, new_pub_addr, new_app_idx);
    }
    else if (param->ctx.opcode == MESHX_MODEL_OP_MODEL_APP_BIND)
    {
        target_addr  = param->state_change.mod_app_bind.element_addr;
        new_app_idx  = param->state_change.mod_app_bind.app_idx;
        sync_required = true;
        MESHX_LOGI(MODULE_ID_MODEL_SERVER, "  Syncing AppBind: el_addr=0x%04x -> app_idx=%d",
                   target_addr, new_app_idx);
    }
    else if (param->ctx.opcode == MESHX_MODEL_OP_MODEL_APP_UNBIND)
    {
        target_addr  = param->state_change.mod_app_unbind.element_addr;
        new_app_idx  = param->state_change.mod_app_unbind.app_idx;
        sync_required = true;
        MESHX_LOGI(MODULE_ID_MODEL_SERVER, "  Syncing AppUnbind: el_addr=0x%04x -> app_idx=%d",
                   target_addr, new_app_idx);
    }
 
    if (sync_required)
    {
        uint16_t el_id = target_addr - p_dev->meshx_store.node_addr;
        auto *el = meshXElementRegistry::get_instance().find_element(el_id);
        if (el && el->get_element_ctx())
        {
            meshx_element_type_t variant = el->get_element_variant();
            // All element contexts in MeshX start with meshx_element_common_ctx_t (app_id and pub_addr)
            auto *ctx = static_cast<meshx_element_common_ctx_t*>(el->get_element_ctx());
            if (param->ctx.opcode == MESHX_MODEL_OP_MODEL_PUB_SET) {
                ctx->pub_addr = new_pub_addr;
            }
            ctx->app_id = new_app_idx;
 
            meshx_nvs_element_ctx_set(el_id, variant, ctx, el->get_element_ctx_size());
            meshx_nvs_commit(); // Force immediate commit for critical config changes
            MESHX_LOGI(MODULE_ID_MODEL_SERVER, "  Element [%d] context updated and committed to NVS (variant: %d)", el_id, variant);
        }
    }
 
    // Store the message in member variable for later use by prepare_element_msg
    element_msg = {
        .header = {
            .model                  = param->model,
            .element_state_change   = MESHX_SUCCESS,
        },
        .state = { .state_change = param->state_change }
    };
 
    /* Map opcode to legacy config event for publishing */
    config_evt_t config_evt = CONTROL_TASK_MSG_EVT_CONFIG_ALL;
    switch (param->ctx.opcode)
    {
        case MESHX_MODEL_OP_APP_KEY_ADD:    config_evt = CONTROL_TASK_MSG_EVT_APP_KEY_ADD; break;
        case MESHX_MODEL_OP_NET_KEY_ADD:    config_evt = CONTROL_TASK_MSG_EVT_NET_KEY_ADD; break;
        case MESHX_MODEL_OP_MODEL_SUB_ADD:  config_evt = CONTROL_TASK_MSG_EVT_SUB_ADD; break;
        case MESHX_MODEL_OP_MODEL_PUB_SET:  config_evt = CONTROL_TASK_MSG_EVT_PUB_ADD; break;
        case MESHX_MODEL_OP_MODEL_APP_BIND: config_evt = CONTROL_TASK_MSG_EVT_APP_KEY_BIND; break;
        case MESHX_MODEL_OP_NET_KEY_DELETE: config_evt = CONTROL_TASK_MSG_EVT_NET_KEY_DEL; break;
        case MESHX_MODEL_OP_APP_KEY_DELETE: config_evt = CONTROL_TASK_MSG_EVT_APP_KEY_DEL; break;
        case MESHX_MODEL_OP_MODEL_SUB_DELETE: config_evt = CONTROL_TASK_MSG_EVT_SUB_DEL; break;
        case MESHX_MODEL_OP_MODEL_APP_UNBIND: config_evt = CONTROL_TASK_MSG_EVT_APP_KEY_UNBIND; break;
        default: break;
    }
 
    if (config_evt != CONTROL_TASK_MSG_EVT_CONFIG_ALL)
    {
        control_task_msg_publish(
            CONTROL_TASK_MSG_CODE_CONFIG,
            config_evt,
            param,
            sizeof(meshx_config_srv_cb_param_t));
    }
 
    return MESHX_SUCCESS;
}

model_send()

meshx_err_t meshXConfigModel::model_send ( meshx_config_send_params_t * params )

overridevirtual

Send a packet to the MeshX stack based on the given parameters.

This function takes a pointer to a meshx_config_send_params_t structure as input and sends the corresponding packet to the MeshX stack for processing. For config server, this is typically used for sending status responses.

Parameters

[in]

params

Pointer to the meshx_config_send_params_t structure containing the parameters

Returns

MESHX_SUCCESS on success, or an error code on failure

Implements meshXModel< meshXBaseConfigServerModel, meshx_config_send_params_t >.

{
    if (!params || !params->model || !params->ctx)
    {
        return MESHX_INVALID_ARG;
    }
 
    // For config server, we use the base model's send functionality
    // The config server send params structure is minimal (just a stub)
    meshx_config_server_send_params_t send_params = {
        .p_model   = params->model,
        .p_ctx     = params->ctx,
        .p_data    = &params->stub,  // Use stub field as data
        .data_len  = sizeof(params->stub)
    };
 
    return this->get_base_model()->plat_send_msg(&send_params);
}

plat_model_create()

meshx_err_t meshXConfigModel::plat_model_create ( MESHX_MODEL * p_plat_model_ptr = nullptr )

overrideprivatevirtual

Creates and initializes a config server model instance.

This function handles the platform-specific model creation process for config server models. It initializes config server-specific features and cannot be overridden by derived classes.

Returns

meshx_err_t Returns an error code indicating the result of the operation.

• MESHX_SUCCESS on successful model creation and initialization
• MESHX_ERR_NO_MEM if memory allocation fails
• Other error codes for platform-specific failures

Implements meshXModelIF.

{
    meshx_err_t err = MESHX_SUCCESS;
 
    if (p_plat_model_ptr) {
        this->set_plat_model(p_plat_model_ptr);
    }
 
    MESHX_MODEL* p_use = (MESHX_MODEL*)this->get_plat_model();
    if (!p_use)
    {
        MESHX_LOGE(MODULE_ID_MODEL_SERVER, "No platform model pointer available");
        return MESHX_INVALID_STATE;
    }
 
    // For config server, we use the platform's get_config_srv_model function
    // to get the model instance since there's no specific create function
    err = meshx_plat_get_config_srv_model(p_use);
    if (err)
    {
        MESHX_LOGE(MODULE_ID_MODEL_SERVER, "Failed to get Config Server Model");
        return err;
    }
 
    // Config server doesn't use pub/gen structures like other models
    // Set them to nullptr to indicate they're not used
    this->set_pub_struct(nullptr);
    this->set_gen_struct(nullptr);
 
    return MESHX_SUCCESS;
}

plat_model_delete()

meshx_err_t meshXConfigModel::plat_model_delete ( void )

overrideprivatevirtual

Deletes the Config Server model and its associated resources.

This function frees the memory allocated for the Config Server and sets the pointer to NULL. For config server, this is mainly a cleanup operation since the model is managed by the platform.

Returns

• MESHX_SUCCESS: Model deleted successfully.
• MESHX_FAIL: Failed to delete the model.

Implements meshXModelIF.

{
    // Config server is managed by the platform, so we don't need to
    // explicitly delete it. Just clean up our references.
    this->set_pub_struct(nullptr);
    this->set_gen_struct(nullptr);
 
    return MESHX_SUCCESS;
}

prepare_element_msg()

meshx_err_t meshXConfigModel::prepare_element_msg ( meshx_ptr_t * msg_ptr, size_t * msg_size )

overridevirtual

Prepare message for element notification.

Returns pointer to the stored element message

Parameters

[out]	msg_ptr	Pointer to message structure (output parameter)
[out]	msg_size	Size of the message structure (output parameter)

Returns

MESHX_SUCCESS if message prepared successfully, error code otherwise

Implements meshXModelIF.

{
    if (!msg_ptr || !msg_size)
    {
        return MESHX_INVALID_ARG;
    }
 
    *msg_ptr  = &element_msg;
    *msg_size = sizeof(element_msg);
 
    return MESHX_SUCCESS;
}

Field Documentation

element_msg

meshx_config_srv_el_msg_t meshXConfigModel::element_msg

private

model_state

meshx_config_model_state_t meshXConfigModel::model_state

private

---

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

• meshx_model_config.hpp
• meshx_model_config.cpp