Performing loopback test

[DevBear]

Hello!

I am currently developing my own custom service with two nrf 52840 development kits where one acts as the Client and one acts as the Server.

I have managed to set up the service and the service is discoverable and the client can subscribe to notifications from the server.
The next step is to perform a loopback test where I want to take the data sent from the Server ---> Client and send it back with my Write without response attributes.

So my questions are:

1: Is there some sample code on how to write from Client --> Server? What do I need to do on both ends? My Client code is inserted below.

2: Once the writing is set up properly, is it possible to just loop the data back to the Server or is there something I need to think about?

3: When the loopback test is set up, is the nrf sniffer a viable way of testing throughput or are there some pot holes I should be careful about?

#include <stdio.h>
#include <stddef.h>
#include <errno.h>

#include <zephyr/kernel.h>
#include <zephyr/sys/printk.h>
#include <zephyr/sys/byteorder.h>

#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>

/* --------------------- START OF FROG UUID:s ---------------- */

#define FROG_SERVICE BT_UUID_128_ENCODE(0x2016ec20, 0xb2eb, 0x11e5, 0xa307, 0x0002a5d5c51b)
// Notify characteristics
#define FROG_TXDATA_UUID BT_UUID_128_ENCODE(0x388706a0, 0xb2eb, 0x11e5, 0xa790, 0x0002a5d5c51b)
#define FROG_RXCREDIT BT_UUID_128_ENCODE(0x43802b40, 0xb2eb, 0x11e5, 0xb6e5, 0x0002a5d5c51b)

// Write without response characteristics


#define BT_UUID_FROG BT_UUID_DECLARE_128(FROG_SERVICE)
#define BT_UUID_TXDATA BT_UUID_DECLARE_128(FROG_TXDATA_UUID)
#define BT_UUID_RXCREDIT BT_UUID_DECLARE_128(FROG_RXCREDIT)

/* ----------------------------- END ------------------------- */


static int scan_start(void);

static struct bt_conn *default_conn;
static struct bt_uuid_16 frog_ccc_discover_uuid = BT_UUID_INIT_16(0);
static struct bt_uuid_128 frog_discover_uuid = BT_UUID_INIT_128(0);
static const struct bt_uuid *ccc_uuid = BT_UUID_GATT_CCC;
//static const struct bt_uuid *ccc_uuid2 = BT_UUID_GATT_CCC;
static const struct bt_uuid *ccc_uuid2;
static struct bt_gatt_discover_params discover_params;
static struct bt_gatt_subscribe_params subscribe_params_txdata;
static struct bt_gatt_subscribe_params subscribe_params_rxcredit;

static uint8_t notify_func(struct bt_conn *conn,
			   struct bt_gatt_subscribe_params *params,
			   const void *data, uint16_t length)
{

	if (!data) {
		printk("[UNSUBSCRIBED]\n");
		params->value_handle = 0U;
		return BT_GATT_ITER_STOP;
	}


	printf("[NOTIFICATION]: Data from server %p.\n", data);
	uint8_t* uint8data = (uint8_t *)data;
	printf("[NOTIFICATION]: Data from server");
	int i;
	for (i = 0; i < length; ++i)
	{
		printf(" 0x%02x", uint8data[i]);
	}
	printf("\n");	

	return BT_GATT_ITER_CONTINUE;
}

static uint8_t discover_func(struct bt_conn *conn,
			     const struct bt_gatt_attr *attr,
			     struct bt_gatt_discover_params *params)
{
	int err;

	if (!attr) {
		printk("Discover complete\n");
		(void)memset(params, 0, sizeof(*params));
		return BT_GATT_ITER_STOP;
	}

	printk("[ATTRIBUTE] handle %u\n", attr->handle);

	if (!bt_uuid_cmp(discover_params.uuid, BT_UUID_FROG)) {
		printk("Discovering TxDATA\n");
		memcpy(&frog_discover_uuid, BT_UUID_TXDATA, sizeof(frog_discover_uuid));
		discover_params.uuid = &frog_discover_uuid.uuid;
		discover_params.start_handle = attr->handle + 1;
		discover_params.type = BT_GATT_DISCOVER_CHARACTERISTIC;

		err = bt_gatt_discover(conn, &discover_params);
		if (err) {
			printk("Discover failed (err %d)\n", err);
		}
	} else if (!bt_uuid_cmp(discover_params.uuid, BT_UUID_TXDATA)) {
		printk("Discovering CCC TxData\n");
	
		memcpy(&frog_ccc_discover_uuid, BT_UUID_GATT_CCC, sizeof(frog_ccc_discover_uuid));
		discover_params.uuid = &frog_ccc_discover_uuid.uuid;
		discover_params.start_handle = bt_gatt_attr_value_handle(attr);//attr->handle + 1;
		discover_params.type = BT_GATT_DISCOVER_DESCRIPTOR;

		subscribe_params_txdata.value_handle = bt_gatt_attr_value_handle(attr);

		err = bt_gatt_discover(conn, &discover_params);
		if (err) {
			printk("Discover failed (err %d)\n", err);
		}
	} else if (!bt_uuid_cmp(discover_params.uuid, BT_UUID_RXCREDIT)) {
		
		printk("[CHARACTERISTIC] RxCredit handle %u\n", attr->handle);
		printk("Discovering CCC RxCredit\n");
		//memcpy(&frog_discover_uuid, BT_UUID_GATT_CCC, sizeof(frog_discover_uuid));

		memcpy(&frog_ccc_discover_uuid, BT_UUID_GATT_CCC, sizeof(frog_ccc_discover_uuid));
		discover_params.uuid = &frog_ccc_discover_uuid.uuid;

		discover_params.start_handle = bt_gatt_attr_value_handle(attr);
		discover_params.type = BT_GATT_DISCOVER_DESCRIPTOR;

		printk("Value handle RxCredit: %d \n", bt_gatt_attr_value_handle(attr));

		subscribe_params_rxcredit.value_handle = bt_gatt_attr_value_handle(attr);

		err = bt_gatt_discover(conn, &discover_params);
		if (err) {
			printk("Discover failed (err %d)\n", err);
		}
	} else if (!bt_uuid_cmp(discover_params.uuid, BT_UUID_GATT_CCC)){
		printk("Discover params 1:%d\n", discover_params.start_handle);
		printk("Discover params 2:%d\n", subscribe_params_txdata.value_handle);
		printk("Discovered CCCD\n");

		if (attr->handle-1 == subscribe_params_txdata.value_handle)
		{
			printk("[SUBSCRIBE PARAMS]\n");
			subscribe_params_txdata.notify = notify_func;
			subscribe_params_txdata.value = BT_GATT_CCC_NOTIFY;
			subscribe_params_txdata.ccc_handle = attr->handle;
	
			err = bt_gatt_subscribe(conn, &subscribe_params_txdata);
			if (err && err != -EALREADY) {
				printk("Subscribe failed (err %d)\n", err);
			} else {
				printk("[SUBSCRIBED]\n");
			}

			printk("Discovering RxCredit\n");
			//memcpy(&frog_discover_uuid, BT_UUID_GATT_CCC, sizeof(frog_discover_uuid));
			memcpy(&frog_discover_uuid, BT_UUID_RXCREDIT, sizeof(frog_discover_uuid));
			discover_params.uuid = &frog_discover_uuid.uuid;
			discover_params.start_handle = attr->handle + 1;
			discover_params.type = BT_GATT_DISCOVER_CHARACTERISTIC;	
		} 

		else if (attr->handle-1 == subscribe_params_rxcredit.value_handle)
		{
			printk("[SUBSCRIBE PARAMS]\n");
			subscribe_params_rxcredit.notify = notify_func;
			subscribe_params_rxcredit.value = BT_GATT_CCC_NOTIFY;
			subscribe_params_rxcredit.ccc_handle = attr->handle;
	
			err = bt_gatt_subscribe(conn, &subscribe_params_rxcredit);
			if (err && err != -EALREADY) {
				printk("Subscribe failed (err %d)\n", err);
			} else {
				printk("[SUBSCRIBED]\n");
			}
			
			return BT_GATT_ITER_STOP;
		}
		
		//subscribe_params_rxcredit.value_handle = bt_gatt_attr_value_handle(attr); 
		

		err = bt_gatt_discover(conn, &discover_params);
		if (err) {
			printk("Discover failed (err %d)\n", err);
		}
	}

	return BT_GATT_ITER_STOP;
}

static void connected(struct bt_conn *conn, uint8_t conn_err)
{
	char addr[BT_ADDR_LE_STR_LEN];
	int err;

	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

	if (conn_err) {
		printk("Failed to connect to %s (%u)\n", addr, conn_err);

		bt_conn_unref(default_conn);
		default_conn = NULL;

		scan_start();
		return;
	}

	printk("Connected: %s\n", addr);

	if (conn == default_conn) {
		memcpy(&frog_discover_uuid, BT_UUID_FROG, sizeof(frog_discover_uuid));
		discover_params.uuid = &frog_discover_uuid.uuid;
		discover_params.func = discover_func;
		discover_params.start_handle = BT_ATT_FIRST_ATTRIBUTE_HANDLE;
		discover_params.end_handle = BT_ATT_LAST_ATTRIBUTE_HANDLE;
		discover_params.type = BT_GATT_DISCOVER_PRIMARY;

		err = bt_gatt_discover(default_conn, &discover_params);
		if (err) {
			printk("Discover failed(err %d)\n", err);
			return;
		}
	}
}

static bool eir_found(struct bt_data *data, void *user_data)
{
	bt_addr_le_t *addr = user_data;
	int i;

	printk("[AD]: %u data_len %u\n", data->type, data->data_len);
	switch (data->type) {
	case BT_DATA_UUID128_SOME:
	case BT_DATA_UUID128_ALL:
		if (data->data_len % BT_UUID_SIZE_128 != 0U) {
			printk("AD malformed\n");
			return true;
		}
		
		printk("INSIDE SWITCH\n");

		for (i = 0; i < data->data_len; i += BT_UUID_SIZE_128) {
			struct bt_uuid *uuid128;
			uint8_t btadvData[16];
			memcpy(btadvData, data->data, 16);
			uuid128 = (struct bt_uuid *)btadvData;
			int err;
			printk("INSIDE FOR LOOP\n");


			if (bt_uuid_cmp(uuid128, BT_UUID_TXDATA)) {
				//printk("COMPARISON OK!\n");
				printk("uuid128 == TXDATA\n");				
					err = bt_le_scan_stop();
					if(err) {
						printk("Stop LE scan failed (err %d)\n", err);					
					}
				printk("make connection\n");

				err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN,
						BT_LE_CONN_PARAM_DEFAULT,
						&default_conn);

				printk("err: %d\n", err);

				if (err) {
					printk("Create connection failed (err %d)\n",
						err);
				}
				//continue;
				return false;
			} if (bt_uuid_cmp(uuid128, BT_UUID_RXCREDIT)) {
				//printk("COMPARISON OK!\n");
				printk("uuid128 == RXCREDIT\n");				
					err = bt_le_scan_stop();
					if(err) {
						printk("Stop LE scan failed (err %d)\n", err);					
					}
				printk("make connection");

				err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN,
						BT_LE_CONN_PARAM_DEFAULT,
						&default_conn);

				printk("err: %d\n", err);

				if (err) {
					printk("Create connection failed (err %d)\n",
						err);
				}
				//continue;
				return false;				
			}
		}
	}
	return true;
}

static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
			 struct net_buf_simple *ad)
{
	char dev[BT_ADDR_LE_STR_LEN];

	bt_addr_le_to_str(addr, dev, sizeof(dev));
	printk("[DEVICE]: %s, AD evt type %u, AD data len %u, RSSI %i\n",
	       dev, type, ad->len, rssi);

	/* We're only interested in connectable events */
	if (type == BT_HCI_ADV_IND || type == BT_HCI_ADV_DIRECT_IND) {
		bt_data_parse(ad, eir_found, (void *)addr);
	}
}

static int scan_start(void)
{
	/* Use active scanning and disable duplicate filtering to handle any
	 * devices that might update their advertising data at runtime.
	 */
	struct bt_le_scan_param scan_param = {
		.type       = BT_LE_SCAN_TYPE_ACTIVE,
		.options    = BT_LE_SCAN_OPT_NONE,
		.interval   = BT_GAP_SCAN_FAST_INTERVAL,
		.window     = BT_GAP_SCAN_FAST_WINDOW,
	};

	return bt_le_scan_start(&scan_param, device_found);
}

static void disconnected(struct bt_conn *conn, uint8_t reason)
{
	char addr[BT_ADDR_LE_STR_LEN];
	int err;

	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

	printk("Disconnected: %s (reason 0x%02x)\n", addr, reason);

	if (default_conn != conn) {
		return;
	}

	bt_conn_unref(default_conn);
	default_conn = NULL;

	err = scan_start();
	if (err) {
		printk("Scanning failed to start (err %d)\n", err);
	}
}

BT_CONN_CB_DEFINE(conn_callbacks) = {
	.connected = connected,
	.disconnected = disconnected,
};

int main(void)
{
	int err;

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

	printk("Bluetooth initialized\n");

	err = scan_start();

	if (err) {
		printk("Scanning failed to start (err %d)\n", err);
		return 0;
	}

	printk("Scanning successfully started\n");
	return 0;
}

Regards,
B

[Einar Thorsrud]

Hi,

I suggest you take a look at the peripheral UART central and peripheral samples and use the implementation as reference. This does not do loopback, but you can modify one of the sides to loop the data back instead of writing to UART.

[DevBear]

Thank you Einar!

[DevBear]

Einar Thorsrud if I don't want to use the UART is the suggestion given still a valid sample code? 

[Einar Thorsrud]

Yes, you can remove the code related to the physical UART and still use the Nordic UART service - NUS (or just refer to it and it's implementation as an example). Most real world applications that use NUS don't use it together with a physical UART.