nrf5340 netcore callback after each transmission

[RafaelV]

Good afternoon!

I didn't find a post with a solution to my problem. If I overlooked something, please feel free to just redirect me :)

Goal:
In our project we want the device to send measurement data to phones and gateways via BLE. Since multiple devices should be able to listen at the same time, we want to use connectionless broadcasting in the form of extended advertising, so we can send larger data packets. (Redundancy and encryption are handled inside the payload itself, so that part is not relevant yet.)
Our plan is to broadcast a new data packet for every advertising event, while keeping the device as energy-efficient as possible.

Background:
We are using the nRF5340, with the Netcore running the Controller and the Appcore running the Host part of the Bluetooth stack. From what I understand, the SoftDevice Controller is better optimized for the nRF5340 than the Zephyr controller (eventhough I then can not edit anything on the firmware of the Netcore).
To achieve "new data per event", the Appcore needs to deliver updated advertising data to the Netcore before each broadcast. The challenge is synchronization. For example, if we had an advertising intervall of 20 ms, there is also the random advertising delay (0–10 ms), so we can not simply update the data on a fixed timer.
Instead, we would need the Netcore to notify the Appcore whenever either a packet was actually transmitted, or is about to be transmitted, so that the payload can be updated before the next broadcast.

Problem:
The radio notification mechanism does not seem to work the same way on the nRF5340, right?
With bt_le_ext_adv_create() we can register a .sent callback, but it only fires when the set number of events has been reached.
If we configure num_events = 1, the callback arrives after every single event — but this means the advertising set stops and has to be restarted each time. In this case, the configured advertising interval is also not followed anymore. We could add a wait timer before restarting, but this does not seem elegant at all.

Question:
Is there a proper way on the nRF5340 to get a callback from the controller before/after each advertising transmission, so that the payload can be updated in sync with every event, without having to constantly stop and restart the advertising set?

Setup: nRF5340, nRF Connect SDK v3.0.0
The code below is just a basic extended advertising code I use to experiment.

Any examples or guidance would be much appreciated. Thanks!

Fullscreen 7080.main.c Download

#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/gap.h>
#include <zephyr/bluetooth/hci.h>

static int start_advertising(struct bt_le_ext_adv *adv)
{
	int err;

	printk("Starting Extended Advertising\n");
	err = bt_le_ext_adv_start(adv, BT_LE_EXT_ADV_START_DEFAULT);
	if (err) {
		printk("Failed to start extended advertising (err %d)\n", err);
	}

	return err;
}

static const struct bt_data ad[] = {
	BT_DATA(BT_DATA_NAME_COMPLETE, CONFIG_BT_DEVICE_NAME, sizeof(CONFIG_BT_DEVICE_NAME) - 1),
};

static int create_advertising_set(struct bt_le_ext_adv **adv)
{
    int err;


    struct bt_le_adv_param param = {
        .id = BT_ID_DEFAULT,
        .sid = 0,
        .secondary_max_skip = 0,
        .options = BT_LE_ADV_OPT_EXT_ADV | BT_LE_ADV_OPT_USE_IDENTITY | BT_LE_ADV_OPT_NO_2M,
        .interval_min = 3200, // 2000 ms in 0.625 ms steps
        .interval_max = 3200,
        .peer = NULL,
    };

    err = bt_le_ext_adv_create(&param, NULL, adv);
    if (err) {
        printk("Failed to create advertising set (err %d)\n", err);
        return err;
    }

    return 0;
}

int main(void)
{
	int err;
	struct bt_le_ext_adv *adv;

	printk("Starting main loop\n");

	/* Initialize the Bluetooth Subsystem */
	err = bt_enable(NULL);
	if (err) {
		printk("Bluetooth init failed (err %d)\n", err);
		return err;
	}
	
	/* Create a nonconnectable advertising set with the custom parameters */
	err = create_advertising_set(&adv);
	if (err) {
		return err;
	}

	/* Set advertising data to have complete local name set */
	err = bt_le_ext_adv_set_data(adv, ad, ARRAY_SIZE(ad), NULL, 0);
	if (err) {
		printk("Failed to set advertising data (err %d)\n", err);
		return 0;
	}

	err = start_advertising(adv);
	if (err) {
		return err;
	}

    /* Just keep running, no connections possible */
    for (;;) {
        k_sleep(K_SECONDS(1));
    }

    return err;
}

1122.prj.conf

[Hung Bui]

Hi Rafael, 
AFAIK, I don't think you can get an event on each advertising packet. Unless you are doing periodic advertising with response. For periodic advertising with response you will have a request_cb on each advertising event. 

One work around is to use radio notification callback https://docs.nordicsemi.com/bundle/ncs-latest/page/nrf/libraries/bluetooth/radio_notification_conn_cb.html#ug-radio-notification-conn-cb 

Sample:  docs.nordicsemi.com/.../README.html

This allow you to have an event on every radio activity. If you are only doing advertising (with no scan response) then it's quite easy to track when you have the next advertising event. 

[RafaelV]

Hello Hung,

Thanks for your response!

The radio notification callback would be exactly what I'd need.. BUT it only works when the Bluetooth controller and application run on the same core, which will not be the case for a bigger project with the nrf5340 (dual core). 

So, is there no way to broadcast data packets to multiple devices while sending every data packet only once?

[Hung Bui]

Hi Rafael, 
You are right, I forgot to notice that you are using nRF53 which will make things a bit more complicated. 
I quote here an answer from one of our coworkers: 

What options do you have for the nRF4340?

- compile both host + controller on the network core, and the application core could then just be a simple "empty_app_core" or equivalent sample flashed on it
(https://github.com/nrfconnect/sdk-nrf/tree/master/samples/nrf5340/empty_app_core)

- An alternative is to implement the radio notification callback on the network core, and signal the application core that it has been triggered. You could possible implement a vendor-specific HCI event and pass it to the host through bt_recv() 
(https://github.com/nrfconnect/sdk-nrf/blob/master/subsys/bluetooth/controller/hci_driver.c#L328) Or trigger an interrupt on the application core somehow, perhaps? 

Note that you cam add your code into the netcore by modifying the ipc_radio firmware built on the nRF53 netcore. 

[RafaelV]

Thanks for all the help!

-Since our device will have to process a lot of sensory input, the application has to run on the appcore, and we can't put everything on the netcore, sadly. 

-The second alternative could work. But then I'd have to write extra firmware for the netcore, right? Not a problem in itself, but from what I understand, the Softdevice controller is a precompiled firmware for the netcore, which I can not modify. Instead, I'd have to run the Zephyr controller, which is open source, but also not optimised for the nrf5340 and less efficient. Is that correct? 

[Hung Bui]

Hi Rafael, 
I haven't tried it myself but as far as I know, you can just modify the ipc_radio sample. 
The softdevice controller is precompiled but it only contrain the BLE stack. It's included as a library into the ipc_radio firmware which run on the network core. It should be possible to modify the firmware to add your own features in.