meshXBaseClientModel< baseClientModelDerived_t, ble_mesh_send_msg_params_t, ble_mesh_plat_model_cb_params_t > Class Template Reference

#include <meshx_base_model_class.hpp>

Inheritance diagram for meshXBaseClientModel< baseClientModelDerived_t, ble_mesh_send_msg_params_t, ble_mesh_plat_model_cb_params_t >:

Public Member Functions
	meshXBaseClientModel ()=delete
	~meshXBaseClientModel ()=default
	meshXBaseClientModel (uint32_t model_id, meshx_ptr_t p_plat_model, const control_msg_cb &from_ble_cb)
	Constructor for the meshXBaseClientModel template class.
meshx_err_t	from_ble_dereg_cb (void) const override
	Deregister BLE message callback for this model.
void	set_plat_model_ptr (meshx_ptr_t p_model)
	Set the platform model pointer and update the registration list.
Public Member Functions inherited from meshXBaseModel< ble_mesh_send_msg_params_t >
meshx_err_t	from_ble_reg_cb (void) const
	Register BLE message callback for this model.
virtual meshx_err_t	plat_model_init (void)=0
	Initialize platform model.
virtual meshx_err_t	plat_send_msg (ble_mesh_send_msg_params_t *params)=0
	Send message through the model.
meshx_err_t	get_status (void) const
	Get the current status of the model.
uint32_t	get_model_id (void) const
	Get the model identifier.
control_task_msg_handle_t	get_from_ble_cb (void) const
	Get the BLE message callback function.
meshXBaseModelType_t	get_model_type (void) const
	Get the model type (server/client).
void	set_status (meshx_err_t err)
	Set the model status.
void	set_model_id (uint32_t id)
	Set the model identifier.
void	set_from_ble_cb (control_task_msg_handle_t cb)
	Set the BLE message callback function.
void	set_model_type (meshXBaseModelType_t type)
	Set the model type.
	meshXBaseModel (uint32_t model_id, control_task_msg_handle_t from_ble_cb, meshXBaseModelType_t model_type)
	Construct a new meshXBaseModel object.
	meshXBaseModel ()=delete
virtual	~meshXBaseModel ()
	Virtual destructor for meshXBaseModel.

Protected Member Functions
virtual meshx_err_t	validate_client_model_id (uint32_t model_id)=0

Static Protected Member Functions
static constexpr const char *	get_client_type_name ()
static meshx_err_t	base_txcm_handle_ack (uint16_t src_addr)
	Resend an acknowledgement message for the given source address.
static meshx_err_t	base_txcm_handle_resend (uint16_t model_id, const ble_mesh_plat_model_cb_params_t *param)
	Resend a message for the given model ID and parameter.
static meshx_err_t	base_from_ble_msg_handle (dev_struct_t *pdev, control_task_msg_evt_t evt, meshx_ptr_t params)
	Template-based static message handler for BLE Mesh Generic Client models.
static meshx_err_t	base_handle_txcm_msg (dev_struct_t *pdev, control_task_msg_evt_t evt, base_client_model_resend_ctx_t *param)
	Template-based TXCM (Transmission Control Module) message handler for timeout scenarios.

Protected Attributes
meshx_ptr_t	p_plat_model
Protected Attributes inherited from meshXBaseModel< ble_mesh_send_msg_params_t >
uint32_t	model_id
meshXBaseModelType_t	model_type
control_task_msg_handle_t	from_ble_cb
meshx_err_t	status = MESHX_SUCCESS

Static Protected Attributes
static std::once_flag	plat_client_init_flag
static std::forward_list< base_client_model_cb_reg_t >	base_client_model_cb_list

Private Types
using	base_client_model_cb_reg_t
using	base_client_model_resend_ctx_t

Member Typedef Documentation

base_client_model_cb_reg_t

template<typename baseClientModelDerived_t, typename ble_mesh_send_msg_params_t, typename ble_mesh_plat_model_cb_params_t>

using meshXBaseClientModel< baseClientModelDerived_t, ble_mesh_send_msg_params_t, ble_mesh_plat_model_cb_params_t >::base_client_model_cb_reg_t

private

Initial value:

struct base_client_model_cb_reg
   {
       uint16_t model_id;   
       meshx_ptr_t p_plat_model; 
       control_msg_cb cb;   
       meshXBaseClientModel *instance; 
   }

    {
        uint16_t model_id;   /**< Model ID associated with the registration. */
        meshx_ptr_t p_plat_model; /**< Platform model pointer for instance verification. */
        control_msg_cb cb;   /**< Callback function associated with the registration. */
        meshXBaseClientModel *instance; /**< Instance pointer for registration management. */
    };

base_client_model_resend_ctx_t

template<typename baseClientModelDerived_t, typename ble_mesh_send_msg_params_t, typename ble_mesh_plat_model_cb_params_t>

using meshXBaseClientModel< baseClientModelDerived_t, ble_mesh_send_msg_params_t, ble_mesh_plat_model_cb_params_t >::base_client_model_resend_ctx_t

private

Initial value:

struct base_client_model_resend_ctx
   {
       uint16_t model_id;                   
       ble_mesh_plat_model_cb_params_t param; 
   }

    {
        uint16_t model_id;                   /**< Model ID associated with the re-sending. */
        ble_mesh_plat_model_cb_params_t param; /**< Params received from Platform callback */
    };

Constructor & Destructor Documentation

meshXBaseClientModel() [1/2]

template<typename baseClientModelDerived_t, typename ble_mesh_send_msg_params_t, typename ble_mesh_plat_model_cb_params_t>

meshXBaseClientModel< baseClientModelDerived_t, ble_mesh_send_msg_params_t, ble_mesh_plat_model_cb_params_t >::meshXBaseClientModel ( )

delete

~meshXBaseClientModel()

template<typename baseClientModelDerived_t, typename ble_mesh_send_msg_params_t, typename ble_mesh_plat_model_cb_params_t>

meshXBaseClientModel< baseClientModelDerived_t, ble_mesh_send_msg_params_t, ble_mesh_plat_model_cb_params_t >::~meshXBaseClientModel ( )

default

meshXBaseClientModel() [2/2]

template<typename baseClientModelDerived_t, typename ble_mesh_send_msg_params_t, typename ble_mesh_plat_model_cb_params_t>

meshXBaseClientModel< baseClientModelDerived_t, ble_mesh_send_msg_params_t, ble_mesh_plat_model_cb_params_t >::meshXBaseClientModel	(	uint32_t	model_id,
		meshx_ptr_t	p_plat_model,
		const control_msg_cb &	from_ble_cb )

Constructor for the meshXBaseClientModel template class.

Parameters

[in]	model_id	The unique 32-bit identifier of the Generic Client model.
[in]	p_plat_model	Pointer to the platform-specific model structure.
[in]	from_ble_cb	The callback function to handle BLE mesh messages.

    : meshXBaseModel<ble_mesh_send_msg_params_t>(model_id, base_from_ble_msg_handle, meshXBaseModelType::MESHX_BASE_MODEL_TYPE_CLIENT)
{
    this->p_plat_model = p_plat_model;
    // Validate model ID and callback - consistent with C implementation
    if (!from_ble_cb)
    {
        MESHX_LOGE(MODULE_ID_MODEL_CLIENT, "Invalid callback");
        this->status = MESHX_INVALID_ARG;
        return;
    }
 
    std::call_once(plat_client_init_flag, [this]() {
        MESHX_LOGD(MODULE_ID_MODEL_CLIENT, "First-time initialization for client template");
    });
 
    base_client_model_cb_list.push_front({(uint16_t)model_id, p_plat_model, from_ble_cb, this});
    this->status = MESHX_SUCCESS;
}

Member Function Documentation

base_from_ble_msg_handle()

template<typename baseClientModelDerived_t, typename ble_mesh_send_msg_params_t, typename ble_mesh_plat_model_cb_params_t>

meshx_err_t meshXBaseClientModel< baseClientModelDerived_t, ble_mesh_send_msg_params_t, ble_mesh_plat_model_cb_params_t >::base_from_ble_msg_handle ( dev_struct_t * pdev, control_task_msg_evt_t evt, meshx_ptr_t params )

staticprotected

Template-based static message handler for BLE Mesh Generic Client models.

This is the core static message handling function that processes incoming BLE mesh messages for all instances of a specific template instantiation. It provides a centralized dispatch mechanism with enhanced debugging, validation, and error handling.

Key Features:

• Template-specific static dispatch (one handler per template instantiation)
• Model ID validation against supported Generic Client models
• Enhanced logging with template type identification
• Timeout and error handling with automatic retry mechanism
• ACK handling for reliable message delivery
• Callback routing based on registered model IDs

Message Processing Flow:

1. Validates input parameters and model ID
2. Searches the template-specific callback list for matching model ID
3. Handles timeout/error cases with retry mechanism via TXCM
4. Processes successful messages and handles ACK
5. Invokes the registered application callback

Template Parameters

baseClientModelDerived_t	The derived client model class type
ble_mesh_plat_model_cb_params_t	Platform-specific callback parameter type
ble_mesh_send_msg_params_t	Platform-specific send message parameter type

Parameters

[in]	pdev	Pointer to the device structure associated with the BLE Mesh node. Must not be NULL.
[in]	evt	Control task message event type (typically contains model context).
[in]	params	Pointer to platform-specific message parameters structure. Must not be NULL and contain valid model_id.

Return values

MESHX_SUCCESS	Message processed successfully by registered callback.
MESHX_INVALID_ARG	Invalid parameters or unsupported model ID.
Other	Error codes from callback execution or TXCM operations.

Note

This function is automatically registered as the message handler during construction.

Each template instantiation gets its own static instance of this function.

Enhanced with template type identification for improved debugging.

See also

base_txcm_handle_resend() for retry mechanism details.

base_txcm_handle_ack() for ACK processing details.

{
    if (pdev == nullptr || params == nullptr)
    {
        MESHX_LOGE(MODULE_ID_MODEL_CLIENT, "Invalid parameters");
        return MESHX_INVALID_ARG;
    }
 
    // Enhanced logging with template type identification
    MESHX_LOGD(MODULE_ID_MODEL_CLIENT, "Handling message for model_id: %04x", (uint32_t)evt);
 
    meshx_err_t err = MESHX_SUCCESS;
    auto *param = static_cast<ble_mesh_plat_model_cb_params_t*>(params);
    meshx_ptr_t plat_model = param->model.p_model;
    bool cb_invoked = false;
 
    for (auto &node : base_client_model_cb_list)
    {
        if ((uint16_t)evt == node.model_id)
        {
            /* Only invoke if the platform model matches this instance */
            if (node.p_plat_model != plat_model)
            {
                continue;
            }
 
            MESHX_LOGD(MODULE_ID_MODEL_CLIENT,
                       "op|src|dst:%04" PRIx32 "|%04x|%04x",
                       param->ctx.opcode, param->ctx.src_addr, param->ctx.dst_addr);
 
            if (node.cb == nullptr)
            {
                MESHX_LOGW(MODULE_ID_MODEL_CLIENT, "Callback is NULL for model_id: %04x", node.model_id);
                continue;
            }
 
            if (param->evt == static_cast<decltype(param->evt)>(meshx_base_cli_evt::MESHX_BASE_CLI_TIMEOUT) || param->err_code != MESHX_SUCCESS)
            {
                MESHX_LOGW(MODULE_ID_MODEL_CLIENT, "Message timeout or error, retrying...");
                err = base_txcm_handle_resend(node.model_id, param);
                if (err != MESHX_SUCCESS)
                    MESHX_LOGE(MODULE_ID_MODEL_CLIENT, "Resend failed: %d", err);
            }
            else
            {
                err = base_txcm_handle_ack(param->ctx.src_addr);
                if (err != MESHX_SUCCESS)
                    MESHX_LOGE(MODULE_ID_MODEL_CLIENT, "Ack failed: %d", err);
 
                err = node.cb(pdev, evt, param);
            }
 
            cb_invoked = true;
        }
    }
 
    if (!cb_invoked)
        MESHX_LOGW(MODULE_ID_MODEL_CLIENT, "No registered client handled model_id=%04" PRIx32, (uint32_t)evt);
 
    return err;
}

base_handle_txcm_msg()

template<typename baseClientModelDerived_t, typename ble_mesh_send_msg_params_t, typename ble_mesh_plat_model_cb_params_t>

meshx_err_t meshXBaseClientModel< baseClientModelDerived_t, ble_mesh_send_msg_params_t, ble_mesh_plat_model_cb_params_t >::base_handle_txcm_msg ( dev_struct_t * pdev, control_task_msg_evt_t evt, base_client_model_resend_ctx_t * param )

staticprotected

Template-based TXCM (Transmission Control Module) message handler for timeout scenarios.

This function handles control task messages from the Transmission Control Module (TXCM), specifically for timeout and resend scenarios in Generic Client models. It processes timeout events by setting appropriate error codes and invoking registered callbacks to notify the application layer of transmission failures.

Key Responsibilities:

• Processes TXCM timeout notifications for failed message transmissions
• Sets timeout error codes (MESHX_TIMEOUT, MESHX_BASE_CLI_TIMEOUT)
• Routes timeout events to registered application callbacks
• Provides template-specific error logging and debugging
• Maintains consistency with C implementation error handling patterns

Timeout Processing Flow:

1. Searches template-specific callback list for matching model ID
2. Sets timeout error codes in the parameter structure
3. Validates callback function is not null
4. Invokes registered callback with timeout notification
5. Returns gracefully if no callback is registered (consistent with C impl)

Template Parameters

baseClientModelDerived_t	The derived client model class type
ble_mesh_plat_model_cb_params_t	Platform-specific callback parameter type
ble_mesh_send_msg_params_t	Platform-specific send message parameter type

Parameters

[in]	pdev	Pointer to the device structure associated with the BLE Mesh node. Must not be NULL.
[in]	evt	Control task message event type (unused in current implementation).
[in]	param	Pointer to resend context containing model ID and callback parameters. Must not be NULL and contain valid model_id.

Return values

MESHX_SUCCESS	Timeout processed successfully or no callback registered.
Other	Error codes from callback execution.

Note

This function is called by the TXCM when message transmission timeouts occur.

Each template instantiation maintains its own callback list and handler.

Enhanced with template type identification for debugging purposes.

See also

base_from_ble_msg_handle() for normal message processing.

base_txcm_handle_resend() for retry mechanism details.

{
    MESHX_UNUSED(evt);
    meshx_err_t err = MESHX_SUCCESS;
    bool cb_invoked = false;
    for (auto &node : base_client_model_cb_list)
    {
        if (param->model_id == node.model_id)
        {
            /* Only invoke if the platform model matches this instance */
            if (node.p_plat_model != nullptr && node.p_plat_model != param->param.model.p_model)
            {
                continue;
            }
 
            param->param.err_code   = MESHX_TIMEOUT;
            param->param.evt        = static_cast<decltype(param->param.evt)>(meshx_base_cli_evt::MESHX_BASE_CLI_TIMEOUT);
            if(node.cb == nullptr)
            {
                MESHX_LOGW(MODULE_ID_MODEL_CLIENT, "Callback is NULL for model_id: %04x", node.model_id);
                continue;
            }
            err = node.cb(pdev, param->model_id, &param->param);
            cb_invoked = true;
        }
    }
 
    if (!cb_invoked)
    {
        MESHX_LOGW(MODULE_ID_MODEL_CLIENT, "No registered client handled model_id=%04x", param->model_id);
        return MESHX_SUCCESS; // Consistent with C implementation - graceful handling
    }
 
    return err;
}

base_txcm_handle_ack()

template<typename baseClientModelDerived_t, typename ble_mesh_send_msg_params_t, typename ble_mesh_plat_model_cb_params_t>

meshx_err_t meshXBaseClientModel< baseClientModelDerived_t, ble_mesh_send_msg_params_t, ble_mesh_plat_model_cb_params_t >::base_txcm_handle_ack ( uint16_t src_addr )

staticprotected

Resend an acknowledgement message for the given source address.

This function resends an acknowledgement message for the given source address.

Parameters

[in]

src_addr

The source address associated with the acknowledgement message.

Return values

MESHX_SUCCESS

if the acknowledgement message was resent successfully, otherwise an error code.

{
    meshx_err_t err = MESHX_SUCCESS;
    err = meshx_txcm_request_send(MESHX_TXCM_SIG_ACK, src_addr, nullptr, 0, nullptr);
    return err;
}

base_txcm_handle_resend()

template<typename baseClientModelDerived_t, typename ble_mesh_send_msg_params_t, typename ble_mesh_plat_model_cb_params_t>

meshx_err_t meshXBaseClientModel< baseClientModelDerived_t, ble_mesh_send_msg_params_t, ble_mesh_plat_model_cb_params_t >::base_txcm_handle_resend ( uint16_t model_id, const ble_mesh_plat_model_cb_params_t * param )

staticprotected

Resend a message for the given model ID and parameter.

This function resends a message for the given model ID and parameter.

Parameters

[in]	model_id	The unique identifier of the generic client model.
[in]	param	The parameter associated with the re-sending.

Return values

MESHX_SUCCESS

if the message was resent successfully, otherwise an error code.

{
    base_client_model_resend_ctx_t ctx = {
        .model_id = model_id,
        .param = {}
    };
    memcpy(&ctx.param, param, sizeof(ble_mesh_plat_model_cb_params_t));
 
    return meshx_txcm_request_send(
        MESHX_TXCM_SIG_RESEND,
        MESHX_ADDR_UNASSIGNED,
        &ctx,
        sizeof(base_client_model_resend_ctx_t),
        NULL);
}

from_ble_dereg_cb()

template<typename baseClientModelDerived_t, typename ble_mesh_send_msg_params_t, typename ble_mesh_plat_model_cb_params_t>

meshx_err_t meshXBaseClientModel< baseClientModelDerived_t, ble_mesh_send_msg_params_t, ble_mesh_plat_model_cb_params_t >::from_ble_dereg_cb ( void ) const

overridevirtual

Deregister BLE message callback for this model.

Deregisters a callback function associated with a model ID.

Automatically called during model destruction to remove the callback function that handles BLE messages for this model's ID.

Returns

MESHX_SUCCESS if deregistration successful, error code otherwise

This function deregisters the callback function associated with the given model ID, allowing the server to stop handling events or messages related to that model.

Returns

meshx_err_t Returns an error code indicating the result of the deregistration. Possible values include success or specific error codes.

Reimplemented from meshXBaseModel< ble_mesh_send_msg_params_t >.

{
    // First, unsubscribe from control task
    meshx_err_t err = control_task_msg_unsubscribe(CONTROL_TASK_MSG_CODE_FRM_BLE, (control_task_msg_evt_t)this->model_id, this->from_ble_cb);
 
    // Then, remove from our static callback list to prevent dangling pointers
    base_client_model_cb_list.remove_if([this](const base_client_model_cb_reg_t& node) {
        return node.p_plat_model == this->p_plat_model;
    });
 
    return err;
}

get_client_type_name()

template<typename baseClientModelDerived_t, typename ble_mesh_send_msg_params_t, typename ble_mesh_plat_model_cb_params_t>

constexpr const char * meshXBaseClientModel< baseClientModelDerived_t, ble_mesh_send_msg_params_t, ble_mesh_plat_model_cb_params_t >::get_client_type_name ( )

inlinestaticconstexprprotected

                                                        {
        return __PRETTY_FUNCTION__;
    }

set_plat_model_ptr()

template<typename baseClientModelDerived_t, typename ble_mesh_send_msg_params_t, typename ble_mesh_plat_model_cb_params_t>

void meshXBaseClientModel< baseClientModelDerived_t, ble_mesh_send_msg_params_t, ble_mesh_plat_model_cb_params_t >::set_plat_model_ptr

(

meshx_ptr_t

p_model

)

Set the platform model pointer and update the registration list.

Parameters

[in]

p_model

Pointer to the platform model instance.

{
    this->p_plat_model = p_model;
    for (auto &node : base_client_model_cb_list)
    {
        if (node.instance == this)
        {
            node.p_plat_model = p_model;
            break;
        }
    }
}

validate_client_model_id()

template<typename baseClientModelDerived_t, typename ble_mesh_send_msg_params_t, typename ble_mesh_plat_model_cb_params_t>

virtual meshx_err_t meshXBaseClientModel< baseClientModelDerived_t, ble_mesh_send_msg_params_t, ble_mesh_plat_model_cb_params_t >::validate_client_model_id ( uint32_t model_id )

protectedpure virtual

Implemented in meshXBaseGenericClientModel, and meshXBaseLightClientModel.

Field Documentation

base_client_model_cb_list

template<typename baseClientModelDerived_t, typename ble_mesh_send_msg_params_t, typename ble_mesh_plat_model_cb_params_t>

std::forward_list<base_client_model_cb_reg_t> meshXBaseClientModel< baseClientModelDerived_t, ble_mesh_send_msg_params_t, ble_mesh_plat_model_cb_params_t >::base_client_model_cb_list

staticprotected

p_plat_model

template<typename baseClientModelDerived_t, typename ble_mesh_send_msg_params_t, typename ble_mesh_plat_model_cb_params_t>

meshx_ptr_t meshXBaseClientModel< baseClientModelDerived_t, ble_mesh_send_msg_params_t, ble_mesh_plat_model_cb_params_t >::p_plat_model

protected

plat_client_init_flag

template<typename baseClientModelDerived_t, typename ble_mesh_send_msg_params_t, typename ble_mesh_plat_model_cb_params_t>

std::once_flag meshXBaseClientModel< baseClientModelDerived_t, ble_mesh_send_msg_params_t, ble_mesh_plat_model_cb_params_t >::plat_client_init_flag

staticprotected

---

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

• meshx_base_model_class.hpp
• meshx_base_model_class.cpp