blob: 2710b2534a6ad394b8d9148aca7686724a6817ff [file] [log] [blame]
/* main.c - Application main entry point */
/*
* Copyright (c) 2015-2016 Intel Corporation
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stdint.h>
#include <stddef.h>
#include <errno.h>
#include <zephyr.h>
#include <misc/printk.h>
#include <bluetooth/bluetooth.h>
#include <bluetooth/hci.h>
#include <bluetooth/conn.h>
#include <bluetooth/uuid.h>
#include <bluetooth/gatt.h>
#include <misc/byteorder.h>
static struct bt_conn *default_conn;
static struct bt_uuid_16 uuid = BT_UUID_INIT_16(0);
static struct bt_gatt_discover_params discover_params;
static struct bt_gatt_subscribe_params subscribe_params;
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 = 0;
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");
memset(params, 0, sizeof(*params));
return BT_GATT_ITER_STOP;
}
printk("[ATTRIBUTE] handle %u\n", attr->handle);
if (BT_UUID_16(discover_params.uuid)->val == BT_UUID_HRS_VAL) {
uuid.val = BT_UUID_HRS_MEASUREMENT_VAL;
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_16(discover_params.uuid)->val ==
BT_UUID_HRS_MEASUREMENT_VAL) {
uuid.val = BT_UUID_GATT_CCC_VAL;
discover_params.uuid = &uuid.uuid;
discover_params.start_handle = attr->handle + 2;
discover_params.type = BT_GATT_DISCOVER_DESCRIPTOR;
subscribe_params.value_handle = attr->handle + 1;
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 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);
return;
}
printk("Connected: %s\n", addr);
if (conn == default_conn) {
uuid.val = BT_UUID_HRS_VAL;
discover_params.uuid = &uuid.uuid;
discover_params.func = discover_func;
discover_params.start_handle = 0x0001;
discover_params.end_handle = 0xffff;
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(uint8_t type, const uint8_t *data, uint8_t data_len,
void *user_data)
{
bt_addr_le_t *addr = user_data;
int i;
printk("[AD]: %u data_len %u\n", type, data_len);
switch (type) {
case BT_DATA_UUID16_SOME:
case BT_DATA_UUID16_ALL:
if (data_len % sizeof(uint16_t) != 0) {
printk("AD malformed\n");
return true;
}
for (i = 0; i < data_len; i += sizeof(uint16_t)) {
uint16_t u16;
int err;
memcpy(&u16, &data[i], sizeof(u16));
if (sys_le16_to_cpu(u16) != BT_UUID_HRS_VAL) {
continue;
}
err = bt_le_scan_stop();
if (err) {
printk("Stop LE scan failed (err %d)\n", err);
continue;
}
default_conn = bt_conn_create_le(addr,
BT_LE_CONN_PARAM_DEFAULT);
return false;
}
}
return true;
}
static void ad_parse(struct net_buf_simple *ad,
bool (*func)(uint8_t type, const uint8_t *data,
uint8_t data_len, void *user_data),
void *user_data)
{
while (ad->len > 1) {
uint8_t len = net_buf_simple_pull_u8(ad);
uint8_t type;
/* Check for early termination */
if (len == 0) {
return;
}
if (len > ad->len || ad->len < 1) {
printk("AD malformed\n");
return;
}
type = net_buf_simple_pull_u8(ad);
if (!func(type, ad->data, len - 1, user_data)) {
return;
}
net_buf_simple_pull(ad, len - 1);
}
}
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_LE_ADV_IND || type == BT_LE_ADV_DIRECT_IND) {
/* TODO: Move this to a place it can be shared */
ad_parse(ad, eir_found, (void *)addr);
}
}
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 %u)\n", addr, reason);
if (default_conn != conn) {
return;
}
bt_conn_unref(default_conn);
default_conn = NULL;
/* This demo doesn't require active scan */
err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, device_found);
if (err) {
printk("Scanning failed to start (err %d)\n", err);
}
}
static struct bt_conn_cb conn_callbacks = {
.connected = connected,
.disconnected = disconnected,
};
void main(void)
{
int err;
err = bt_enable(NULL);
if (err) {
printk("Bluetooth init failed (err %d)\n", err);
return;
}
printk("Bluetooth initialized\n");
bt_conn_cb_register(&conn_callbacks);
err = bt_le_scan_start(BT_LE_SCAN_ACTIVE, device_found);
if (err) {
printk("Scanning failed to start (err %d)\n", err);
return;
}
printk("Scanning successfully started\n");
}