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
