Custom BLE Client with 128BIT UUID

[DougMortime]

Hello,

I've needed recently to relay some results from my 52840 peripherals to the 7002dk which has the 5340 on it. I've managed to get the Central HR and Peripheral HR examples to work flawlessly however I'd like to send my custom data and respective characteristics now. I've tried variations of the below code but unfortunately no progress has been made.

Firstly, the declarations and includes: Note my UUIDs match the peripherals being tested, I've double checked this. 

#include <zephyr/types.h>
#include <stddef.h>
#include <errno.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/printk.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>
#include <zephyr/sys/byteorder.h>

static void start_scan(void);

static struct bt_conn *default_conn;

static struct bt_uuid_128 uuid = BT_UUID_INIT_128(0);
static struct bt_gatt_discover_params discover_params;
static struct bt_gatt_subscribe_params subscribe_params;

/** @brief Sensor Service UUID. */
#define BT_UUID_SERVICE_VAL \
	BT_UUID_128_ENCODE(0x4E6B7170, 0xAD33, 0x4A8F, 0x8C52, 0x4F4D3CA3FDCC)

/** @brief Characteristic UUID. */
#define BT_UUID_CHARACTERISTIC_VAL \
	BT_UUID_128_ENCODE(0x4E6B7171, 0xAD33, 0x4A8F, 0x8C52, 0x4F4D3CA3FDCC)

#define BT_UUID_SERVICE BT_UUID_DECLARE_128(BT_UUID_SERVICE_VAL)
#define BT_UUID_CHARACTERISTIC BT_UUID_DECLARE_128(BT_UUID_CHARACTERISTIC_VAL)

Next is the discover function which I believe has no issues, it's just the same central hr sample with the service UUID and characteristic UUID swapped out for my own peripherals.

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;
	}

	printk("[NOTIFICATION] data %p length %u\n", data, length);

	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_SERVICE))
	{
		memcpy(&uuid, BT_UUID_CHARACTERISTIC, sizeof(uuid));
		discover_params.uuid = &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_CHARACTERISTIC))
	{
		memcpy(&uuid, BT_UUID_GATT_CCC, sizeof(uuid));
		discover_params.uuid = &uuid.uuid;
		discover_params.start_handle = attr->handle + 2;
		discover_params.type = BT_GATT_DISCOVER_DESCRIPTOR;
		subscribe_params.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
	{
		subscribe_params.notify = notify_func;
		subscribe_params.value = BT_GATT_CCC_NOTIFY;
		subscribe_params.ccc_handle = attr->handle;

		err = bt_gatt_subscribe(conn, &subscribe_params);
		if (err && err != -EALREADY)
		{
			printk("Subscribe failed (err %d)\n", err);
		}
		else
		{
			printk("[SUBSCRIBED]\n");
		}

		return BT_GATT_ITER_STOP;
	}

	return BT_GATT_ITER_STOP;
}

Now to the section where I think the issue really is, the eir_found callback function.

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 % 16 != 0U)
		{
			printk("AD malformed\n");
			return true;
		}

		for (i = 0; i < data->data_len; i += 16)
		{
			struct bt_le_conn_param *param;
			struct bt_uuid *uuid;
			uint8_t u128[16];
			int err;

			memcpy(u128, &data->data[i], sizeof(u128));
			uuid = BT_UUID_DECLARE_128(u128);
			if (bt_uuid_cmp(uuid, BT_UUID_SERVICE))
			{
				continue;
			}

			err = bt_le_scan_stop();
			if (err)
			{
				printk("Stop LE scan failed (err %d)\n", err);
				continue;
			}

			param = BT_LE_CONN_PARAM_DEFAULT;
			err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN,
									param, &default_conn);
			if (err)
			{
				printk("Create conn failed (err %d)\n", err);
				start_scan();
			}

			return false;
		}
	}

	return true;
}

The remaining code seems fine, I only needed to change the service UUID.

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_GAP_ADV_TYPE_ADV_IND ||
		type == BT_GAP_ADV_TYPE_ADV_DIRECT_IND)
	{
		bt_data_parse(ad, eir_found, (void *)addr);
	}
}

static void start_scan(void)
{
	int err;

	/* 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,
	};

	err = bt_le_scan_start(&scan_param, device_found);
	if (err)
	{
		printk("Scanning failed to start (err %d)\n", err);
		return;
	}

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

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;

		start_scan();
		return;
	}

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

	if (conn == default_conn)
	{
		memcpy(&uuid, BT_UUID_SERVICE, sizeof(uuid));
		discover_params.uuid = &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 void disconnected(struct bt_conn *conn, uint8_t reason)
{
	char addr[BT_ADDR_LE_STR_LEN];

	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;

	start_scan();
}

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");

	start_scan();
	return 0;
}

I have looked around but a lot of the questions pertaining to clients seem to be utilizing the old sdk not zephyr. There was one post about this but it was more about discovery rather than connecting but I'm happy to take a look at it again if I've missed something.

Any help is appreciated.

Edit - Posted code for notification, still wont work as intended.

Regards

Doug

[Vidar Berg]

Hello Doug,

I think it's easier to use our Scanning module with filter matching, same as we do in the central uart sample here: https://github.com/nrfconnect/sdk-nrf/blob/main/samples/bluetooth/central_uart/src/main.c#L502 

Now to the section where I think the issue really is, the eir_found callback function.

I guess it fails because it does not find a matching UUID? I would suggest to print the UUIDs parsed from the adv. packets to see if the expected UUID is found our not. 

Regards,

Vidar

[DougMortime]

Hello Vidar,

After a long slog I finally have it connecting and discovering the service as well as the characteristic. The notification however won't come through, I've tried the peripheral on another device (iPad as client) and it works seamlessly. 

I note that when I disconnect the peripheral, turn off the power, finally my notify_func gets called albeit its null.

Any thoughts at all would be appreciated greatly.

I've attached the relevant code based on your input to use the scanning module.

static struct bt_conn *default_conn;

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

	printk("Notification: data %p length %u\n", data, length);
	return BT_GATT_ITER_CONTINUE;
}

static void discovery_complete(struct bt_gatt_dm *dm,
							   void *context)
{

	printk("Service discovery completed\n");

	bt_gatt_dm_data_print(dm);
	const struct bt_gatt_dm_attr *gatt_service_attr = bt_gatt_dm_service_get(dm);
	const struct bt_gatt_service_val *gatt_service = bt_gatt_dm_attr_service_val(gatt_service_attr);
	char uuid_str[37];
	bt_uuid_to_str(gatt_service->uuid, uuid_str, sizeof(uuid_str));
	printk("Discovered service %s\n", uuid_str);
	memset(uuid_str, 0, sizeof(uuid_str));

	const struct bt_uuid *chrc_ptr = BT_UUID_DECLARE_128(BT_UUID_SENSOR_INPUT1);
	bt_uuid_to_str(chrc_ptr, uuid_str, sizeof(uuid_str));
	printk("CHRC UUID %s\n", uuid_str);
	const struct bt_gatt_dm_attr *gatt_chrc_attr = bt_gatt_dm_char_by_uuid(dm, chrc_ptr);
	if (!gatt_chrc_attr)
	{
		printk("No matching characteristics found\n");
		return;
	}

	const struct bt_gatt_chrc *gatt_chrc = bt_gatt_dm_attr_chrc_val(gatt_chrc_attr);

	const struct bt_gatt_dm_attr *gatt_chrc_ccc = bt_gatt_dm_desc_by_uuid(dm, gatt_chrc_attr, BT_UUID_GATT_CCC);
	if (!gatt_chrc_ccc)
	{
		printk("CCC handle not found\n");
		return;
	}

	struct bt_gatt_subscribe_params params;
	memset(&params, 0, sizeof(params));
	params.ccc_handle = gatt_chrc_ccc->handle;
	params.value_handle = gatt_chrc_attr->handle; 
	params.value = BT_GATT_CCC_NOTIFY;
	params.notify = notify_func;

	int err = bt_gatt_subscribe(default_conn, &params);
	if (err && err != -EALREADY)
	{
		printk("Subscribe failed (err %d)\n", err);
	}
	else
	{
		printk("Subscribed\n");
	}

	bt_gatt_dm_data_release(dm);
}

Regards,

DM

[DougMortime]

Hello, 

Finally, tracked down the issue. It was the gatt_chrc.

params.value_handle = gatt_chrc->value_handle

Now its working as intended.

Regards,

DM

[Vidar Berg]

Hello,

I was just about to review your code. Thanks for the update!

Regards,

Vidar

[DougMortime]

Haha no problems! Thanks for pointing me to the scanning module.

Regards,

DM