cant get Indications to work with NRF Connect

RE: cant get Indications to work with NRF Connect

Vidar Berg — Mon, 05 Jun 2023 13:19:06 GMT

Yes, you can use a semaphore to signal the main() or some other thread to start sending the indication packets. The point is that you should not run the blocking send from the Bluetooth workqueue thread.

RE: cant get Indications to work with NRF Connect

IvanR — Mon, 05 Jun 2023 11:50:45 GMT

There is no other way of doing this? this will add a lot of unneeded complexity to my code. Coudnt the semaphore be used?

RE: cant get Indications to work with NRF Connect

Vidar Berg — Mon, 05 Jun 2023 10:12:12 GMT

The problem is that you are executing a function that never returns from the BT RX workqueue thread. This will prevent subsequent BLE packets from being processed by the Bluetooth host. I'd suggest you send the indications from your main loop instead.

RE: cant get Indications to work with NRF Connect

IvanR — Mon, 05 Jun 2023 09:44:36 GMT

devzone.nordicsemi.com/.../5808.test.zip

nRF Connect SDK 2.3.0

RE: cant get Indications to work with NRF Connect

Vidar Berg — Mon, 05 Jun 2023 09:34:09 GMT

Please upload the project folder as a .zip and let me know what SDK version you use.

RE: cant get Indications to work with NRF Connect

IvanR — Mon, 05 Jun 2023 09:27:00 GMT

the board is nRF5340 DK, Button Service example

RE: cant get Indications to work with NRF Connect

IvanR — Mon, 05 Jun 2023 09:26:06 GMT

#include <zephyr/types.h>
#include <stddef.h>
#include <string.h>
#include <time.h>
#include <stdlib.h> 
#include <errno.h>
#include <zephyr/sys/printk.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.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 "button_svc.h"
#include "led_svc.h"

#include <stdio.h>
#include <zephyr/device.h>
#include <zephyr/drivers/sensor.h>

static uint8_t indicating;
static struct bt_gatt_indicate_params ind_params;

#define DEVICE_NAME "Test1"
#define DEVICE_NAME_LEN (sizeof(DEVICE_NAME) - 1)
#define ADV_LEN 12

#define VERSION_MAJOR 0
#define VERSION_MINOR 1
#define VERSION_PATCH 0

/* The devicetree node identifier for the "led0" alias. */
#define SLEEP_TIME_MS 1000
#define LED0_NODE DT_ALIAS(led0)
#define LED1_NODE DT_ALIAS(led1)
#define LED2_NODE DT_ALIAS(led2)
#define LED3_NODE DT_ALIAS(led3)

static const struct gpio_dt_spec led[] = {
		GPIO_DT_SPEC_GET(LED0_NODE, gpios),
		GPIO_DT_SPEC_GET(LED1_NODE, gpios),
		GPIO_DT_SPEC_GET(LED3_NODE, gpios),
		GPIO_DT_SPEC_GET(LED2_NODE, gpios)};

LOG_MODULE_REGISTER(main);

static void testLed();
const char *banner(void);
void sendStringInChunks(const char *inputString, size_t maxLength);
void sendStringInChunksIndicate(const char *inputString, size_t maxLength);

/* Button value. */
static uint16_t but_val;

/* BLE connection */
struct bt_conn *conn;
static struct bt_uuid_128 st_service_uuid = BT_UUID_INIT_128(BT_UUID_128_ENCODE(0x25AE1441, 0x05D3, 0x4C5B, 0x8281, 0x93D4E07420CF));
static struct bt_uuid_128 commands_uuid = BT_UUID_INIT_128(BT_UUID_128_ENCODE(0x25AE1442, 0x05D3, 0x4C5B, 0x8281, 0x93D4E07420CF));
static struct bt_uuid_128 notify_uuid = BT_UUID_INIT_128(BT_UUID_128_ENCODE(0x25AE1443, 0x05D3, 0x4C5B, 0x8281, 0x93D4E07420CF));
static struct bt_uuid_128 l_char_uuid = BT_UUID_INIT_128(BT_UUID_128_ENCODE(0x25AE1444, 0x05D3, 0x4C5B, 0x8281, 0x93D4E07420CF));
static struct bt_uuid_128 batt_uuid = BT_UUID_INIT_128(BT_UUID_128_ENCODE(0x25AE1445, 0x05D3, 0x4C5B, 0x8281, 0x93D4E07420CF));
static struct bt_uuid_128 indicate_uuid = BT_UUID_INIT_128(BT_UUID_128_ENCODE(0x25AE1446, 0x05D3, 0x4C5B, 0x8281, 0x93D4E07420CF));

static ssize_t recv(struct bt_conn *conn, const struct bt_gatt_attr *attr, const void *buf, uint16_t len, uint16_t offset, uint8_t flags);

static const struct bt_data ad[] = {
		BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
		BT_DATA(BT_DATA_NAME_COMPLETE, DEVICE_NAME, DEVICE_NAME_LEN),
		BT_DATA(BT_DATA_UUID128_ALL, st_service_uuid.val, 16)};

/* Notification state */
volatile bool notify_enable;
volatile bool batt_notify_enable;
volatile bool notifyl_enable;
volatile bool indicate_enabled;

static void notify_ccc_cfg_changed(const struct bt_gatt_attr *attr, uint16_t value)
{
	ARG_UNUSED(attr);
	notify_enable = (value == BT_GATT_CCC_NOTIFY);
	LOG_INF("Notification %s", notify_enable ? "enabled" : "disabled");
}

static void batt_ccc_cfg_changed(const struct bt_gatt_attr *attr, uint16_t value)
{
	ARG_UNUSED(attr);
	batt_notify_enable = (value == BT_GATT_CCC_NOTIFY);
	LOG_INF("Battery Notification %s", notify_enable ? "enabled" : "disabled");
}

static void l_ccc_cfg_changed(const struct bt_gatt_attr *attr, uint16_t value)
{
	ARG_UNUSED(attr);
	notifyl_enable = (value == BT_GATT_CCC_NOTIFY);
	LOG_INF("Notification %s", notifyl_enable ? "enabled" : "disabled");
	// Check if notifications are enabled or disabled
	if (value == BT_GATT_CCC_NOTIFY)
	{
		// Notifications enabled
	}
	else if (value == 0)
	{
		// Notifications disabled
	}
}

static void indicate_ccc_cfg_changed(const struct bt_gatt_attr *attr, uint16_t value)
{
	// ARG_UNUSED(attr);
	indicate_enabled = (value == BT_GATT_CCC_INDICATE);
	LOG_INF("Indicate %s", indicate_enabled ? "enabled" : "disabled");
}

static void indicate_confirm_cb(struct bt_conn *conn, struct bt_gatt_indicate_params *params, uint8_t err)
{
	printk("HERE2\n");
	if (err)
	{
		printk("Indication confirmation error: %d\n", err);
	}
}

static void indicate_destroy(struct bt_gatt_indicate_params *params)
{
	printk("Indication complete\n");
	indicating = 0U;
}

/* The embedded board is acting as GATT server.
 * The ST BLE Android app is the BLE GATT client.
 */

/* ST BLE Sensor GATT services and characteristic */

BT_GATT_SERVICE_DEFINE(stsensor_svc,
											 BT_GATT_PRIMARY_SERVICE(&st_service_uuid),
											 BT_GATT_CHARACTERISTIC(&commands_uuid.uuid, BT_GATT_CHRC_READ | BT_GATT_CHRC_WRITE_WITHOUT_RESP, BT_GATT_PERM_WRITE, NULL, recv, NULL),
											 BT_GATT_CHARACTERISTIC(&notify_uuid.uuid, BT_GATT_CHRC_NOTIFY, BT_GATT_PERM_READ | BT_GATT_PERM_WRITE, NULL, NULL, NULL),
											 BT_GATT_CCC(notify_ccc_cfg_changed, BT_GATT_PERM_READ | BT_GATT_PERM_WRITE),
											 BT_GATT_CHARACTERISTIC(&l_char_uuid.uuid, BT_GATT_CHRC_NOTIFY, BT_GATT_PERM_READ, NULL, NULL, NULL),
											 BT_GATT_CCC(l_ccc_cfg_changed, BT_GATT_PERM_READ | BT_GATT_PERM_WRITE),
											 BT_GATT_CHARACTERISTIC(&batt_uuid.uuid, BT_GATT_CHRC_NOTIFY, BT_GATT_PERM_READ, NULL, NULL, NULL),
											 BT_GATT_CCC(batt_ccc_cfg_changed, BT_GATT_PERM_READ | BT_GATT_PERM_WRITE),
											 BT_GATT_CHARACTERISTIC(&indicate_uuid.uuid, BT_GATT_CHRC_INDICATE, BT_GATT_PERM_READ | BT_GATT_PERM_WRITE, NULL, NULL, NULL),
											 BT_GATT_CCC(indicate_ccc_cfg_changed, BT_GATT_PERM_READ | BT_GATT_PERM_WRITE));

static void bt_ready(int err)
{
	if (err)
	{
		LOG_ERR("Bluetooth init failed (err %d)", err);
		return;
	}
	LOG_INF("Bluetooth initialized");
	/* Start advertising */
	err = bt_le_adv_start(BT_LE_ADV_CONN, ad, ARRAY_SIZE(ad), NULL, 0);
	if (err)
	{
		LOG_ERR("Advertising failed to start (err %d)", err);
		return;
	}

	LOG_INF("Configuration mode: waiting connections...");
}

static void connected(struct bt_conn *connected, uint8_t err)
{
	if (err)
	{
		LOG_ERR("Connection failed (err %u)", err);
	}
	else
	{
		LOG_INF("Connected");
		if (!conn)
		{
			conn = bt_conn_ref(connected);
		}
	}
}

static void disconnected(struct bt_conn *disconn, uint8_t reason)
{
	if (conn)
	{
		bt_conn_unref(conn);
		conn = NULL;
	}

	LOG_INF("Disconnected (reason %u)", reason);
}

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

static void test_indicate()
{
	while (1)
	{
		const char *data = "Hello, client!";
		sendStringInChunksIndicate(data, 20);
		k_sleep(K_SECONDS(1));
	}
}

static ssize_t recv(struct bt_conn *conn, const struct bt_gatt_attr *attr, const void *buf, uint16_t len, uint16_t offset, uint8_t flags)
{
	char str_data[len + 1];
	snprintf(str_data, sizeof(str_data), "%.*s", len, (const char *)buf); // Convert the received data to a string
	LOG_INF("Received data: %s", str_data);
	if (strcmp(str_data, "led") == 0)
	{
		testLed();
	}
	else if (strcmp(str_data, "info2") == 0)
	{
		test_indicate();
	}

	return 0;
}

static void testLed()
{
	int ret;
	int num_leds = sizeof(led) / sizeof(led[0]);

	for (int i = 0; i < num_leds; i++)
	{
		if (!device_is_ready(led[i].port))
		{
			return;
		}

		ret = gpio_pin_configure_dt(&led[i], GPIO_OUTPUT_ACTIVE);
		if (ret < 0)
		{
			return;
		}
	}

	for (int i = 0; i < num_leds; i++)
	{
		printf("LED %d ON\n", i);
		ret = gpio_pin_set_dt(&led[i], 1);
		if (ret < 0)
		{
			return;
		}
		k_msleep(SLEEP_TIME_MS);
		printf("LED %d OFF\n", i);
		ret = gpio_pin_set_dt(&led[i], 0);
		if (ret < 0)
		{
			return;
		}
	}
}

void main(void)
{
	int err;

	err = led_init();
	if (err)
	{
		return;
	}

	/* Initialize the Bluetooth Subsystem */
	err = bt_enable(bt_ready);
	if (err)
	{
		LOG_ERR("Bluetooth init failed (err %d)", err);
	}

	testLed();

}

void sendStringInChunksIndicate(const char *inputString, size_t maxLength)
{
	if (indicate_enabled && !indicating)
	{
		printk("Sending Indication\n");
		indicating = 1U;
		ind_params.attr = &stsensor_svc.attrs[13]; // Indicate attribute index in the service
		ind_params.func = indicate_confirm_cb;
		ind_params.destroy = indicate_destroy;
		ind_params.data = inputString;				// Pointer to the data to be indicated
		ind_params.len = strlen(inputString); // Length of the data

		int err = bt_gatt_indicate(conn, &ind_params);
		if (err)
		{
			printk("Indicate failed (err %d)\n", err);
			indicating = 0U;
		}
	}
}

RE: cant get Indications to work with NRF Connect

Vidar Berg — Mon, 05 Jun 2023 09:05:42 GMT

I don't see any reason why this should not work. Could you please provide me with a minimal version of your application so that I can try to debug the issue here?

RE: cant get Indications to work with NRF Connect

IvanR — Mon, 05 Jun 2023 09:02:52 GMT

no,

when while(1) and k_sleep are uncommented its not working. After a while, there is a TIMEOUT and ccc is disabled (not by my code)

output:

[00:00:49.383,697] [1;31m<err> bt_att: att_timeout: ATT Timeout[0m
HERE2
Indication confirmation error: 14
Indication complete
[00:00:49.383,850] [0m<inf> main: indicate_ccc_cfg_changed: Indicate disabled[0m

RE: cant get Indications to work with NRF Connect

Vidar Berg — Mon, 05 Jun 2023 08:58:06 GMT

Hi,

Does it work if you uncomment while(1) and k_sleep()? Without the k_sleep(), the Bluetooth thread will become blocked.

RE: cant get Indications to work with NRF Connect

IvanR — Mon, 05 Jun 2023 08:24:26 GMT

I have this function

void sendStringInChunksIndicate(const char *inputString)

{

if (indicate_enabled && !indicating)

{

indicating = 1U;

ind_params.attr = &stsensor_svc.attrs[13]; // Indicate attribute index in the service

ind_params.func = indicate_confirm_cb;

ind_params.destroy = indicate_destroy;

ind_params.data = inputString; // Pointer to the data to be indicated

ind_params.len = strlen(inputString); // Length of the data

int err = bt_gatt_indicate(conn, &ind_params);

if (err)

{

printk("Indicate failed (err %d)\n", err);

indicating = 0U;

}

which is called by

static void test_indicate()

{

// while (1)

// {

//k_sleep(K_SECONDS(1));

const char *data = "Hello, client!";

sendStringInChunksIndicate(data);

// }

}

and it works, but as soon as I uncomment the While(1) it stops working.

RE: cant get Indications to work with NRF Connect

IvanR — Mon, 05 Jun 2023 05:13:38 GMT

Zephyr peripheral_ht is working, but I literally copied it and its not working. Now Im racking my head what I did wrong

RE: cant get Indications to work with NRF Connect

Vidar Berg — Fri, 02 Jun 2023 11:57:14 GMT

Hi,

The Android Bluetooth stack automatically takes care of acknowledging/confirming all indication packets received by the phone, so the app you use should not be relevant. To confirm that there is no issue on the phone side, you can repeat the test with another SDK sample that sends indications, such as the Zephyr peripheral_ht sample.

Best regards,

Vidar

RE: cant get Indications to work with NRF Connect

IvanR — Fri, 02 Jun 2023 11:04:41 GMT

I even tried

static void indicate_confirm_cb(struct bt_conn *conn, struct bt_gatt_indicate_params *params, uint8_t err)

{

printk("HERE2\n");

if (err)

{

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

}

static void indicate_destroy(struct bt_gatt_indicate_params *params)

{

printk("Indication complete\n");

indicating = 0U;

}

void sendStringInChunksIndicate(const char *inputString)

{

int err;

if (indicating)

return;

printk("HERE\n");

ind_params.attr = &stsensor_svc.attrs[13];

ind_params.func = indicate_confirm_cb;

ind_params.destroy = indicate_destroy;

ind_params.data = &inputString;

ind_params.len = sizeof(inputString);

err = bt_gatt_indicate(NULL, &ind_params);

if (err)

{

LOG_ERR("ERROR: %d", err);

} else {

indicating = 1U;

}

which is called when info2 is sent over notify:

if (strcmp(str_data, "info2") == 0)

{

if (indicate_enabled)

{

while (1)

{

k_sleep(K_SECONDS(1));

const char *data = "Hello, client!";

sendStringInChunksIndicate(data);

}

in nRF Connect android app i can see the first message but no subsequent indications are sent and the first times out m<err> bt_att: att_timeout: ATT Timeout
Indication confirmation error: 14