meshx_prov_srv.cpp File Reference

This file contains the implementation of the provisioning process for the BLE mesh node. Migrated to C++ to align with the modern MeshX element architecture. More...

#include <meshx_c_header.h>

Data Structures
struct	prov_cb_evt_ctrl_task_evt_table
	Structure to map provisioning callback events to control task events. More...

Macros
#define	CONTROL_TASK_PROV_EVT_MASK
	Mask for control task provisioning events.
#define	MESHX_PROV_SRV_CLIENT_EVENT_BMAP   (CONTROL_TASK_MSG_EVT_SYSTEM_FRESH_BOOT)
#define	MESHX_PROV_SRV_SERVER_EVENT_BMAP   (CONTROL_TASK_MSG_EVT_SYSTEM_STACK_READY)

Typedefs
typedef struct prov_cb_evt_ctrl_task_evt_table	prov_cb_evt_ctrl_task_evt_table_t
	Structure to map provisioning callback events to control task events.

Functions
static void	init_prov_cb_table (void)
static meshx_err_t	meshx_prov_srv_control_task_handler (dev_struct_t *pdev, control_task_msg_evt_t evt, meshx_prov_srv_param_t *params)
	Control task handler for the provisioning server.
static void	meshx_handle_node_reset (dev_struct_t *pdev)
	Handle node reset event.
static meshx_err_t	meshx_prov_control_task_handler (dev_struct_t *pdev, control_task_msg_evt_t evt, void *params)
	Handles provisioning control task events.
meshx_err_t	meshx_prov_srv_meshx_reg_cb (void)
static void	meshx_init_freshboot_timer_trigger_cb (const meshx_os_timer_t *p_timer)
static meshx_err_t	meshx_init_freshboot_timer (dev_struct_t *p_dev, uint16_t timeout_ms)
meshx_err_t	meshx_prov_srv_reg_from_ble_cb (void)
meshx_err_t	meshx_init_prov (dev_struct_t *p_dev, const meshx_prov_params_t *prov_cfg)
	Initialize provisioning parameters.
meshx_err_t	meshx_prov_srv_reg_el_client_cb (prov_srv_cb_t cb)
	Register a callback function for provisioning events.
meshx_err_t	meshx_prov_srv_reg_el_server_cb (prov_srv_cb_t cb)
	Register a callback function for provisioning events.
meshx_err_t	meshx_prov_srv_notify_plat_event (meshx_prov_srv_param_t *param)
	Notify the model event to the application.
bool	meshx_prov_srv_is_provisioned (void)
	Checks if the device is provisioned.

Variables
static prov_cb_evt_ctrl_task_evt_table_t	prov_cb_evt_ctrl_task_evt_table [MESHX_PROV_EVT_MAX] = {}
	Table mapping provisioning events to control task events.
static meshx_os_timer_t *	g_boot_timer

Detailed Description

This file contains the implementation of the provisioning process for the BLE mesh node. Migrated to C++ to align with the modern MeshX element architecture.

Copyright © 2024 - 2025 MeshX

Author

Pranjal Chanda

Macro Definition Documentation

CONTROL_TASK_PROV_EVT_MASK

#define CONTROL_TASK_PROV_EVT_MASK

Value:

( CONTROL_TASK_MSG_EVT_PROV_REG_COMP  |  \
CONTROL_TASK_MSG_EVT_IDENTIFY_START |  \
CONTROL_TASK_MSG_EVT_IDENTIFY_STOP  |  \
CONTROL_TASK_MSG_EVT_PROVISION_STOP |  \
CONTROL_TASK_MSG_EVT_NODE_RESET     |  \
CONTROL_TASK_MSG_EVT_SET_NAME_COMP  |  \
CONTROL_TASK_MSG_EVT_EN_NODE_PROV   |  \
CONTROL_TASK_MSG_EVT_SYSTEM_STACK_READY | \
CONTROL_TASK_MSG_EVT_PROXY_CONNECT  |  \
CONTROL_TASK_MSG_EVT_PROXY_DISCONN )

Mask for control task provisioning events.

#define CONTROL_TASK_PROV_EVT_MASK ( CONTROL_TASK_MSG_EVT_PROV_REG_COMP  |  \
                                     CONTROL_TASK_MSG_EVT_IDENTIFY_START |  \
                                     CONTROL_TASK_MSG_EVT_IDENTIFY_STOP  |  \
                                     CONTROL_TASK_MSG_EVT_PROVISION_STOP |  \
                                     CONTROL_TASK_MSG_EVT_NODE_RESET     |  \
                                     CONTROL_TASK_MSG_EVT_SET_NAME_COMP  |  \
                                     CONTROL_TASK_MSG_EVT_EN_NODE_PROV   |  \
                                     CONTROL_TASK_MSG_EVT_SYSTEM_STACK_READY | \
                                     CONTROL_TASK_MSG_EVT_PROXY_CONNECT  |  \
                                     CONTROL_TASK_MSG_EVT_PROXY_DISCONN )

MESHX_PROV_SRV_CLIENT_EVENT_BMAP

#define MESHX_PROV_SRV_CLIENT_EVENT_BMAP   (CONTROL_TASK_MSG_EVT_SYSTEM_FRESH_BOOT)

MESHX_PROV_SRV_SERVER_EVENT_BMAP

#define MESHX_PROV_SRV_SERVER_EVENT_BMAP   (CONTROL_TASK_MSG_EVT_SYSTEM_STACK_READY)

Typedef Documentation

prov_cb_evt_ctrl_task_evt_table_t

typedef struct prov_cb_evt_ctrl_task_evt_table prov_cb_evt_ctrl_task_evt_table_t

Structure to map provisioning callback events to control task events.

Function Documentation

init_prov_cb_table()

void init_prov_cb_table ( void )

static

{
    static bool initialized = false;
    if (initialized) return;
 
#if CONFIG_MESHX_DEFAULT_LOG_LEVEL < MESHX_LOG_INFO
    prov_cb_evt_ctrl_task_evt_table[MESHX_PROV_REGISTER_COMP_EVT]          = {"MESHX_PROV_REGISTER_COMP_EVT",          CONTROL_TASK_MSG_EVT_PROV_REG_COMP};
    prov_cb_evt_ctrl_task_evt_table[MESHX_NODE_SET_UPROV_NAME_COMP_EVT]    = {"MESHX_NODE_SET_UPROV_NAME_COMP_EVT",    CONTROL_TASK_MSG_EVT_SET_NAME_COMP};
    prov_cb_evt_ctrl_task_evt_table[MESHX_NODE_PROV_RESET_EVT]             = {"MESHX_NODE_PROV_RESET_EVT",             CONTROL_TASK_MSG_EVT_NODE_RESET};
    prov_cb_evt_ctrl_task_evt_table[MESHX_NODE_PROV_COMPLETE_EVT]          = {"MESHX_NODE_PROV_COMPLETE_EVT",          CONTROL_TASK_MSG_EVT_PROVISION_STOP};
    prov_cb_evt_ctrl_task_evt_table[MESHX_NODE_PROV_LINK_OPEN_EVT]         = {"MESHX_NODE_PROV_LINK_OPEN_EVT",         CONTROL_TASK_MSG_EVT_IDENTIFY_START};
    prov_cb_evt_ctrl_task_evt_table[MESHX_NODE_PROV_LINK_CLOSE_EVT]        = {"MESHX_NODE_PROV_LINK_CLOSE_EVT",        CONTROL_TASK_MSG_EVT_IDENTIFY_STOP};
    prov_cb_evt_ctrl_task_evt_table[MESHX_NODE_PROV_ENABLE_COMP_EVT]       = {"MESHX_NODE_PROV_ENABLE_COMP_EVT",       CONTROL_TASK_MSG_EVT_EN_NODE_PROV};
    prov_cb_evt_ctrl_task_evt_table[MESHX_PROXY_SERVER_CONNECTED_EVT]      = {"MESHX_PROXY_SERVER_CONNECTED_EVT",      CONTROL_TASK_MSG_EVT_PROXY_CONNECT};
    prov_cb_evt_ctrl_task_evt_table[MESHX_PROXY_SERVER_DISCONNECTED_EVT]   = {"MESHX_PROXY_SERVER_DISCONNECTED_EVT",   CONTROL_TASK_MSG_EVT_PROXY_DISCONN};
#else
    prov_cb_evt_ctrl_task_evt_table[MESHX_PROV_REGISTER_COMP_EVT].ctrl_task_evt          = CONTROL_TASK_MSG_EVT_PROV_REG_COMP;
    prov_cb_evt_ctrl_task_evt_table[MESHX_NODE_SET_UPROV_NAME_COMP_EVT].ctrl_task_evt    = CONTROL_TASK_MSG_EVT_SET_NAME_COMP;
    prov_cb_evt_ctrl_task_evt_table[MESHX_NODE_PROV_RESET_EVT].ctrl_task_evt             = CONTROL_TASK_MSG_EVT_NODE_RESET;
    prov_cb_evt_ctrl_task_evt_table[MESHX_NODE_PROV_COMPLETE_EVT].ctrl_task_evt          = CONTROL_TASK_MSG_EVT_PROVISION_STOP;
    prov_cb_evt_ctrl_task_evt_table[MESHX_NODE_PROV_LINK_OPEN_EVT].ctrl_task_evt         = CONTROL_TASK_MSG_EVT_IDENTIFY_START;
    prov_cb_evt_ctrl_task_evt_table[MESHX_NODE_PROV_LINK_CLOSE_EVT].ctrl_task_evt        = CONTROL_TASK_MSG_EVT_IDENTIFY_STOP;
    prov_cb_evt_ctrl_task_evt_table[MESHX_NODE_PROV_ENABLE_COMP_EVT].ctrl_task_evt       = CONTROL_TASK_MSG_EVT_EN_NODE_PROV;
    prov_cb_evt_ctrl_task_evt_table[MESHX_PROXY_SERVER_CONNECTED_EVT].ctrl_task_evt      = CONTROL_TASK_MSG_EVT_PROXY_CONNECT;
    prov_cb_evt_ctrl_task_evt_table[MESHX_PROXY_SERVER_DISCONNECTED_EVT].ctrl_task_evt   = CONTROL_TASK_MSG_EVT_PROXY_DISCONN;
#endif
    initialized = true;
}

meshx_handle_node_reset()

void meshx_handle_node_reset ( dev_struct_t * pdev )

static

Handle node reset event.

{
    if(!pdev)
    {
        MESHX_LOGE(MODULE_ID_COMMON, "Invalid device structure");
        return;
    }
 
    for(size_t i = 1; i < pdev->element_idx; ++i)
    {
        meshx_err_t err = meshx_nvs_element_ctx_remove(static_cast<uint16_t>(i), MESHX_ELEMENT_TYPE_ALL);
        if(err != MESHX_SUCCESS)
        {
            MESHX_LOGE(MODULE_ID_COMMON, "Failed to erase element context (%zu): (%d)", i, err);
        }
    }
 
    /* Notify application about node reset */
    meshx_send_ctrl_msg_to_app(MESHX_CTRL_EVT_NODE_RESET, 0, NULL);
 
    /* Reset the MCU */
    meshx_platform_reset();
}

meshx_init_freshboot_timer()

meshx_err_t meshx_init_freshboot_timer ( dev_struct_t * p_dev, uint16_t timeout_ms )

static

{
    if(p_dev->meshx_store.node_addr == MESHX_ADDR_UNASSIGNED)
    {
        MESHX_LOGI(MODULE_ID_COMMON, "Device not provisioned, not starting boot timer");
        return MESHX_SUCCESS;
    }
    meshx_err_t err = meshx_os_timer_create("boot_timer",
        timeout_ms,
        false,
        meshx_init_freshboot_timer_trigger_cb,
        &g_boot_timer
    );
    if(err != MESHX_SUCCESS)
    {
        MESHX_LOGE(MODULE_ID_COMMON, "Failed to create boot timer: (%d)", err);
    }
 
    err = meshx_os_timer_start(g_boot_timer);
    if(err != MESHX_SUCCESS)
    {
        MESHX_LOGE(MODULE_ID_COMMON, "Failed to start boot timer: (%d)", err);
    }
 
    return err;
}

meshx_init_freshboot_timer_trigger_cb()

void meshx_init_freshboot_timer_trigger_cb ( const meshx_os_timer_t * p_timer )

static

{
    MESHX_UNUSED(p_timer);
    MESHX_LOGD(MODULE_ID_COMMON, "Fresh Boot Timer Expired");
 
    meshx_err_t err = control_task_msg_publish(
        CONTROL_TASK_MSG_CODE_PROVISION,
        CONTROL_TASK_MSG_EVT_SYSTEM_FRESH_BOOT,
        NULL,
        0
    );
    if(err)
    {
        MESHX_LOGE(MODULE_ID_COMMON, "Failed to publish fresh boot event: (%d)", err);
    }
}

meshx_init_prov()

meshx_err_t meshx_init_prov	(	dev_struct_t *	p_dev,
		const meshx_prov_params_t *	prov_cfg )

Initialize provisioning parameters.

This function initializes the provisioning parameters by copying the UUID from the provided server configuration and registering the provisioning callback.

Parameters

[in]	p_dev	Pointer to the device structure.
[in]	prov_cfg	Pointer to the provisioning parameters structure containing the UUID.

Returns

• MESHX_SUCCESS: Success
• MESHX_FAIL: Failed to register provisioning callback

{
    if (!prov_cfg || memcmp(prov_cfg->uuid, MESHX_UUID_EMPTY, sizeof(meshx_uuid_addr_t)) == 0)
    {
        MESHX_LOGE(MODULE_ID_MODEL_SERVER, "Invalid server configuration");
        return MESHX_INVALID_ARG;
    }
 
    meshx_err_t err = meshx_prov_srv_reg_from_ble_cb();
    if (err != MESHX_SUCCESS)
    {
        MESHX_LOGE(MODULE_ID_MODEL_SERVER, "Failed to register provisioning callback");
        return err;
    }
 
    err = meshx_prov_srv_meshx_reg_cb();
    if (err != MESHX_SUCCESS)
    {
        MESHX_LOGE(MODULE_ID_MODEL_SERVER, "Failed to register provisioning callback");
        return err;
    }
 
    err = meshx_init_freshboot_timer(p_dev, prov_cfg->freshboot_timeout_ms);
    if (err != MESHX_SUCCESS)
    {
        MESHX_LOGE(MODULE_ID_MODEL_SERVER, "Failed to initialize boot timer");
        return err;
    }
 
    return meshx_plat_init_prov(prov_cfg->uuid);
}

meshx_prov_control_task_handler()

meshx_err_t meshx_prov_control_task_handler ( dev_struct_t * pdev, control_task_msg_evt_t evt, void * params )

static

Handles provisioning control task events.

{
    const meshx_prov_cb_param_t *param = (meshx_prov_cb_param_t*) params;
 
    switch (evt)
    {
        case CONTROL_TASK_MSG_EVT_PROVISION_STOP:
            pdev->meshx_store.net_key_id = param->node_prov_complete.net_idx;
            pdev->meshx_store.node_addr  = param->node_prov_complete.addr;
            meshx_nvs_set(MESHX_NVS_STORE, &pdev->meshx_store, sizeof(pdev->meshx_store), MESHX_NVS_AUTO_COMMIT);
            break;
        case CONTROL_TASK_MSG_EVT_IDENTIFY_START:
            MESHX_LOGI(MODULE_ID_COMMON, "Identify Start");
            break;
        case CONTROL_TASK_MSG_EVT_NODE_RESET:
            MESHX_LOGW(MODULE_ID_COMMON, "Node Reset Event");
            meshx_handle_node_reset(pdev);
            break;
        case CONTROL_TASK_MSG_EVT_SET_NAME_COMP:
        case CONTROL_TASK_MSG_EVT_EN_NODE_PROV:
        case CONTROL_TASK_MSG_EVT_PROV_REG_COMP:
            /* Benign events during boot, handled to silence warnings */
            break;
        default:
            break;
    }
    return MESHX_SUCCESS;
}

meshx_prov_srv_control_task_handler()

meshx_err_t meshx_prov_srv_control_task_handler ( dev_struct_t * pdev, control_task_msg_evt_t evt, meshx_prov_srv_param_t * params )

static

Control task handler for the provisioning server.

{
    if (!pdev || !params)
    {
        return MESHX_INVALID_ARG;
    }
    init_prov_cb_table();
    control_task_msg_evt_provision_t prov_evt = (control_task_msg_evt_provision_t)0;
    if(evt != CONTROL_TASK_MSG_EVT_PROVISION_ALL)
    {
        return MESHX_INVALID_ARG;
    }
 
    if (params->prov_evt < MESHX_PROV_EVT_MAX && prov_cb_evt_ctrl_task_evt_table[params->prov_evt].ctrl_task_evt != 0)
    {
#if CONFIG_MESHX_DEFAULT_LOG_LEVEL < MESHX_LOG_INFO
        MESHX_LOGD(MODULE_ID_MODEL_SERVER, "Provisioning event mapped: %s",
                    prov_cb_evt_ctrl_task_evt_table[params->prov_evt].evt_str);
#endif
        prov_evt = prov_cb_evt_ctrl_task_evt_table[params->prov_evt].ctrl_task_evt;
    }
    else
    {
        MESHX_LOGD(MODULE_ID_MODEL_SERVER, "Unhandled event: %d", params->prov_evt);
    }
    if (params->prov_evt == MESHX_NODE_PROV_COMPLETE_EVT)
    {
        MESHX_LOGI(MODULE_ID_MODEL_SERVER, "net_idx: 0x%04x, addr: 0x%04x", params->param.node_prov_complete.net_idx, params->param.node_prov_complete.addr);
        MESHX_LOGD(MODULE_ID_MODEL_SERVER, "flags: 0x%02x, iv_index: 0x%08" PRIx32, params->param.node_prov_complete.flags, params->param.node_prov_complete.iv_index);
    }
    if (prov_evt == 0)
    {
        return MESHX_SUCCESS;
    }
 
    /* Publish the event */
    return control_task_msg_publish(
        CONTROL_TASK_MSG_CODE_PROVISION,
        (control_task_msg_evt_t)prov_evt,
        &params->param,
        sizeof(meshx_prov_cb_param_t));
}

meshx_prov_srv_is_provisioned()

bool meshx_prov_srv_is_provisioned

(

void

)

Checks if the device is provisioned.

This function returns whether the device has been provisioned.

Returns

bool true if provisioned, false otherwise.

{
    uint16_t primary_addr = 0;
    if (MESHX_SUCCESS == meshx_get_base_element_id(&primary_addr))
    {
        return (primary_addr != MESHX_ADDR_UNASSIGNED);
    }
    return false;
}

meshx_prov_srv_meshx_reg_cb()

meshx_err_t meshx_prov_srv_meshx_reg_cb

(

void

)

{
    return control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_PROVISION,
        CONTROL_TASK_PROV_EVT_MASK,
        (control_task_msg_handle_t)&meshx_prov_control_task_handler);
}

meshx_prov_srv_notify_plat_event()

meshx_err_t meshx_prov_srv_notify_plat_event

(

meshx_prov_srv_param_t *

param

)

Notify the model event to the application.

Note

This API is not to be defined in Platform Port layer and shall be called by the respective platform event handler to notify the MeshX of a model event.

This function notifies the application of a model event by invoking the registered provisioning callback with the provided event parameters.

Parameters

[in]

param

Pointer to the event parameters structure.

Returns

• MESHX_SUCCESS: Success
• MESHX_FAIL: Failed to notify model event

{
    if (!param)
    {
        return MESHX_INVALID_ARG;
    }
 
    return control_task_msg_publish(
        CONTROL_TASK_MSG_CODE_PROV_PLAT,
        CONTROL_TASK_MSG_EVT_PROVISION_ALL,
        param,
        sizeof(meshx_prov_srv_param_t)
    );
}

meshx_prov_srv_reg_el_client_cb()

meshx_err_t meshx_prov_srv_reg_el_client_cb

(

prov_srv_cb_t

cb

)

Register a callback function for provisioning events.

This function registers a callback function that will be called when certain provisioning events occur.

Parameters

[in]

cb

The callback function to register.

Returns

• MESHX_SUCCESS: Success
• MESHX_FAIL: Failed to register the callback

{
    return control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_PROVISION,
        MESHX_PROV_SRV_CLIENT_EVENT_BMAP,
        (control_task_msg_handle_t)cb
    );
}

meshx_prov_srv_reg_el_server_cb()

meshx_err_t meshx_prov_srv_reg_el_server_cb

(

prov_srv_cb_t

cb

)

Register a callback function for provisioning events.

This function registers a callback function that will be called when certain provisioning events occur.

Parameters

[in]

cb

The callback function to register.

Returns

• MESHX_SUCCESS: Success
• MESHX_FAIL: Failed to register the callback

{
    return control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_PROVISION,
        MESHX_PROV_SRV_SERVER_EVENT_BMAP,
        (control_task_msg_handle_t)cb
    );
}

meshx_prov_srv_reg_from_ble_cb()

meshx_err_t meshx_prov_srv_reg_from_ble_cb

(

void

)

{
    init_prov_cb_table();
    return control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_PROV_PLAT,
        CONTROL_TASK_MSG_EVT_PROVISION_ALL,
        (control_task_msg_handle_t)&meshx_prov_srv_control_task_handler
    );
}

Variable Documentation

g_boot_timer

meshx_os_timer_t* g_boot_timer

static

prov_cb_evt_ctrl_task_evt_table

prov_cb_evt_ctrl_task_evt_table_t prov_cb_evt_ctrl_task_evt_table[MESHX_PROV_EVT_MAX] = {}

static

Table mapping provisioning events to control task events.

Note

Fixed for C++17 compatibility (removed C99 designated initializers for large arrays if needed, but here we use explicit indices for clarity).

{};