meshXGenericOnOffServerModel Class Reference

A template class for creating Generic OnOff Server models. More...

#include <meshx_model_onoff.hpp>

Inheritance diagram for meshXGenericOnOffServerModel:

Public Member Functions
meshx_err_t	model_send (meshx_gen_onoff_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 Generic OnOff Server model.
meshx_err_t	prepare_element_msg (meshx_ptr_t *msg_ptr, size_t *msg_size) override
	Prepare the element message for notification.
meshx_err_t	request_status (uint16_t dst_addr=0)
	Request to send the Generic OnOff status to a specific address.
meshx_err_t	element_state_change_handle (void) override
	Handle state change request from element.
	meshXGenericOnOffServerModel (meshXElementIF *parent_element=nullptr, meshx_ptr_t parent_element_state=nullptr, uint16_t model_func_id=0)
	A template class for creating Generic OnOff Server models.
	~meshXGenericOnOffServerModel () override=default
Public Member Functions inherited from meshXServerModel< meshXBaseGenericServerModel, meshx_gen_onoff_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< meshXBaseGenericServerModel, meshx_gen_onoff_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.
meshXBaseGenericServerModel *	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 server model instance.
meshx_err_t	plat_model_delete (void) override
	Deletes the Generic OnOff Server model and its associated resources.

Private Attributes
meshx_gen_onoff_model_state_t	model_state
meshx_on_off_srv_el_msg_t	element_msg
bool	element_msg_prepared

Additional Inherited Members
Protected Member Functions inherited from meshXServerModel< meshXBaseGenericServerModel, meshx_gen_onoff_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.

Detailed Description

A template class for creating Generic OnOff Server models.

This class is derived from meshXServerModel and provides a convenient interface for creating Generic OnOff Server models. It handles the Generic OnOff state change notifications from the MeshX stack and publishes the state change event to the element layer.

Constructor & Destructor Documentation

meshXGenericOnOffServerModel()

meshXGenericOnOffServerModel::meshXGenericOnOffServerModel ( meshXElementIF * parent_element = nullptr, meshx_ptr_t parent_element_state = nullptr, uint16_t model_func_id = 0 )

explicit

A template class for creating Generic OnOff Server models.

This class is derived from meshXServerModel and provides a convenient interface for creating Generic OnOff Server models. It handles Generic OnOff state change notifications from the MeshX stack and publishes the state change event to the element layer.

Template Parameters

meshxBaseServerModel_t	The type of the meshXBaseServerModel class to be used.
meshx_send_packet_params_t	The type of the meshXSendPacketParams structure used for sending packets.

Parameters

[in]	parent_element	A 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_GEN_ONOFF_SRV, parent_element, parent_element_state, model_func_id),
      model_state({0, 1, 0}),
      element_msg_prepared(false)
{
}

~meshXGenericOnOffServerModel()

meshXGenericOnOffServerModel::~meshXGenericOnOffServerModel ( )

overridedefault

Member Function Documentation

element_state_change_handle()

meshx_err_t meshXGenericOnOffServerModel::element_state_change_handle ( void )

overridevirtual

Handle state change request from element.

This function is called by the parent element when a state change request is received. It validates the request and returns a result to the element. Note: The actual state is maintained in the element layer, not the model layer.

Returns

• MESHX_SUCCESS: State change handled successfully
• MESHX_INVALID_ARG: Invalid parameter

Implements meshXModelIF.

{
 
    auto *el_state = static_cast<meshx_gen_onoff_model_state_t*>(this->get_parent_element_state());
 
    if (!el_state) {
        MESHX_LOGE(MODULE_ID_MODEL_SERVER, "Invalid parameter in element_state_change_handle");
        return MESHX_INVALID_ARG;
    }
 
    if(el_state->on_off != model_state.on_off)
    {
        *el_state = model_state;
    }
    else
    {
        return MESHX_INVALID_STATE;
    }
    return MESHX_SUCCESS;
}

model_from_ble_cb()

meshx_err_t meshXGenericOnOffServerModel::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 Generic OnOff Server model.

This function is triggered whenever a Generic OnOff message is received from the MeshX stack. It handles Generic OnOff 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

Implements meshXModel< meshXBaseGenericServerModel, meshx_gen_onoff_send_params_t >.

{
    if(!params || !p_dev)
    {
        MESHX_LOGE(MODULE_ID_MODEL_SERVER, "Invalid parameters");
        return MESHX_INVALID_ARG;
    }
    if(model_id != this->get_model_id())
    {
        /* Callback triggered not for this model */
        return MESHX_SUCCESS;
    }
 
    auto *param = static_cast<meshx_gen_srv_cb_param_t *>(params);
 
    // Initialize flag - message not prepared yet
    element_msg_prepared = false;
 
    bool send_reply = (param->ctx.opcode != MESHX_MODEL_OP_GEN_ONOFF_SET_UNACK);
    switch (param->ctx.opcode)
    {
        case MESHX_MODEL_OP_GEN_ONOFF_GET:
            // GET opcode - no state change, no element notification needed
            break;
        case MESHX_MODEL_OP_GEN_ONOFF_SET:
        case MESHX_MODEL_OP_GEN_ONOFF_SET_UNACK:
        {
            model_state.on_off      = param->state_change.onoff_set.onoff;
            model_state.next_on_off = !model_state.on_off;
 
            // Prepare the message (store in member variable)
            element_msg.header.model = param->model;
            element_msg.state = model_state;
            element_msg_prepared = true;
            break;
        }
        case MESHX_MODEL_OP_GEN_ONOFF_STATUS:
            // Servers may receive their own status messages in some platform event flows; ignore silently
            return MESHX_SUCCESS;
        default:
            // Unknown opcode - return error
            return MESHX_NOT_SUPPORTED;
    }
 
    meshx_err_t send_err = MESHX_SUCCESS;
    if (send_reply)
    {
        /* Response to the requester */
        meshx_ctx_t reply_ctx = param->ctx;
        reply_ctx.dst_addr = param->ctx.src_addr;
 
        meshx_gen_onoff_send_params_t send_params = {
            .model  = &param->model,
            .ctx    = &reply_ctx,
            .state  = model_state,
            .tid    = 0
        };
        send_err = this->model_send(&send_params);
    }
 
    /* Publish to the configured publication address if present */
    if (param->model.pub_addr != MESHX_ADDR_UNASSIGNED && param->ctx.src_addr != param->model.pub_addr)
    {
        MESHX_LOGD(MODULE_ID_MODEL_SERVER, "PUB: src|pub %x|%x", param->ctx.src_addr, param->model.pub_addr);
        meshx_ctx_t pub_ctx = param->ctx;
        pub_ctx.dst_addr = param->model.pub_addr;
 
        meshx_gen_onoff_send_params_t send_params = {
            .model  = &param->model,
            .ctx    = &pub_ctx,
            .state  = model_state,
            .tid    = 0
        };
        meshx_err_t pub_err = this->model_send(&send_params);
        if (send_err == MESHX_SUCCESS) send_err = pub_err;
    }
 
    return send_err;
 
    // If we reach here, message was not prepared for element notification
    // Return error so base layer doesn't send uninitialized message
    if (!element_msg_prepared)
    {
        MESHX_LOGD(MODULE_ID_MODEL_SERVER, "No element notification needed for opcode: %04x", param->ctx.opcode);
        return MESHX_NOT_SUPPORTED;
    }
 
    return MESHX_SUCCESS;
}

model_send()

meshx_err_t meshXGenericOnOffServerModel::model_send ( meshx_gen_onoff_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_gen_onoff_send_params_t structure as input and sends the corresponding packet to the MeshX stack for processing.

Parameters

[in]

params

Pointer to the meshx_gen_onoff_send_params_t structure containing the parameters

Returns

MESHX_SUCCESS on success, or an error code on failure

Implements meshXModel< meshXBaseGenericServerModel, meshx_gen_onoff_send_params_t >.

{
    if (!params || !params->model || !params->ctx)
    {
        return MESHX_INVALID_ARG;
    }
    params->ctx->opcode = MESHX_MODEL_OP_GEN_ONOFF_STATUS;
    meshx_gen_srv_state_change_t state_change = {
        .onoff_set = {
            .onoff = params->state.on_off
        }
    };
    meshx_gen_server_send_params_t send_params = {
        .p_model        = params->model,
        .p_ctx          = params->ctx,
        .state_change   = state_change,
        .data_len       = sizeof(meshx_state_change_gen_onoff_set_t)
    };
    return this->get_base_model()->plat_send_msg(&send_params);
}

plat_model_create()

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

overrideprivatevirtual

Creates and initializes a server model instance.

This function handles the platform-specific model creation process for server models. It initializes 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

Note

This is a final function and cannot be overridden by derived classes.

Implements meshXModelIF.

{
    if (p_plat_model_ptr) {
        this->set_plat_model(p_plat_model_ptr);
    }
 
    meshx_ptr_t p_pub = this->get_pub_struct();
    meshx_ptr_t p_gen = this->get_gen_struct();
    meshx_err_t err = MESHX_SUCCESS;
 
    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;
    }
 
    // If already created, skip platform creation to avoid memory leaks
    if (p_pub != nullptr || p_gen != nullptr)
    {
        // Still need to initialize the platform struct fields in the new slot
        uint16_t model_id = MESHX_MODEL_ID_GEN_ONOFF_SRV;
        memcpy((void*)&p_use->model_id, &model_id, sizeof(model_id));
        memcpy((void*)&p_use->pub, &p_pub, sizeof(p_pub));
        memcpy((void*)&p_use->user_data, &p_gen, sizeof(p_gen));
        return MESHX_SUCCESS;
    }
 
    err = meshx_plat_on_off_gen_srv_create( p_use, &p_pub, &p_gen );
    if(err)
    {
        MESHX_LOGE(MODULE_ID_MODEL_SERVER, "Failed to create Generic OnOff Server Model");
    }
    else
    {
        /* Set the publication and generic structures */
        this->set_pub_struct(p_pub);
        this->set_gen_struct(p_gen);
    }
    return err;
}

plat_model_delete()

meshx_err_t meshXGenericOnOffServerModel::plat_model_delete ( void )

overrideprivatevirtual

Deletes the Generic OnOff Server model and its associated resources.

This function frees the memory allocated for the Generic OnOff Server and sets the pointer to NULL. It also deletes the model publication resources associated with the server.

Returns

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

Implements meshXModelIF.

{
    meshx_ptr_t p_pub = this->get_pub_struct();
    meshx_ptr_t p_gen = this->get_gen_struct();
 
    meshx_err_t err = meshx_plat_gen_srv_delete( &p_pub, &p_gen );
    if (err)
    {
        MESHX_LOGE(MODULE_ID_MODEL_SERVER, "Failed to delete Generic OnOff Server Model");
    }
    else
    {
        /* Set the publication and generic structures to NULL */
        this->set_pub_struct(nullptr);
        this->set_gen_struct(nullptr);
    }
 
    return err;
}

prepare_element_msg()

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

overridevirtual

Prepare the element message for notification.

This function prepares the element message for notification by setting the message pointer and size. It checks if the message was prepared for element notification and returns an error if not.

Parameters

[out]	msg_ptr	Pointer to store the message pointer.
[out]	msg_size	Pointer to store the message size.

Returns

• MESHX_SUCCESS: Message prepared successfully.
• MESHX_INVALID_ARG: Invalid argument.
• MESHX_NOT_SUPPORTED: Message was not prepared for element notification.

Implements meshXModelIF.

{
    if (!msg_ptr || !msg_size)
    {
        return MESHX_INVALID_ARG;
    }
 
    if (!element_msg_prepared)
    {
        // Message was not prepared, return error
        return MESHX_NOT_SUPPORTED;
    }
 
    *msg_ptr  = &element_msg;
    *msg_size = sizeof(element_msg);
 
    return MESHX_SUCCESS;
}

request_status()

meshx_err_t meshXGenericOnOffServerModel::request_status

(

uint16_t

dst_addr = 0

)

Request to send the Generic OnOff status to a specific address.

This function is used to request the Generic OnOff status to be sent to a specific address. It uses the parent element's context for the message.

Parameters

[in]

dst_addr

The destination address to send the status to.

Returns

• MESHX_SUCCESS: Request sent successfully.
• MESHX_INVALID_STATE: One of the model states is invalid.

{
    auto *el_state = static_cast<meshx_gen_onoff_model_state_t*>(this->get_parent_element_state());
    auto *el = this->get_parent_element();
    if (!el || !el_state) return MESHX_INVALID_STATE;
 
    auto *common_ctx = static_cast<meshx_element_common_ctx_t*>(el->get_element_ctx());
    if (!common_ctx) return MESHX_INVALID_STATE;
 
    meshx_model_t model_ref = {
        .el_id    = el->get_element_idx(),
        .model_id = (uint16_t)this->get_model_id(),
        .pub_addr = common_ctx->pub_addr,
        .p_model  = (MESHX_MODEL*)this->get_plat_model()
    };
 
    meshx_ctx_t ctx = {
        .app_idx  = common_ctx->app_id,
        .net_idx  = meshx_get_net_key_id(),
        .opcode   = MESHX_MODEL_OP_GEN_ONOFF_STATUS,
        .src_addr = 0,
        .dst_addr = (dst_addr == 0) ? common_ctx->pub_addr : dst_addr,
        .p_ctx    = nullptr
    };
 
    meshx_gen_onoff_send_params_t sp = {
        .model = &model_ref,
        .ctx   = &ctx,
        .state = *el_state,
        .tid   = 0
    };
 
    return this->model_send(&sp);
}

Field Documentation

element_msg

meshx_on_off_srv_el_msg_t meshXGenericOnOffServerModel::element_msg

private

element_msg_prepared

bool meshXGenericOnOffServerModel::element_msg_prepared

private

model_state

meshx_gen_onoff_model_state_t meshXGenericOnOffServerModel::model_state

private

---

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

• meshx_model_onoff.hpp
• meshx_model_onoff.cpp