meshx_relay_element.cpp File Reference

Implementation of MeshX Relay Element. This file contains the implementation of the MeshX Relay Element class, which represents a relay element in the MeshX BLE mesh network. Key Features: More...

#include <variants/meshx_relay_element.hpp>
#include "meshx_element_factory.hpp"
#include "meshx_element_registry.hpp"

Macros
#define	CONFIG_SERVER_CB_MASK
#define	RELAY_SRV_TO_BLE_EVT_MASK   CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF_SRV
#define	RELAY_CLI_TO_BLE_EVT_MASK   CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF

Functions
meshx_err_t	relay_cli_ut_handler (int cmd_id, int argc, char **argv)
meshx_err_t	relay_srv_ut_handler (int cmd_id, int argc, char **argv)
meshx_err_t	create_relay_server_elements_cpp (dev_struct_t *pdev, uint16_t element_cnt)
	C++ factory for Relay Server elements.
meshx_err_t	create_relay_client_elements_cpp (dev_struct_t *pdev, uint16_t element_cnt)
	C++ factory for Relay Client elements.
meshx_err_t	meshx_relay_el_set_state (uint16_t el_id, bool ack)
meshx_err_t	meshx_relay_el_get_state (uint16_t el_id)

Detailed Description

Implementation of MeshX Relay Element. This file contains the implementation of the MeshX Relay Element class, which represents a relay element in the MeshX BLE mesh network. Key Features:

• Implements relay element functionality
• Inherits from meshXElementServer / meshXElementClient
• Automatically initializes required SIG models for relay elements
• Maintains state context for NVS persistence (mirrors C el_ctx)
• Config server callback for app-key bind and publication address
• Provisioning event handling (server: re-publish; client: send GET)
• TO_BLE client send path for app-driven OnOff commands

Author

Pranjal Chanda

Date

2024-2025

Copyright

Copyright 2024 - 2025 MeshX

Macro Definition Documentation

CONFIG_SERVER_CB_MASK

#define CONFIG_SERVER_CB_MASK

Value:

  CONTROL_TASK_MSG_EVT_PUB_ADD  \
| CONTROL_TASK_MSG_EVT_PUB_DEL  \
| CONTROL_TASK_MSG_EVT_APP_KEY_BIND

#define CONFIG_SERVER_CB_MASK   \
    CONTROL_TASK_MSG_EVT_PUB_ADD  \
  | CONTROL_TASK_MSG_EVT_PUB_DEL  \
  | CONTROL_TASK_MSG_EVT_APP_KEY_BIND

RELAY_CLI_TO_BLE_EVT_MASK

#define RELAY_CLI_TO_BLE_EVT_MASK   CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF

RELAY_SRV_TO_BLE_EVT_MASK

#define RELAY_SRV_TO_BLE_EVT_MASK   CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF_SRV

Function Documentation

create_relay_client_elements_cpp()

meshx_err_t create_relay_client_elements_cpp	(	dev_struct_t *	pdev,
		uint16_t	element_cnt )

C++ factory for Relay Client elements.

Constructs CONFIG_RELAY_CLIENT_COUNT meshXRelayClientElement objects and registers each with the platform BLE Mesh composition.

Parameters

pdev	Pointer to the device structure.
element_cnt	Number of relay client elements to create. Capped by CONFIG_RELAY_CLIENT_COUNT.

Returns

MESHX_SUCCESS on success, error code otherwise.

{
    return meshx_element_factory_helper<meshXRelayClientElement, meshx_relay_cli_el_ctx_t>(
        pdev,
        element_cnt,
        CONFIG_RELAY_CLIENT_COUNT,
        MODULE_ID_ELEMENT_SWITCH_RELAY_CLIENT,
        "Relay Cli"
    );
}

create_relay_server_elements_cpp()

meshx_err_t create_relay_server_elements_cpp	(	dev_struct_t *	pdev,
		uint16_t	element_cnt )

C++ factory for Relay Server elements.

Constructs CONFIG_RELAY_SERVER_COUNT meshXRelayServerElement objects and registers each with the platform BLE Mesh composition.

Parameters

pdev	Pointer to the device structure.
element_cnt	Number of relay server elements to create. Capped by CONFIG_RELAY_SERVER_COUNT.

Returns

MESHX_SUCCESS on success, error code otherwise.

{
    return meshx_element_factory_helper<meshXRelayServerElement, meshx_relay_srv_el_ctx_t>(
        pdev,
        element_cnt,
        CONFIG_RELAY_SERVER_COUNT,
        MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER,
        "Relay Srv"
    );
}

meshx_relay_el_get_state()

meshx_err_t meshx_relay_el_get_state

(

uint16_t

el_id

)

{
    meshx_gen_on_off_cli_msg_t msg = {};
    msg.ack        = MESHX_GEN_ON_OFF_CLI_MSG_ACK;
    msg.set_get    = MESHX_GEN_ON_OFF_CLI_MSG_GET;
    msg.reserved   = 0;
    msg.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));
}

meshx_relay_el_set_state()

meshx_err_t meshx_relay_el_set_state	(	uint16_t	el_id,
		bool	ack )

{
    auto *el = meshXElementRegistry::get_instance().find_and_cast<meshXRelayClientElement>(
        el_id, MESHX_ELEMENT_TYPE_RELAY_CLIENT);
    if (!el) return MESHX_NOT_FOUND;
 
    meshx_gen_on_off_cli_msg_t msg = {};
    msg.ack        = (uint8_t)(ack ? 1 : 0);
    msg.set_get    = MESHX_GEN_ON_OFF_CLI_MSG_SET;
    msg.reserved   = 0;
    msg.element_id = el_id;
 
    // We use the model's next_on_off state internally as the target for the SET operation.
    // This allows the UT command to set the target state in the context before triggering.
    msg.on_off     = el->get_ctx().gen_on_off_state.next_on_off;
 
    return control_task_msg_publish(
            CONTROL_TASK_MSG_CODE_TO_BLE,
            CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF,
            &msg,
            sizeof(msg));
}

relay_cli_ut_handler()

meshx_err_t relay_cli_ut_handler	(	int	cmd_id,
		int	argc,
		char **	argv )

{
    MESHX_LOGI(MODULE_ID_ELEMENT_SWITCH_RELAY_CLIENT, "Entering C++ Relay Client UT Handler: cmd_id=%d, argc=%d", cmd_id, argc);
    if (argc < 1) return MESHX_INVALID_ARG;
    uint16_t el_id = UT_GET_ARG(0, uint16_t, argv);
 
    if (cmd_id == 0x01) { // SET
        return meshx_relay_el_set_state(el_id, true);
    } else if (cmd_id == 0x02) { // SET UNACK
        return meshx_relay_el_set_state(el_id, false);
    } else { // GET
        return meshx_relay_el_get_state(el_id);
    }
}

relay_srv_ut_handler()

meshx_err_t relay_srv_ut_handler	(	int	cmd_id,
		int	argc,
		char **	argv )

{
    MESHX_LOGI(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Entering C++ Relay Server UT Handler: cmd_id=%d, argc=%d", cmd_id, argc);
    // Server UT can be used to query local state
    if (argc < 1) return MESHX_INVALID_ARG;
    uint16_t el_id = UT_GET_ARG(0, uint16_t, argv);
 
    auto *el = meshXElementRegistry::get_instance().find_and_cast<meshXRelayServerElement>(
        el_id, MESHX_ELEMENT_TYPE_RELAY_SERVER);
    if (!el) return MESHX_NOT_FOUND;
 
    if (cmd_id == 0x01) {
        uint8_t expected = UT_GET_ARG(1, uint8_t, argv);
        uint8_t actual = el->get_state();
        MESHX_LOGI(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Relay Server [%d] state: %d, expected: %d", el_id, actual, expected);
        return (actual == expected) ? MESHX_SUCCESS : MESHX_FAIL;
    }
 
    MESHX_LOGI(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Relay Server [%d] state: %d", el_id, el->get_state());
    return MESHX_SUCCESS;
}