| /* |
| * Copyright (c) 2023 Nordic Semiconductor ASA |
| * |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| #include <stddef.h> |
| #include <errno.h> |
| #include <stdint.h> |
| #include <string.h> |
| |
| #include <zephyr/types.h> |
| #include <zephyr/kernel.h> |
| |
| #include <zephyr/sys/printk.h> |
| #include <zephyr/sys/byteorder.h> |
| |
| #include <zephyr/bluetooth/att.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> |
| |
| #define MTU_TEST_SERVICE_TYPE BT_UUID_128_ENCODE(0x2e2b8dc3, 0x06e0, 0x4f93, 0x9bb2, 0x734091c356f0) |
| #define MTU_TEST_SERVICE_NOTIFY_TYPE \ |
| BT_UUID_128_ENCODE(0x2e2b8dc3, 0x06e0, 0x4f93, 0x9bb2, 0x734091c356f3) |
| |
| #define BT_UUID_MTU_TEST BT_UUID_DECLARE_128(MTU_TEST_SERVICE_TYPE) |
| #define BT_UUID_MTU_TEST_NOTIFY BT_UUID_DECLARE_128(MTU_TEST_SERVICE_NOTIFY_TYPE) |
| |
| static void start_scan(void); |
| |
| static struct bt_conn *default_conn; |
| |
| static struct bt_uuid_128 uuid = BT_UUID_INIT_128(0); |
| static const struct bt_uuid *ccc_uuid = BT_UUID_GATT_CCC; |
| |
| static struct bt_gatt_discover_params discover_params; |
| static struct bt_gatt_subscribe_params subscribe_params; |
| |
| bt_gatt_notify_func_t notify_cb; |
| |
| 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); |
| |
| if (notify_cb != NULL) { |
| notify_cb(conn, params, data, length); |
| } |
| |
| return BT_GATT_ITER_STOP; |
| } |
| |
| 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_MTU_TEST)) { |
| memcpy(&uuid, BT_UUID_MTU_TEST_NOTIFY, 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_MTU_TEST_NOTIFY)) { |
| discover_params.uuid = ccc_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; |
| } |
| |
| static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type, |
| struct net_buf_simple *ad) |
| { |
| char addr_str[BT_ADDR_LE_STR_LEN]; |
| int err; |
| |
| if (default_conn) { |
| return; |
| } |
| |
| /* We're only interested in connectable events */ |
| if (type != BT_GAP_ADV_TYPE_ADV_IND && |
| type != BT_GAP_ADV_TYPE_ADV_DIRECT_IND) { |
| return; |
| } |
| |
| bt_addr_le_to_str(addr, addr_str, sizeof(addr_str)); |
| printk("Device found: %s (RSSI %d)\n", addr_str, rssi); |
| |
| /* connect only to devices in close proximity */ |
| if (rssi < -70) { |
| return; |
| } |
| |
| if (bt_le_scan_stop()) { |
| return; |
| } |
| |
| err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN, |
| BT_LE_CONN_PARAM_DEFAULT, &default_conn); |
| if (err) { |
| printk("Create conn to %s failed (%u)\n", addr_str, err); |
| start_scan(); |
| } |
| } |
| |
| static void start_scan(void) |
| { |
| int err; |
| |
| err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, device_found); |
| if (err) { |
| printk("Scanning failed to start (err %d)\n", err); |
| return; |
| } |
| |
| printk("Scanning successfully started\n"); |
| } |
| |
| static void mtu_exchange_cb(struct bt_conn *conn, uint8_t err, |
| struct bt_gatt_exchange_params *params) |
| { |
| printk("%s: MTU exchange %s (%u)\n", __func__, |
| err == 0U ? "successful" : "failed", |
| bt_gatt_get_mtu(conn)); |
| } |
| |
| static struct bt_gatt_exchange_params mtu_exchange_params = { |
| .func = mtu_exchange_cb |
| }; |
| |
| static int mtu_exchange(struct bt_conn *conn) |
| { |
| int err; |
| |
| printk("%s: Current MTU = %u\n", __func__, bt_gatt_get_mtu(conn)); |
| |
| printk("%s: Exchange MTU...\n", __func__); |
| err = bt_gatt_exchange_mtu(conn, &mtu_exchange_params); |
| if (err) { |
| printk("%s: MTU exchange failed (err %d)", __func__, err); |
| } |
| |
| return err; |
| } |
| |
| static void connected(struct bt_conn *conn, uint8_t err) |
| { |
| char addr[BT_ADDR_LE_STR_LEN]; |
| |
| bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr)); |
| |
| if (err) { |
| printk("Failed to connect to %s (%u)\n", addr, err); |
| |
| bt_conn_unref(default_conn); |
| default_conn = NULL; |
| |
| start_scan(); |
| return; |
| } |
| |
| printk("Connected: %s\n", addr); |
| |
| (void)mtu_exchange(conn); |
| |
| if (conn == default_conn) { |
| memcpy(&uuid, BT_UUID_MTU_TEST, 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]; |
| |
| if (conn != default_conn) { |
| return; |
| } |
| |
| bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr)); |
| |
| printk("Disconnected: %s (reason 0x%02x)\n", addr, reason); |
| |
| bt_conn_unref(default_conn); |
| default_conn = NULL; |
| |
| start_scan(); |
| } |
| |
| BT_CONN_CB_DEFINE(conn_callbacks) = { |
| .connected = connected, |
| .disconnected = disconnected, |
| }; |
| |
| void run_central_sample(bt_gatt_notify_func_t cb) |
| { |
| int err; |
| |
| notify_cb = cb; |
| |
| err = bt_enable(NULL); |
| if (err) { |
| printk("Bluetooth init failed (err %d)\n", err); |
| return; |
| } |
| |
| printk("Bluetooth initialized\n"); |
| |
| start_scan(); |
| } |