meshx_relay_client.c File Reference

Implementation of the relay client model for BLE Mesh. More...

#include "meshx_common.h"
#include "meshx_control_task.h"
#include "meshx_nvs.h"
#include "meshx_api.h"
#include "meshx_relay_client_element.h"
#include "meshx_config_server.h"

Include dependency graph for meshx_relay_client.c:

Go to the source code of this file.

Macros
#define	CONFIG_SERVER_CB_MASK
#define	CONTROL_TASK_MSG_CODE_EVT_MASK   CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF
#define	MOD_SRC   MODULE_ID_ELEMENT_SWITCH_RELAY_CLIENT
#define	RELAY_CLI_EL_STATE_CH_EVT_MASK   CONTROL_TASK_MSG_EVT_EL_STATE_CH_SET_ON_OFF
#define	GET_RELATIVE_EL_IDX(_element_id)
#define	IS_EL_IN_RANGE(_element_id)
#define	RELAY_CLI_EL(_rel_el_id)

Enumerations
enum	relay_cli_cmd_t {   RELAY_CLI_CMD_GET = 0x00 ,   RELAY_CLI_CMD_SET = 0x01 ,   RELAY_CLI_CMD_SET_UNACK = 0x02 ,   RELAY_CLI_MAX_CMD }

Functions
static meshx_err_t	meshx_element_struct_init (uint16_t n_max)
	Initializes the mesh element structure.
static meshx_err_t	meshx_element_struct_deinit (void)
	Deinitializes the mesh element structure.
static meshx_err_t	meshx_dev_create_relay_model_space (dev_struct_t const *pdev, uint16_t n_max)
	Create Dynamic Relay Model Elements.
static meshx_err_t	meshx_add_relay_cli_model_to_element_list (dev_struct_t *pdev, uint16_t *start_idx, uint16_t n_max)
	Add relay client models to the element list.
static meshx_err_t	relay_client_config_cli_cb (const dev_struct_t *pdev, control_task_msg_evt_t evt, const meshx_config_srv_cb_param_t *params)
	Callback function for configuration client events.
static meshx_err_t	relay_cli_prov_srv_msg_handle (const dev_struct_t *pdev, control_task_msg_evt_t evt, const void *params)
	Relay Client Provisioning Server Control Task Message Handler.
static meshx_err_t	meshx_relay_cli_send_onoff_msg (const dev_struct_t *pdev, uint16_t element_id, uint8_t set_get, uint8_t ack)
	Sends a relay message over BLE mesh.
static meshx_err_t	meshx_relay_client_element_state_change_handler (const dev_struct_t *pdev, control_task_msg_evt_t evt, const meshx_on_off_cli_el_msg_t *param)
	Handles the relay client element message.
static meshx_err_t	meshx_relay_client_to_ble_handler (const dev_struct_t *pdev, control_task_msg_evt_t evt, const meshx_gen_on_off_cli_msg_t *msg)
	Relay Client Element Application Request Handler.
static meshx_err_t	relay_cli_unit_test_cb_handler (int cmd_id, int argc, char **argv)
	Callback handler for the Relay client unit test command.
static meshx_err_t	meshx_relay_cli_reg_app_req_cb ()
	Registers a callback handler for relay application requests.
static meshx_err_t	meshx_relay_cli_el_state_change_reg_cb ()
	Registers a callback for relay element state change events.
meshx_err_t	meshx_relay_el_set_state (uint16_t el_id, bool ack)
	Set the On/Off state for a specific element in the BLE mesh network.
meshx_err_t	meshx_relay_el_get_state (uint16_t el_id)
	Retrieves the current state of the relay element.
meshx_err_t	create_relay_client_elements (dev_struct_t *pdev, uint16_t element_cnt)
	Create Dynamic Relay Model Elements.
	REG_MESHX_ELEMENT_FN (relay_cli_el, MESHX_ELEMENT_TYPE_RELAY_CLIENT, create_relay_client_elements)

Variables
static relay_client_element_ctrl_t	relay_element_init_ctrl

Detailed Description

Implementation of the relay client model for BLE Mesh.

Copyright (c) 2024 - 2025 MeshX

This file contains the implementation of the relay client model for BLE Mesh, including initialization, configuration, and event handling.

Author

Pranjal Chanda

Definition in file meshx_relay_client.c.

Macro Definition Documentation

CONFIG_SERVER_CB_MASK

#define CONFIG_SERVER_CB_MASK

Value:

      CONTROL_TASK_MSG_EVT_PUB_ADD  \
    | CONTROL_TASK_MSG_EVT_SUB_ADD  \
    | CONTROL_TASK_MSG_EVT_APP_KEY_BIND

Definition at line 24 of file meshx_relay_client.c.

#define CONFIG_SERVER_CB_MASK       \
      CONTROL_TASK_MSG_EVT_PUB_ADD  \
    | CONTROL_TASK_MSG_EVT_SUB_ADD  \
    | CONTROL_TASK_MSG_EVT_APP_KEY_BIND

CONTROL_TASK_MSG_CODE_EVT_MASK

#define CONTROL_TASK_MSG_CODE_EVT_MASK   CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF

Definition at line 28 of file meshx_relay_client.c.

GET_RELATIVE_EL_IDX

#define GET_RELATIVE_EL_IDX

(

_element_id

)

Value:

_element_id - relay_element_init_ctrl.element_id_start

Definition at line 34 of file meshx_relay_client.c.

IS_EL_IN_RANGE

#define IS_EL_IN_RANGE

(

_element_id

)

Value:

(_element_id >= relay_element_init_ctrl.element_id_start && _element_id < relay_element_init_ctrl.element_id_end)

Definition at line 35 of file meshx_relay_client.c.

MOD_SRC

#define MOD_SRC   MODULE_ID_ELEMENT_SWITCH_RELAY_CLIENT

Definition at line 31 of file meshx_relay_client.c.

RELAY_CLI_EL

#define RELAY_CLI_EL

(

_rel_el_id

)

Value:

relay_element_init_ctrl.el_list[_rel_el_id]

Definition at line 36 of file meshx_relay_client.c.

RELAY_CLI_EL_STATE_CH_EVT_MASK

#define RELAY_CLI_EL_STATE_CH_EVT_MASK   CONTROL_TASK_MSG_EVT_EL_STATE_CH_SET_ON_OFF

Definition at line 32 of file meshx_relay_client.c.

Enumeration Type Documentation

relay_cli_cmd_t

enum relay_cli_cmd_t

Enumerator
RELAY_CLI_CMD_GET	0x00
RELAY_CLI_CMD_SET	0x01
RELAY_CLI_CMD_SET_UNACK	0x02
RELAY_CLI_MAX_CMD

Definition at line 491 of file meshx_relay_client.c.

{
    RELAY_CLI_CMD_GET = 0x00,
    RELAY_CLI_CMD_SET = 0x01,
    RELAY_CLI_CMD_SET_UNACK = 0x02,
    RELAY_CLI_MAX_CMD
} relay_cli_cmd_t;

Function Documentation

create_relay_client_elements()

meshx_err_t create_relay_client_elements	(	dev_struct_t *	pdev,
		uint16_t	element_cnt )

Create Dynamic Relay Model Elements.

Parameters

[in]	pdev	Pointer to device structure
[in]	element_cnt	Maximum number of relay models

Returns

meshx_err_t

Definition at line 635 of file meshx_relay_client.c.

{
    meshx_err_t err;
 
    err = meshx_dev_create_relay_model_space(pdev, element_cnt);
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "Relay Model space create failed: (%d)", err);
        return err;
    }
 
    err = meshx_add_relay_cli_model_to_element_list(pdev, (uint16_t *)&pdev->element_idx, element_cnt);
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "Relay Model add to element create failed: (%d)", err);
        return err;
    }
 
#if CONFIG_ENABLE_CONFIG_SERVER
    err = meshx_config_server_cb_reg(
        (config_srv_cb_t)&relay_client_config_cli_cb,
        CONFIG_SERVER_CB_MASK);
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "Relay Model config client callback reg failed: (%d)", err);
        return err;
    }
#endif /* CONFIG_ENABLE_CONFIG_SERVER */
    err = meshx_relay_cli_reg_app_req_cb();
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "Relay Client app req callback reg failed: (%d)", err);
        return err;
    }
    err = meshx_prov_srv_reg_el_client_cb(
        (prov_srv_cb_t)&relay_cli_prov_srv_msg_handle);
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "Relay Client freshboot callback reg failed: (%d)", err);
        return err;
    }
    err = meshx_relay_cli_el_state_change_reg_cb();
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "Relay Client element state change callback reg failed: (%d)", err);
        return err;
    }
#if CONFIG_ENABLE_UNIT_TEST
    err = register_unit_test(MOD_SRC, &relay_cli_unit_test_cb_handler);
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "unit_test reg failed: (%d)", err);
        return err;
    }
#endif /* CONFIG_ENABLE_UNIT_TEST */
 
    err = meshx_on_off_client_init();
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "meshx_onoff_client_init failed: (%d)", err);
        return err;
    }
 
    return MESHX_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

meshx_add_relay_cli_model_to_element_list()

static meshx_err_t meshx_add_relay_cli_model_to_element_list ( dev_struct_t * pdev, uint16_t * start_idx, uint16_t n_max )

static

Add relay client models to the element list.

Registers the relay client models to the BLE Mesh element list.

Parameters

[in]	pdev	Pointer to the device structure.
[in,out]	start_idx	Pointer to the start index of elements.
[in]	n_max	Maximum number of elements to add.

Returns

MESHX_SUCCESS on success, error code otherwise.

Definition at line 172 of file meshx_relay_client.c.

{
    if (!pdev || !start_idx || !n_max)
        return MESHX_INVALID_STATE;
 
    if ((n_max + *start_idx) > CONFIG_MAX_ELEMENT_COUNT)
    {
        MESHX_LOGE(MOD_SRC, "No of elements limit reached");
        return MESHX_NO_MEM;
    }
 
    meshx_err_t err = MESHX_SUCCESS;
    relay_element_init_ctrl.element_id_start = *start_idx;
 
    for (uint16_t i = *start_idx; i < (n_max + *start_idx); i++)
    {
        if (i == 0)
            continue;
        err = meshx_plat_add_element_to_composition(
            i,
            pdev->elements,
            RELAY_CLI_EL(i - *start_idx).relay_cli_sig_model_list,
            NULL,
            RELAY_CLI_MODEL_SIG_CNT,
            RELAY_CLI_MODEL_VEN_CNT);
        if (err)
        {
            MESHX_LOGE(MOD_SRC, "Failed to add element to composition: (%d)", err);
            return err;
        }
        err = meshx_nvs_element_ctx_get(
            i,
            RELAY_CLI_EL(i - *start_idx).cli_ctx,
            sizeof(meshx_relay_client_model_ctx_t));
        if (err != MESHX_SUCCESS)
        {
            MESHX_LOGW(MOD_SRC, "Failed to get relay cli element context: (0x%x)", err);
        }
    }
    /* Increment the index for further registrations */
    relay_element_init_ctrl.element_id_end = *start_idx += n_max;
    return MESHX_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

meshx_dev_create_relay_model_space()

static meshx_err_t meshx_dev_create_relay_model_space ( dev_struct_t const * pdev, uint16_t n_max )

static

Create Dynamic Relay Model Elements.

Parameters

[in]	pdev	Pointer to device structure
[in]	n_max	Maximum number of relay models

Returns

meshx_err_t

Definition at line 145 of file meshx_relay_client.c.

{
    if (!pdev)
        return MESHX_INVALID_STATE;
 
    /* Assign Spaces for Model List, Publish List and onoff gen list */
    meshx_err_t err = meshx_element_struct_init(n_max);
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "Failed to initialize relay element structures: (%d)", err);
        meshx_element_struct_deinit();
        return err;
    }
    return MESHX_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

meshx_element_struct_deinit()

static meshx_err_t meshx_element_struct_deinit ( void )

static

Deinitializes the mesh element structure.

This function deinitializes the mesh element structure by freeing the allocated memory.

Returns

meshx_err_t

• MESHX_SUCCESS: Success
• MESHX_INVALID_STATE: Invalid state
• MESHX_ERR: Error occurred during deinitialization

Definition at line 106 of file meshx_relay_client.c.

{
    if (!relay_element_init_ctrl.element_cnt || !relay_element_init_ctrl.el_list)
    {
        MESHX_LOGE(MOD_SRC, "Relay element list not initialized");
        return MESHX_INVALID_STATE;
    }
 
    meshx_err_t err;
 
    for (size_t i = 0; i < relay_element_init_ctrl.element_cnt; i++)
    {
        if (RELAY_CLI_EL(i).cli_ctx)
        {
            MESHX_FREE(RELAY_CLI_EL(i).cli_ctx);
            RELAY_CLI_EL(i).cli_ctx = NULL;
        }
        err = meshx_on_off_client_delete(&RELAY_CLI_EL(i).onoff_cli_model);
        if (err)
            MESHX_LOGE(MOD_SRC, "Meshx On Off Server delete failed (Err : 0x%x)", err);
    }
 
    if (relay_element_init_ctrl.el_list)
    {
        MESHX_FREE(relay_element_init_ctrl.el_list);
        relay_element_init_ctrl.el_list = NULL;
    }
 
    return MESHX_SUCCESS;
}

Here is the caller graph for this function:

meshx_element_struct_init()

static meshx_err_t meshx_element_struct_init ( uint16_t n_max )

static

Initializes the mesh element structure.

This function initializes the mesh element structure with the specified maximum number of elements.

Parameters

n_max

The maximum number of elements to initialize.

Returns

• MESHX_SUCCESS: Success
• MESHX_INVALID_ARG: Invalid argument

Definition at line 51 of file meshx_relay_client.c.

{
    if (!n_max)
        return MESHX_INVALID_ARG;
 
    if (relay_element_init_ctrl.el_list)
    {
        MESHX_LOGW(MOD_SRC, "Relay element list already initialized");
        return MESHX_INVALID_STATE;
    }
 
    meshx_err_t err = MESHX_SUCCESS;
 
    relay_element_init_ctrl.element_cnt      = n_max;
    relay_element_init_ctrl.element_id_end   = 0;
    relay_element_init_ctrl.element_id_start = 0;
 
    relay_element_init_ctrl.el_list =
        (relay_client_elements_t *)MESHX_CALOC(relay_element_init_ctrl.element_cnt, sizeof(relay_client_elements_t));
 
    if (!relay_element_init_ctrl.el_list)
        return MESHX_NO_MEM;
 
    for (size_t i = 0; i < relay_element_init_ctrl.element_cnt; i++)
    {
        RELAY_CLI_EL(i).cli_ctx =
            (meshx_relay_client_model_ctx_t *)MESHX_CALOC(1, sizeof(meshx_relay_client_model_ctx_t));
 
        if (!RELAY_CLI_EL(i).cli_ctx)
            return MESHX_NO_MEM;
 
        err = meshx_on_off_client_create(&RELAY_CLI_EL(i).onoff_cli_model,
                                         &RELAY_CLI_EL(i).relay_cli_sig_model_list[RELAY_CLI_SIG_ONOFF_MODEL_ID]);
        if (err)
        {
            MESHX_LOGE(MOD_SRC, "Meshx On Off Client create failed (Err : 0x%x)", err);
            return err;
        }
        RELAY_CLI_EL(i).onoff_cli_model->meshx_sig
            = &RELAY_CLI_EL(i).relay_cli_sig_model_list[RELAY_CLI_SIG_ONOFF_MODEL_ID];
    }
 
    return MESHX_SUCCESS;
}

Here is the caller graph for this function:

meshx_relay_cli_el_state_change_reg_cb()

static meshx_err_t meshx_relay_cli_el_state_change_reg_cb ( )

static

Registers a callback for relay element state change events.

This function subscribes the provided callback to control task messages related to relay element state changes. It ensures the callback is valid before subscribing.

Returns

• Result of control_task_msg_subscribe() otherwise.

Definition at line 567 of file meshx_relay_client.c.

{
    return control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_EL_STATE_CH,
        RELAY_CLI_EL_STATE_CH_EVT_MASK,
        (control_task_msg_handle_t)&meshx_relay_client_element_state_change_handler
    );
}

Here is the call graph for this function:

Here is the caller graph for this function:

meshx_relay_cli_reg_app_req_cb()

static meshx_err_t meshx_relay_cli_reg_app_req_cb ( )

static

Registers a callback handler for relay application requests.

This function subscribes the provided callback to control task messages related to BLE events. It ensures the callback is valid before subscribing.

Returns

• Result of control_task_msg_subscribe() otherwise.

Definition at line 549 of file meshx_relay_client.c.

{
    return control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_TO_BLE,
        CONTROL_TASK_MSG_CODE_EVT_MASK,
        (control_task_msg_handle_t)&meshx_relay_client_to_ble_handler
    );
}

Here is the call graph for this function:

Here is the caller graph for this function:

meshx_relay_cli_send_onoff_msg()

static meshx_err_t meshx_relay_cli_send_onoff_msg ( const dev_struct_t * pdev, uint16_t element_id, uint8_t set_get, uint8_t ack )

static

Sends a relay message over BLE mesh.

This function sends a relay message to a specified element in the BLE mesh network.

Parameters

[in]	pdev	Pointer to the device structure.
[in]	element_id	The ID of the element to which the message is sent.
[in]	set_get	Indicates whether the message is a set (0) or get (1) operation.
[in]	ack	Indicates whether an acknowledgment is required (1) or not (0).

Returns

• MESHX_SUCCESS: Success
• MESHX_INVALID_ARG: Invalid argument
• MESHX_FAIL: Sending message failed

Definition at line 338 of file meshx_relay_client.c.

{
    if (!pdev || !IS_EL_IN_RANGE(element_id))
        return MESHX_INVALID_ARG;
 
    meshx_err_t err = MESHX_SUCCESS;
    size_t rel_el_id = GET_RELATIVE_EL_IDX(element_id);
    meshx_onoff_client_model_t *model = RELAY_CLI_EL(rel_el_id).onoff_cli_model;
 
    meshx_relay_client_model_ctx_t *el_ctx = RELAY_CLI_EL(rel_el_id).cli_ctx;
    uint16_t opcode = MESHX_MODEL_OP_GEN_ONOFF_GET;
 
    if (MESHX_GEN_ON_OFF_CLI_MSG_SET == set_get)
    {
        opcode = ack ? MESHX_MODEL_OP_GEN_ONOFF_SET : MESHX_MODEL_OP_GEN_ONOFF_SET_UNACK;
    }
 
    MESHX_LOGD(MOD_SRC, "OPCODE: %p", (void *)(uint32_t)opcode);
 
    meshx_gen_onoff_send_params_t params = {
        .element_id = element_id,
        .model      = model,
        .opcode     = opcode,
        .addr       = el_ctx->pub_addr,
        .net_idx    = pdev->meshx_store.net_key_id,
        .app_idx    = el_ctx->app_id,
        .state      = el_ctx->state.on_off,
        .tid        = el_ctx->tid
    };
    /* Send message to the relay client */
    err = meshx_onoff_client_send_msg(&params);
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "Relay Client Send Message failed: (%d)", err);
    }
    else
    {
        el_ctx->tid++;
        if(opcode == MESHX_MODEL_OP_GEN_ONOFF_SET_UNACK)
        {
            el_ctx->prev_state.on_off = el_ctx->state.on_off;
            el_ctx->state.on_off = !el_ctx->state.on_off;
        }
    }
    return err;
}

Here is the caller graph for this function:

meshx_relay_client_element_state_change_handler()

static meshx_err_t meshx_relay_client_element_state_change_handler ( const dev_struct_t * pdev, control_task_msg_evt_t evt, const meshx_on_off_cli_el_msg_t * param )

static

Handles the relay client element message.

Note

CONTROL_TASK_MSG_CODE_EL_STATE_CH

This function processes the relay client element message and updates the state of the relay client model accordingly.

Parameters

[in]	pdev	Pointer to the device structure.
[in]	evt	Event type of the control task message.
[in]	param	Pointer to the parameters of the control task message.

Returns

meshx_err_t

Definition at line 401 of file meshx_relay_client.c.

{
    MESHX_UNUSED(pdev);
    MESHX_UNUSED(evt);
    uint16_t element_id = param->model.el_id;
    if (!IS_EL_IN_RANGE(element_id))
    {
        return MESHX_SUCCESS;
    }
 
    size_t rel_el_id = GET_RELATIVE_EL_IDX(element_id);
    meshx_relay_client_model_ctx_t *el_ctx = RELAY_CLI_EL(rel_el_id).cli_ctx;
    meshx_api_relay_client_evt_t app_notify;
    meshx_err_t err = MESHX_SUCCESS;
    bool nvs_save = false;
    err = meshx_gen_on_off_state_change_handle(param, &el_ctx->prev_state, &el_ctx->state);
    if(err == MESHX_SUCCESS)
    {
        app_notify.err_code = param->err_code;
        app_notify.on_off = el_ctx->prev_state.on_off;
 
        err = meshx_send_msg_to_app(element_id,
                                    MESHX_ELEMENT_TYPE_RELAY_CLIENT,
                                    MESHX_ELEMENT_FUNC_ID_RELAY_SERVER_ONN_OFF,
                                    sizeof(meshx_api_relay_client_evt_t),
                                    &app_notify);
        if (err != MESHX_SUCCESS)
        {
            MESHX_LOGE(MOD_SRC, "Failed to send Relay state change message: (%d)", err);
        }
    }
    if (nvs_save)
    {
        err = meshx_nvs_element_ctx_set(element_id, el_ctx, sizeof(meshx_relay_client_model_ctx_t));
        if (err != MESHX_SUCCESS)
        {
            MESHX_LOGE(MOD_SRC, "Failed to set Relay element context: (%d)", err);
        }
    }
    return MESHX_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

meshx_relay_client_to_ble_handler()

static meshx_err_t meshx_relay_client_to_ble_handler ( const dev_struct_t * pdev, control_task_msg_evt_t evt, const meshx_gen_on_off_cli_msg_t * msg )

static

Relay Client Element Application Request Handler.

This function handles the relay client application requests for setting or getting the On/Off state of the relay element.

Parameters

[in]	pdev	Pointer to the device structure.
[in]	evt	Event type of the control task message.
[in]	msg	Pointer to the parameters of the control task message.

Returns

meshx_err_t

Definition at line 458 of file meshx_relay_client.c.

{
    meshx_err_t err = MESHX_SUCCESS;
 
    if (!pdev || !msg || !IS_EL_IN_RANGE(msg->element_id))
        return MESHX_INVALID_ARG;
 
    if (RELAY_CLI_EL(GET_RELATIVE_EL_IDX(msg->element_id)).cli_ctx->pub_addr == MESHX_ADDR_UNASSIGNED)
    {
        MESHX_LOGW(MOD_SRC, "No publish address set for element: %d", msg->element_id);
        return MESHX_INVALID_STATE;
    }
    if (evt == CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF)
    {
        err = meshx_relay_cli_send_onoff_msg(pdev,
                                      msg->element_id,
                                      msg->set_get,
                                      msg->ack);
        if (err)
        {
            MESHX_LOGE(
                MOD_SRC,
                "Relay Client Control Task: Set OnOff failed (%p)", (void *)err);
        }
    }
    return err;
}

Here is the call graph for this function:

Here is the caller graph for this function:

meshx_relay_el_get_state()

meshx_err_t meshx_relay_el_get_state

(

uint16_t

el_id

)

Retrieves the current state of the relay element.

This function constructs a generic On/Off client message to request the current state of a relay element identified by the given element ID. It then publishes this message to the control task for BLE communication.

Parameters

[in]

el_id

The element ID of the relay whose state is to be retrieved.

Returns

meshx_err_t Returns the result of the message publish operation.

Definition at line 613 of file meshx_relay_client.c.

{
    meshx_gen_on_off_cli_msg_t msg = {
        .ack        = MESHX_GEN_ON_OFF_CLI_MSG_ACK,
        .set_get    = MESHX_GEN_ON_OFF_CLI_MSG_GET,
        .element_id = el_id
    };
    return control_task_msg_publish(
            CONTROL_TASK_MSG_CODE_TO_BLE,
            CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF,
            &msg,
            sizeof(msg));
}

Here is the call graph for this function:

Here is the caller graph for this function:

meshx_relay_el_set_state()

meshx_err_t meshx_relay_el_set_state	(	uint16_t	el_id,
		bool	ack )

Set the On/Off state for a specific element in the BLE mesh network.

This function sets the On/Off state of the specified element, optionally waiting for an acknowledgment.

Parameters

[in]	el_id	The ID of the element for which to set the On/Off state.
[in]	ack	Whether to wait for an acknowledgment (true) or not (false).

Returns

• MESHX_SUCCESS: Successfully set the state.
• MESHX_INVALID_ARG: Invalid element ID or parameters.
• MESHX_FAIL: Failed to set the state.

Definition at line 589 of file meshx_relay_client.c.

{
    meshx_gen_on_off_cli_msg_t msg = {
        .ack        = ack == MESHX_GEN_ON_OFF_CLI_MSG_ACK,
        .set_get    = MESHX_GEN_ON_OFF_CLI_MSG_SET,
        .element_id = el_id
    };
    return control_task_msg_publish(
            CONTROL_TASK_MSG_CODE_TO_BLE,
            CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF,
            &msg,
            sizeof(msg));
}

Here is the call graph for this function:

Here is the caller graph for this function:

REG_MESHX_ELEMENT_FN()

REG_MESHX_ELEMENT_FN	(	relay_cli_el	,
		MESHX_ELEMENT_TYPE_RELAY_CLIENT	,
		create_relay_client_elements	)

Here is the call graph for this function:

relay_cli_prov_srv_msg_handle()

static meshx_err_t relay_cli_prov_srv_msg_handle ( const dev_struct_t * pdev, control_task_msg_evt_t evt, const void * params )

static

Relay Client Provisioning Server Control Task Message Handler.

This function handles the CW-WW client control task messages.

Parameters

[in]	pdev	Pointer to the device structure.
[in]	evt	Event type of the control task message.
[in]	params	Pointer to the parameters of the control task message.

Returns

meshx_err_t

Definition at line 294 of file meshx_relay_client.c.

{
    if(!pdev)
        return MESHX_INVALID_ARG;
 
    MESHX_UNUSED(params);
    size_t rel_el_id = 0;
    switch (evt)
    {
        case CONTROL_TASK_MSG_EVT_SYSTEM_FRESH_BOOT:
            for (size_t i = relay_element_init_ctrl.element_id_start; i < relay_element_init_ctrl.element_id_end; i++)
            {
                rel_el_id = GET_RELATIVE_EL_IDX(i);
                if(false == (RELAY_CLI_EL(rel_el_id).element_model_init
                            & MESHX_BIT(RELAY_CLI_SIG_ONOFF_MODEL_ID)))
                {
                    MESHX_LOGD(MOD_SRC, "Sending GET for model: 0");
                    return meshx_relay_el_get_state((uint16_t) i);
                }
            }
            break;
        default:
            MESHX_LOGW(MOD_SRC, "Unhandled event: %p", (void *)evt);
            break;
    }
 
    return MESHX_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

relay_cli_unit_test_cb_handler()

static meshx_err_t relay_cli_unit_test_cb_handler ( int cmd_id, int argc, char ** argv )

static

Callback handler for the Relay client unit test command.

This function handles the Relay client unit test command by processing the provided command ID and arguments.

Parameters

[in]	cmd_id	The command ID to be processed.
[in]	argc	The number of arguments provided.
[in]	argv	The array of arguments.

Returns

• MESHX_SUCCESS: Success
• MESHX_INVALID_ARG: Invalid arguments
• Other error codes depending on the implementation

Definition at line 514 of file meshx_relay_client.c.

{
    meshx_err_t err = MESHX_SUCCESS;
    MESHX_LOGD(MOD_SRC, "argc|cmd_id: %d|%d", argc, cmd_id);
    if (argc < 1 || cmd_id >= RELAY_CLI_MAX_CMD)
    {
        MESHX_LOGE(
            MOD_SRC, "Relay Client Unit Test: Invalid number of arguments");
        return MESHX_INVALID_ARG;
    }
 
    relay_cli_cmd_t cmd = (relay_cli_cmd_t)cmd_id;
    uint8_t set_get = (cmd == RELAY_CLI_CMD_GET) ? MESHX_GEN_ON_OFF_CLI_MSG_GET : MESHX_GEN_ON_OFF_CLI_MSG_SET;
    uint16_t el_id  = UT_GET_ARG(0, uint16_t, argv);
 
    err = !set_get ? meshx_relay_el_set_state(el_id, (cmd == RELAY_CLI_CMD_SET)) :
                    meshx_relay_el_get_state(el_id);
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "Relay Client Unit Test: Command %d failed", cmd);
    }
    return err;
}

Here is the call graph for this function:

Here is the caller graph for this function:

relay_client_config_cli_cb()

static meshx_err_t relay_client_config_cli_cb ( const dev_struct_t * pdev, control_task_msg_evt_t evt, const meshx_config_srv_cb_param_t * params )

static

Callback function for configuration client events.

This function handles events from the configuration client, such as model publication and application binding events.

Parameters

[in]	pdev	Pointer to the device structure.
[in]	evt	Event type of the control task message.
[in]	params	Pointer to the parameters of the control task message.

Returns

meshx_err_t

Definition at line 231 of file meshx_relay_client.c.

{
    MESHX_UNUSED(pdev);
    meshx_relay_client_model_ctx_t *el_ctx = NULL;
    size_t rel_el_id = 0;
    uint16_t element_id = 0;
    uint16_t base_el_id = 0;
    bool nvs_save = false;
    meshx_get_base_element_id(&base_el_id);
 
    MESHX_LOGD(MODULE_ID_ELEMENT_SWITCH_RELAY_CLIENT, "EVT: %p", (void *)evt);
    switch (evt)
    {
    case CONTROL_TASK_MSG_EVT_APP_KEY_BIND:
        element_id = params->state_change.mod_app_bind.element_addr - base_el_id;
        if (!IS_EL_IN_RANGE(element_id))
            break;
        rel_el_id = GET_RELATIVE_EL_IDX(element_id);
        el_ctx = RELAY_CLI_EL(rel_el_id).cli_ctx;
        el_ctx->app_id = params->state_change.mod_app_bind.app_idx;
        nvs_save = true;
        break;
    case CONTROL_TASK_MSG_EVT_PUB_ADD:
    case CONTROL_TASK_MSG_EVT_PUB_DEL:
        element_id = params->state_change.mod_pub_set.element_addr - base_el_id;
        if (!IS_EL_IN_RANGE(element_id))
            break;
        rel_el_id = GET_RELATIVE_EL_IDX(element_id);
        el_ctx = RELAY_CLI_EL(rel_el_id).cli_ctx;
        el_ctx->pub_addr = evt == CONTROL_TASK_MSG_EVT_PUB_ADD ? params->state_change.mod_pub_set.pub_addr
                                                           : MESHX_ADDR_UNASSIGNED;
        el_ctx->app_id = params->state_change.mod_pub_set.app_idx;
        nvs_save = true;
        MESHX_LOGI(MOD_SRC, "PUB_ADD: %d, %d, 0x%X, 0x%X", element_id, rel_el_id, el_ctx->pub_addr, el_ctx->app_id);
        break;
    default:
        break;
    }
    if (nvs_save)
    {
        meshx_err_t err = meshx_nvs_element_ctx_set(element_id, el_ctx, sizeof(meshx_relay_client_model_ctx_t));
        if (err != MESHX_SUCCESS)
        {
            MESHX_LOGE(MOD_SRC, "Failed to set relay element context: (%d)", err);
        }
    }
    return MESHX_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

relay_element_init_ctrl

relay_client_element_ctrl_t relay_element_init_ctrl

static

Definition at line 38 of file meshx_relay_client.c.