meshXGenericOnOffClientModel Class Reference

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

#include <meshx_model_onoff.hpp>

Inheritance diagram for meshXGenericOnOffClientModel:

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
	Creates a meshXGenericOnOffClientModel instance based on a BLE device.
meshx_err_t	prepare_element_msg (meshx_ptr_t *msg_ptr, size_t *msg_size) override
	Prepare message for element notification.
meshx_err_t	request_onoff (const meshx_gen_on_off_cli_msg_t *msg)
	Request to change or get the Generic OnOff state.
	meshXGenericOnOffClientModel (meshXElementIF *parent_element=nullptr, meshx_ptr_t parent_element_state=nullptr, uint16_t model_func_id=0)
	A template class for creating Generic OnOff Client models.
	~meshXGenericOnOffClientModel () override=default
Public Member Functions inherited from meshXClientModel< meshXBaseGenericClientModel, meshx_gen_onoff_send_params_t >
	meshXClientModel (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 meshXClientModel.
Public Member Functions inherited from meshXModel< meshXBaseGenericClientModel, 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.
meshXBaseGenericClientModel *	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	meshx_state_change_notify (const meshx_gen_cli_cb_param_t *param, uint8_t status)
	Handle Generic OnOff state change notifications from the MeshX stack.
meshx_err_t	element_state_change_handle (void) override
	Handle state change request from element.

Private Attributes
meshx_gen_onoff_model_state_t	model_state
meshx_on_off_cli_el_msg_t	element_msg

Additional Inherited Members
Protected Member Functions inherited from meshXClientModel< meshXBaseGenericClientModel, 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 client message header.

Detailed Description

A template class for creating Generic OnOff Client models.

This class is derived from meshXClientModel and provides a convenient interface for creating Generic OnOff Client 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

meshXGenericOnOffClientModel()

meshXGenericOnOffClientModel::meshXGenericOnOffClientModel ( 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 Client models.

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

Template Parameters

meshxBaseClientModel_t	The type of the meshXBaseClientModel 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.

    : meshXClientModel(nullptr, MESHX_MODEL_ID_GEN_ONOFF_CLI, parent_element, parent_element_state, model_func_id),
      model_state({0, 1, 0})
{
    /* Used only for initialization of Parent Class */
}

~meshXGenericOnOffClientModel()

meshXGenericOnOffClientModel::~meshXGenericOnOffClientModel ( )

overridedefault

Member Function Documentation

element_state_change_handle()

meshx_err_t meshXGenericOnOffClientModel::element_state_change_handle ( void )

overrideprivatevirtual

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_CLIENT, "Invalid parameter in element_state_change_handle");
        return MESHX_INVALID_ARG;
    }
 
    if (el_state->on_off != model_state.on_off || el_state->next_on_off != model_state.next_on_off)
    {
        *el_state = model_state;
        return MESHX_SUCCESS;
    }
    else
    {
        return MESHX_INVALID_STATE;
    }
}

meshx_state_change_notify()

meshx_err_t meshXGenericOnOffClientModel::meshx_state_change_notify ( const meshx_gen_cli_cb_param_t * param, uint8_t status )

private

Handle Generic OnOff state change notifications from the MeshX stack.

This function is responsible for handling Generic OnOff state change notifications from the MeshX stack. It is called when the MeshX stack receives a state change event from the Generic OnOff server model. The function publishes the state change event to the control task framework, which in turn notifies the application about the state change.

Parameters

[in]	param	Pointer to the Generic OnOff client callback parameter structure.
[in]	status	Status of the state change event (success or timeout).

Returns

• MESHX_SUCCESS: Successfully handled the state change notification.
• MESHX_INVALID_ARG: One or more arguments are invalid.

{
    if (!param){
        return MESHX_INVALID_ARG;
    }
 
    model_state.on_off      = param->status.onoff_status.present_onoff;
    model_state.next_on_off = !model_state.on_off;
 
    // Prepare the message (store in member variable)
    element_msg = {
        .header = {
            .err_code               = status,
            .model                  = param->model,
            .ctx                    = param->ctx,
            .element_state_change   = MESHX_SUCCESS,  // Will be set by base layer
        },
        .state                  = model_state,
    };
 
    return MESHX_SUCCESS;
}

model_from_ble_cb()

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

overridevirtual

Creates a meshXGenericOnOffClientModel instance based on a BLE device.

This function is used to create a meshXGenericOnOffClientModel instance based on a BLE device. It takes the device structure, model ID, and parameters as input and returns a pointer to the created instance.

Parameters

[in]	p_dev	Pointer to the device structure
[in]	model_id	Model ID associated with the device
[in]	params	Pointer to the parameters associated with the device

Returns

Pointer to the created meshXGenericOnOffClientModel instance

Implements meshXModel< meshXBaseGenericClientModel, meshx_gen_onoff_send_params_t >.

{
    if(!params || !p_dev)
    {
        MESHX_LOGE(MODULE_ID_MODEL_CLIENT, "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_cli_cb_param_t *>(params);
 
    return static_cast<int>(param->evt) == static_cast<int>(meshx_base_cli_evt::MESHX_BASE_CLI_TIMEOUT) ?
        meshx_state_change_notify(param, MESHX_TIMEOUT) :
        meshx_state_change_notify(param, MESHX_SUCCESS);
}

model_send()

meshx_err_t meshXGenericOnOffClientModel::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< meshXBaseGenericClientModel, meshx_gen_onoff_send_params_t >.

{
    meshx_err_t err;
    meshx_gen_cli_set_t set;
    if (!params || !params->model || !params->model->p_model)
    {
        return MESHX_INVALID_ARG;
    }
 
    meshx_gen_client_send_params_t send_params;
 
    send_params.state   = &set;
    send_params.opcode  = static_cast<uint16_t>(params->ctx->opcode);
    send_params.net_idx = params->ctx->net_idx;
    send_params.app_idx = params->ctx->app_idx;
    send_params.addr    = params->model->pub_addr;
    send_params.model   = params->model->p_model;
 
    if (params->ctx->opcode == MESHX_MODEL_OP_GEN_ONOFF_GET)
    {
        err = this->get_base_model()->plat_send_msg(&send_params);
    }
 
    else if (params->ctx->opcode == MESHX_MODEL_OP_GEN_ONOFF_SET ||
             params->ctx->opcode == MESHX_MODEL_OP_GEN_ONOFF_SET_UNACK)
    {
        set.onoff_set.tid   = params->tid;
        set.onoff_set.onoff = params->state.on_off;
        set.onoff_set.op_en = false;
 
        MESHX_LOGD(MODULE_ID_MODEL_CLIENT, "[EL %d] Sending OnOff: %d (TID: %d)",
                   params->model->el_id, set.onoff_set.onoff, set.onoff_set.tid);
 
        err = this->get_base_model()->plat_send_msg(&send_params);
        if(!err && (params->ctx->opcode == MESHX_MODEL_OP_GEN_ONOFF_SET_UNACK ||
                    params->ctx->dst_addr >= MESHX_ADDR_GROUP_START))
        {
            model_state.on_off = params->state.on_off;
            model_state.next_on_off = !model_state.on_off;
 
            /* Notify parent element of optimistic state change */
            element_msg.header.err_code = MESHX_SUCCESS;
            element_msg.header.model.el_id = params->model->el_id;
            element_msg.header.model.model_id = params->model->model_id;
            element_msg.header.ctx = *params->ctx;
            element_msg.state = model_state;
            this->send_to_parent_element(&element_msg, sizeof(element_msg));
        }
        if(err)
        {
            MESHX_LOGE(MODULE_ID_MODEL_CLIENT, "Failed to send Generic OnOff Set message");
        }
    }
    else
    {
        err = MESHX_INVALID_ARG;
        MESHX_LOGE(MODULE_ID_MODEL_CLIENT, "Invalid opcode for Generic OnOff Client: %04x", params->ctx->opcode);
    }
    return err;
}

prepare_element_msg()

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

overridevirtual

Prepare message for element notification.

This function prepares a message structure that will be sent to the parent element. The message must persist after this function returns, so it is stored as a member variable.

Parameters

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

Returns

• MESHX_SUCCESS: Message prepared successfully
• MESHX_INVALID_ARG: Invalid parameter

Implements meshXModelIF.

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

request_onoff()

meshx_err_t meshXGenericOnOffClientModel::request_onoff

(

const meshx_gen_on_off_cli_msg_t *

msg

)

Request to change or get the Generic OnOff state.

This function is used to request a change or get the Generic OnOff state from the device.

Parameters

[in]

msg

Pointer to the Generic OnOff request message structure

Returns

• MESHX_SUCCESS: Successfully sent the request
• MESHX_INVALID_ARG: One or more arguments are invalid
• MESHX_INVALID_STATE: One or more states are invalid

{
    if (!msg) return MESHX_INVALID_ARG;
 
    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;
 
    uint16_t opcode = (msg->set_get == MESHX_GEN_ON_OFF_CLI_MSG_GET)
        ? MESHX_MODEL_OP_GEN_ONOFF_GET
        : (msg->ack ? MESHX_MODEL_OP_GEN_ONOFF_SET : MESHX_MODEL_OP_GEN_ONOFF_SET_UNACK);
 
    meshx_model_t model_ref = {
        .el_id    = msg->element_id,
        .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   = opcode,
        .src_addr = 0,
        .dst_addr = common_ctx->pub_addr,
        .p_ctx    = nullptr
    };
 
    meshx_gen_onoff_send_params_t sp = {
        .model = &model_ref,
        .ctx   = &ctx,
        .state = { 0, 0, 0 },
        .tid   = 0
    };
 
    if (msg->set_get != MESHX_GEN_ON_OFF_CLI_MSG_GET)
    {
        sp.state.on_off = msg->on_off;
        sp.tid = ++el_state->tid;
 
        /* Update local model state as well for consistency */
        model_state.tid = el_state->tid;
    }
 
    return this->model_send(&sp);
}

Field Documentation

element_msg

meshx_on_off_cli_el_msg_t meshXGenericOnOffClientModel::element_msg

private

model_state

meshx_gen_onoff_model_state_t meshXGenericOnOffClientModel::model_state

private

---

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

• meshx_model_onoff.hpp
• meshx_model_onoff.cpp