(BLE mesh provision) Cannot publish multicast address to servers in mesh provision in BLE stack

[phituong]

I configure a mesh sensor (server) + central (client) for data transmission, but client cannot publish group address to server.

in central node (client):
Mesh controller handling thread starting...
Provisioner initializing...
[00:00:00.191,000] esp32_bt_adapter: BT controller compile version [4713a69]
[00:00:00.191,000] esp32_bt_adapter: Feature Config, ADV:1, BLE_50:1, DTM:1, SCAN:1, CCA:0, SMP:1, CONNECT:1
[00:00:00.221,000] bt_hci_core: HCI transport: BT ESP32
[00:00:00.221,000] bt_hci_core: Identity: D8:3B:DA:5B:CD:94 (public)
[00:00:00.221,000] bt_hci_core: HCI: version 5.0 (0x09) revision 0x0016, manufacturer 0x02e5
[00:00:00.221,000] bt_hci_core: LMP: version 5.0 (0x09) subver 0x0016
Bluetooth initialized
[00:00:00.221,000] bt_mesh_access: Unused space in relation list: 10
Mesh initialized
Created CDB
[00:00:00.556,000] bt_mesh_main: Primary Element: 0x0001
Provisioning completed
Waiting for unprovisioned beacon...
Unprovisioned_beacon
Detected node UUID: aabbccddeeff11223344556677889900
Provisioning aabbccddeeff11223344556677889900
Waiting for node to be added...
Unprovisioned_beacon
Node added at address 0x0002
Configuring node 0x0002...
AppKey bound to model 0x1100
Publish set failed for sensor model (err 0 status 7)
Waiting for unprovisioned beacon...
Configuring node 0x0002...
AppKey bound to model 0x1100
Publish set failed for sensor model (err 0 status 7)
Waiting for unprovisioned beacon...

in sensor node (server):
Mesh sensor handling thread starting...
Booting Sensor Node...
[00:00:00.002,000] esp32_bt_adapter: BT controller compile version [4713a]
[00:00:00.002,000] esp32_bt_adapter: Feature Config, ADV:1, BLE_50:1, DTM1
[00:00:00.045,000] bt_hci_core: HCI transport: BT ESP32
[00:00:00.045,000] bt_hci_core: Identity: 58:8C:81:AE:CB:08 (public)
[00:00:00.045,000] bt_hci_core: HCI: version 5.0 (0x09) revision 0x0016, 5
[00:00:00.045,000] bt_hci_core: LMP: version 5.0 (0x09) subver 0x0016
Bluetooth initialized
[00:00:00.045,000] bt_mesh_access: Unused space in relation list: 10
[00:00:00.753,000] bt_mesh_provisionee: Device UUID: aabbccdd-eeff-1122-30
Mesh sensor node ready (unprovisioned)
[00:00:04.893,000] bt_mesh_main: Primary Element: 0x0002
Provisioned sensor node at addr 0x0002
No publish address assigned (pub->addr=0x0000)
No publish address assigned (pub->addr=0x0000)
No publish address assigned (pub->addr=0x0000)
No publish address assigned (pub->addr=0x0000)
No publish address assigned (pub->addr=0x0000)

---

Here is my central mesh node:
#include <zephyr/sys/printk.h>
#include <zephyr/settings/settings.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/mesh.h>
#include "ble_mesh_central.h"

static const uint16_t net_idx;
static const uint16_t app_idx;
static uint16_t self_addr = 0x0001; /* Provisioner address */
static uint16_t node_addr;

static const uint8_t dev_uuid[16] = {
0xaa, 0xbb, 0xcc, 0xdd,
0xee, 0xff, 0x11, 0x22,
0x33, 0x44, 0x55, 0x66,
0x77, 0x88, 0x99, 0x00
};
static uint8_t node_uuid[16];

K_SEM_DEFINE(sem_unprov_beacon, 0, 1);
K_SEM_DEFINE(sem_node_added, 0, 1);

static void sensor_status(const struct bt_mesh_model *model,
struct bt_mesh_msg_ctx *ctx,
struct net_buf_simple *buf)
{
int32_t value;
// Extract sensor data from buf
value = net_buf_simple_pull_le32(buf);

printk("Received sensor value %d from 0x%04x\n", value, ctx->addr);

}

/* ----------------- Mesh component ----------------- */
BT_MESH_MODEL_PUB_DEFINE(sensor_cli_pub, NULL, 10);

/* Define config client instance */
static struct bt_mesh_cfg_cli cfg_cli = {
// You can set callbacks if needed, otherwise leave empty
};

static const struct bt_mesh_model_op sensor_cli_op[] = {
{ BT_MESH_MODEL_OP_SENSOR_STATUS, 4, sensor_status },
BT_MESH_MODEL_OP_END,
};

static struct bt_mesh_model root_models[] = {
BT_MESH_MODEL_CFG_CLI(&cfg_cli),
BT_MESH_MODEL(BT_MESH_MODEL_ID_SENSOR_CLI,
sensor_cli_op, &sensor_cli_pub, NULL),
};

static const struct bt_mesh_elem elements[] = {
BT_MESH_ELEM(0, root_models, BT_MESH_MODEL_NONE),
};

static void setup_cdb(void)
{
struct bt_mesh_cdb_app_key *key;
uint8_t app_key[16];
int err;

key = bt_mesh_cdb_app_key_alloc(net_idx, app_idx);
if (key == NULL) {
	printk("Failed to allocate app-key 0x%04x\n", app_idx);
	return;
}

bt_rand(app_key, 16);

err = bt_mesh_cdb_app_key_import(key, 0, app_key);
if (err) {
	printk("Failed to import appkey into cdb. Err:%d\n", err);
	return;
}

if (IS_ENABLED(CONFIG_BT_SETTINGS)) {
	bt_mesh_cdb_app_key_store(key);
}

}

static bool model_supports_pub(uint16_t mod_id) {
switch (mod_id) {
case BT_MESH_MODEL_ID_GEN_ONOFF_SRV:
case BT_MESH_MODEL_ID_SENSOR_SRV:
return true;
default:
return false;
}
}

int configure_model_pub(uint16_t net_idx,
uint16_t node_addr,
uint16_t elem_addr,
uint16_t mod_id,
uint16_t app_idx,
uint16_t group_addr,
uint8_t ttl,
uint8_t period_sec,
uint8_t transmit_count,
uint8_t transmit_interval_ms)
{
struct bt_mesh_cfg_cli_mod_pub pub;
uint8_t status;
int err;

pub.addr = group_addr;                     
pub.uuid = NULL;                            
pub.app_idx = app_idx;                      
pub.cred_flag = false;                      
pub.ttl = ttl;                              
pub.period = BT_MESH_PUB_PERIOD_SEC(period_sec); 
pub.transmit = BT_MESH_TRANSMIT(transmit_count, transmit_interval_ms);

// --- Print out all values for runtime check ---
printk("Configuring publication:\n");
printk("  Node Addr: 0x%04x, Elem Addr: 0x%04x\n", node_addr, elem_addr);
printk("  Model ID: 0x%04x, AppKey Index: 0x%04x\n", mod_id, app_idx);
printk("  Publish Addr: 0x%04x\n", pub.addr);
printk("  TTL: %u\n", pub.ttl);
printk("  Period (encoded): 0x%02x (~%u sec)\n", pub.period, period_sec);
printk("  Transmit (encoded): 0x%02x, Count: %u, Interval: %u ms\n",
       pub.transmit, transmit_count, transmit_interval_ms);
printk("  Cred Flag: %u\n", pub.cred_flag);
printk("  UUID: %p\n", pub.uuid);

err = bt_mesh_cfg_cli_mod_pub_set(net_idx, node_addr, elem_addr,
                                  mod_id, &pub, &status);
if (err || status) {
    printk("Publish set failed for model 0x%04x (err %d status %d)\n",
           mod_id, err, status);
    return -1;
}

printk("Publish successfully configured for model 0x%04x (group 0x%04x)\n", mod_id, group_addr);
return 0;

}

/* ----------------- Configure Node ----------------- */
static void configure_node(struct bt_mesh_cdb_node *node)
{
NET_BUF_SIMPLE_DEFINE(buf, BT_MESH_RX_SDU_MAX);
struct bt_mesh_comp_p0_elem elem;
struct bt_mesh_cdb_app_key *key;
uint8_t app_key[16];
struct bt_mesh_comp_p0 comp;
uint8_t status;
int err, elem_addr;

printk("Configuring node 0x%04x...\n", node->addr);

key = bt_mesh_cdb_app_key_get(app_idx);
if (!key) {
    printk("No AppKey 0x%04x\n", app_idx);
    return;
}

err = bt_mesh_cdb_app_key_export(key, 0, app_key);
if (err) {
    printk("Failed to export AppKey from CDB (err %d)\n", err);
    return;
}

/* Add Application Key to node */
err = bt_mesh_cfg_cli_app_key_add(net_idx, node->addr, net_idx, app_idx, app_key, &status);
if (err || status) {
    printk("Failed to add AppKey (err %d status %d)\n", err, status);
    return;
}

/* Get node composition data */
err = bt_mesh_cfg_cli_comp_data_get(net_idx, node->addr, 0, &status, &buf);
if (err || status) {
    printk("Failed to get composition data (err %d, status %d)\n", err, status);
    return;
}

err = bt_mesh_comp_p0_get(&comp, &buf);
if (err) {
    printk("Unable to parse composition data (err: %d)\n", err);
    return;
}

elem_addr = node->addr;

while (bt_mesh_comp_p0_elem_pull(&comp, &elem)) {
	for (int i = 0; i < elem.nsig; i++) {
		uint16_t mod_id = bt_mesh_comp_p0_elem_mod(&elem, i);

		/* Skip Configuration Client and Server models */
		if (mod_id == BT_MESH_MODEL_ID_CFG_CLI ||
			mod_id == BT_MESH_MODEL_ID_CFG_SRV) {
			continue;
		}

		/* Bind AppKey */
		err = bt_mesh_cfg_cli_mod_app_bind(net_idx, node->addr, elem_addr,
										   app_idx, mod_id, &status);
		if (err || status) {
			printk("Failed to bind AppKey to model 0x%04x (err %d status %d)\n",
				   mod_id, err, status);
			continue;
		}
		printk("AppKey bound to model 0x%04x\n", mod_id);

        if (mod_id == BT_MESH_MODEL_ID_SENSOR_SRV) {
			struct bt_mesh_cfg_cli_mod_pub pub = {
				.addr = GROUP_ADDR,    // Group address to publish to
				.app_idx = app_idx,    // Bound AppKey index
				.cred_flag = 0,        // 0 for normal AppKey
				.ttl = 7,              // Time-to-live
				.period = 5,           // Publish period (encoded as steps)
				.transmit = BT_MESH_TRANSMIT(0, 20), // retransmit count and interval
			};
			
			err = bt_mesh_cfg_cli_mod_pub_set(net_idx, node->addr, elem_addr,
											 BT_MESH_MODEL_ID_SENSOR_SRV,
											 &pub, &status);
			if (err || status) {
				printk("Publish set failed for sensor model (err %d status %d)\n", err, status);
				return;
			}		
			printk("Publish successfully configured for model 0x%04x (group 0x%04x)\n", mod_id, GROUP_ADDR);
		}
		
		/* Add subscription to the group address */
		err = bt_mesh_cfg_cli_mod_sub_add(net_idx, node->addr, elem_addr,
										  GROUP_ADDR, mod_id, &status);
		if (err || status) {
			printk("Failed to add subscription for model 0x%04x (err %d status %d)\n",
				   mod_id, err, status);
			return;
		}
		else {
			printk("Subscription added for model 0x%04x\n", mod_id);
		}
	}
	/* ------------------- Vendor Models ------------------- */
	/*
	for (int i = 0; i < elem.nvnd; i++) {
		struct bt_mesh_mod_id_vnd id = bt_mesh_comp_p0_elem_mod_vnd(&elem, i);

		err = bt_mesh_cfg_cli_mod_app_bind_vnd(net_idx, node->addr, elem_addr,
											   app_idx, id.id, id.company, &status);
		if (err) {
			printk("Failed to bind AppKey to vendor model 0x%03x:%04x (err %d, status %d)\n",
				   id.company, id.id, err, status);
			return;
		}
		printk("AppKey bound to vendor model 0x%03x:%04x\n", id.company, id.id);

		err = bt_mesh_cfg_cli_mod_sub_add_vnd(net_idx, node->addr, elem_addr,
											 GROUP_ADDR, id.id, id.company, &status);
		if (err) {
			printk("Failed to add subscription for vendor model 0x%03x:%04x (err %d status %d)\n",
				   id.company, id.id, err, status);
			return;
		}
		else {
			printk("Subscription added for vendor model 0x%03x:%04x\n", id.company, id.id);
		}
	}
	*/
	
	elem_addr++;
}

atomic_set_bit(node->flags, BT_MESH_CDB_NODE_CONFIGURED);

if (IS_ENABLED(CONFIG_BT_SETTINGS)) {
    bt_mesh_cdb_node_store(node);
}

printk("Configuration complete\n");

}

static uint8_t check_unconfigured(struct bt_mesh_cdb_node *node, void *data)
{
k_sleep(K_MSEC(100));

if (!atomic_test_bit(node->flags, BT_MESH_CDB_NODE_CONFIGURED)) {
	if (node->addr == self_addr) {
		//configure_self(node);
	} else {
		configure_node(node);
	}
}

return BT_MESH_CDB_ITER_CONTINUE;

}

/* ----------------- Callbacks ----------------- */
static void unprovisioned_beacon(uint8_t uuid[16],
bt_mesh_prov_oob_info_t oob_info,
uint32_t *uri_hash)
{
printk("Unprovisioned_beacon\n");
memcpy(node_uuid, uuid, 16);
k_sem_give(&sem_unprov_beacon);
}

static void node_added(uint16_t idx, uint8_t uuid[16], uint16_t addr, uint8_t num_elem)
{
printk("Node added at address 0x%04x\n", addr);
node_addr = addr;
k_sem_give(&sem_node_added);
}

static const struct bt_mesh_prov prov = {
.uuid = dev_uuid,
.unprovisioned_beacon = unprovisioned_beacon,
.node_added = node_added,
};

static const struct bt_mesh_comp mesh_comp = {
.cid = BT_COMP_ID_LF,
.elem = elements,
.elem_count = ARRAY_SIZE(elements),
};

/* ----------------- Provisioner initialization ----------------- */
static int bt_ready(void)
{
uint8_t net_key[16], dev_key[16];
int err;

err = bt_mesh_init(&prov, &mesh_comp);
if (err) {
	printk("Initializing mesh failed (err %d)\n", err);
	return err;
}

printk("Mesh initialized\n");

if (IS_ENABLED(CONFIG_BT_SETTINGS)) {
	printk("Loading stored settings\n");
	settings_load();
}


bt_rand(net_key, 16);

err = bt_mesh_cdb_create(net_key);
if (err == -EALREADY) {
	printk("Using stored CDB\n");
} else if (err) {
	printk("Failed to create CDB (err %d)\n", err);
	return err;
} else {
	printk("Created CDB\n");
	setup_cdb();
}

bt_rand(dev_key, 16);

err = bt_mesh_provision(net_key, BT_MESH_NET_PRIMARY, 0, 0, self_addr, dev_key);

if (err == -EALREADY) {
	printk("Using stored settings\n");
} else if (err) {
	printk("Provisioning failed (err %d)\n", err);
	return err;
} else {
	printk("Provisioning completed\n");
}

return 0;

}

int start_mesh_central(void)
{
int err;
char uuid_str[33];

printk("Provisioner initializing...\n");

err = bt_enable(NULL);
if (err) {
    printk("Bluetooth init failed (err %d)\n", err);
    return 0;
}

printk("Bluetooth initialized\n");
bt_ready();

while (1) {
    k_sem_reset(&sem_unprov_beacon);
    k_sem_reset(&sem_node_added);
	bt_mesh_cdb_node_foreach(check_unconfigured, NULL);

    printk("Waiting for unprovisioned beacon...\n");
    err = k_sem_take(&sem_unprov_beacon, K_SECONDS(10));
    if (err == -EAGAIN) {
        continue;
    }

    bin2hex(node_uuid, 16, uuid_str, sizeof(uuid_str));
    printk("Detected node UUID: %s\n", uuid_str);

    printk("Provisioning %s\n", uuid_str);
    
	err = bt_mesh_provision_adv(node_uuid, net_idx, 0, 0);
	
	if (err < 0) {
		printk("Provisioning failed (err %d)\n", err);
		continue;
	}

    printk("Waiting for node to be added...\n");
    
    err = k_sem_take(&sem_node_added, K_SECONDS(10));
    
    if (err == -EAGAIN) {
        printk("Timeout waiting for node to be added\n");
        continue;
    }
}

return 0;

}

Here is sensor node:
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/mesh.h>
#include <zephyr/settings/settings.h>
#include <zephyr/sys/printk.h>
#include <zephyr/kernel.h>
#include "ble_mesh_sensor.h"
#include "ble_mesh_central.h"

/* ------------------- Sensor Server ------------------- /
static int32_t sensor_value = 25;
static struct k_work_delayable sensor_work;
/ ------------------- Provisioning ------------------- */
static uint8_t dev_uuid[16] = {
0xaa, 0xbb, 0xcc, 0xdd,
0xee, 0xff, 0x11, 0x22,
0x33, 0x44, 0x55, 0x66,
0x77, 0x88, 0x99, 0x00
};

BT_MESH_MODEL_PUB_DEFINE(sensor_pub, NULL, 4);

static int sensor_get(const struct bt_mesh_model *model,
struct bt_mesh_msg_ctx *ctx,
struct net_buf_simple *buf)
{
printk("Sensor server get\n");

BT_MESH_MODEL_BUF_DEFINE(msg, BT_MESH_MODEL_OP_SENSOR_STATUS, 5);
bt_mesh_model_msg_init(&msg, BT_MESH_MODEL_OP_SENSOR_STATUS);
net_buf_simple_add_le32(&msg, sensor_value);
bt_mesh_model_send(model, ctx, &msg, NULL, NULL);
return 0;

}

static const struct bt_mesh_model_op sensor_srv_op[] = {
{ BT_MESH_MODEL_OP_SENSOR_GET, BT_MESH_LEN_EXACT(0), sensor_get },
BT_MESH_MODEL_OP_END,
};

static struct bt_mesh_model root_models[] = {
BT_MESH_MODEL_CFG_SRV,
BT_MESH_MODEL(BT_MESH_MODEL_ID_SENSOR_SRV,
sensor_srv_op, &sensor_pub, NULL)
};

static const struct bt_mesh_elem elements[] = {
BT_MESH_ELEM(0, root_models, BT_MESH_MODEL_NONE),
};

static const struct bt_mesh_comp comp = {
.cid = BT_COMP_ID_LF,
.elem = elements,
.elem_count = ARRAY_SIZE(elements),
};

/* ------------------- Periodic Sensor Publish ------------------- */
static void sensor_publish(struct k_work *work)
{
struct bt_mesh_model *model = &root_models[1]; // Sensor Server
struct bt_mesh_model_pub *pub = model->pub;

if (!pub) {
    printk("No publication context\n");
    k_work_reschedule(&sensor_work, K_SECONDS(5));
    return;
}

if (pub->addr == BT_MESH_ADDR_UNASSIGNED) {
	printk("No publish address assigned (pub->addr=0x%04x)\n", pub->addr);
	k_work_reschedule(&sensor_work, K_SECONDS(5));
	return;
}
else {
	printk("Publish address is 0x%04x\n", pub->addr);
}

bt_mesh_model_msg_init(pub->msg, BT_MESH_MODEL_OP_SENSOR_STATUS);
net_buf_simple_add_le32(pub->msg, sensor_value);

int err = bt_mesh_model_publish(model);
if (err) {
    printk("Sensor publish failed (err %d)\n", err);
} else {
    printk("Sensor published value=%d to 0x%04x\n", sensor_value, pub->addr);
}

k_work_reschedule(&sensor_work, K_SECONDS(5));

}

static void prov_complete(uint16_t net_idx, uint16_t addr)
{
printk("Provisioned sensor node at addr 0x%04x\n", addr);
k_work_init_delayable(&sensor_work, sensor_publish);
k_work_reschedule(&sensor_work, K_SECONDS(5));
}

static void prov_reset(void)
{
bt_mesh_prov_enable(BT_MESH_PROV_ADV | BT_MESH_PROV_GATT);
}

static const struct bt_mesh_prov prov = {
.uuid = dev_uuid,
.complete = prov_complete,
.reset = prov_reset,
};

/* ------------------- Bluetooth Ready ------------------- */
static void bt_ready(int err)
{
if (err) {
printk("Bluetooth init failed (err %d)\n", err);
return;
}

printk("Bluetooth initialized\n");

err = bt_mesh_init(&prov, &comp);
if (err) {
    printk("Mesh init failed (err %d)\n", err);
    return;
}

if (IS_ENABLED(CONFIG_SETTINGS)) {
    settings_load();
}

bt_mesh_prov_enable(BT_MESH_PROV_ADV | BT_MESH_PROV_GATT);
printk("Mesh sensor node ready (unprovisioned)\n");

}

/* ------------------- Entry Point ------------------- */
void start_mesh_sensor(void)
{
printk("Booting Sensor Node...\n");
bt_enable(bt_ready);
}