RE: nRF52 SDK peripheral is not connecting to nRF-Connect SDK central device

Hung Bui — Fri, 18 Aug 2023 09:21:20 GMT

Hi Kumar,
Please try capture a sniffer trace.
It's most likely that the central (scanner) didn't enable notification on the peer.

You can use the sniffer trace and compare what you have when testing the firmware on the same SDK vs testing between nRF5SDK and nRFConnect SDK.
You can find a tutorial on how to use the sniffer trace here.

RE: nRF52 SDK peripheral is not connecting to nRF-Connect SDK central device

Theja — Fri, 18 Aug 2023 04:34:11 GMT

Hi Hung Bui,

Thanks for the reply,

As of now I'm able to connect between nRF52 SDK peripheral to nRF-Connect SDK central device by changing security parameters to NULL but whatever data I send through peripheral I'm not able to receive in scanner.

here is scanner code snippet

static void discovery_complete(struct bt_gatt_dm *dm,
							   void *context)
{
	struct bt_nus_client *nus = context;
	LOG_INF("Service discovery completed");

	bt_gatt_dm_data_print(dm);

	bt_nus_handles_assign(dm, nus);
	bt_nus_subscribe_receive(nus);

	bt_gatt_dm_data_release(dm);

	
	send_through_uart("Service discovery completed\n");
}

static void discovery_service_not_found(struct bt_conn *conn,
										void *context)
{
	LOG_INF("Service not found");

	send_through_uart("Service not found\n");
}

static void discovery_error(struct bt_conn *conn,
							int err,
							void *context)
{
	LOG_WRN("Error while discovering GATT database: (%d)", err);

	send_through_uart("Error while discovering GATT database:\n");
}

struct bt_gatt_dm_cb discovery_cb = {
	.completed = discovery_complete,
	.service_not_found = discovery_service_not_found,
	.error_found = discovery_error,
};

static void gatt_discover(struct bt_conn *conn)
{
	int err;

	if (conn != default_conn)
	{
		return;
	}

	err = bt_gatt_dm_start(conn,
						   BT_UUID_NUS_SERVICE,
						   &discovery_cb,
						   &nus_client);
	if (err)
	{
		LOG_ERR("could not start the discovery procedure, error "
				"code: %d",
				err);

		send_through_uart("could not start the discovery procedure\n");
	}
}

static void exchange_func(struct bt_conn *conn, uint8_t err, struct bt_gatt_exchange_params *params)
{
	if (!err)
	{
		LOG_INF("MTU exchange done");

		send_through_uart("MTU exchange done\n");
	}
	else
	{
		LOG_WRN("MTU exchange failed (err %" PRIu8 ")", err);

		send_through_uart("MTU exchange failed1\n");
	}
}

static void connected(struct bt_conn *conn, uint8_t conn_err)
{

	int err;
	
	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

	if (conn_err)
	{
		LOG_INF("Failed to connect to %s (%d)", addr, conn_err);

		send_through_uart("Failed to connect to\n");

		if (default_conn == conn)
		{
			bt_conn_unref(default_conn);
			default_conn = NULL;

			err = bt_scan_start(BT_SCAN_TYPE_SCAN_ACTIVE);
			if (err)
			{
				LOG_ERR("Scanning failed to start (err %d)",
						err);

				send_through_uart("Scanning failed to start\n");
			}
		}

		return;
	}

	LOG_INF("Connected: %s", addr);

	send_through_uart("Connected\n");

	static struct bt_gatt_exchange_params exchange_params;

	exchange_params.func = exchange_func;
	err = bt_gatt_exchange_mtu(conn, &exchange_params);
	if (err)
	{
		LOG_WRN("MTU exchange failed (err %d)", err);

		send_through_uart("MTU exchange failed2\n");
	}

	// TODO: commented now
	err = bt_conn_set_security(conn, BT_SECURITY_L0);     //BT_SECURITY_L2
	if (err)
	{
		LOG_WRN("Failed to set security: %d", err);

		send_through_uart("Failed to set security\n");

		gatt_discover(conn);
	}

	// TODO: newly added
	gatt_discover(conn);


	err = bt_scan_stop();
	if ((!err) && (err != -EALREADY))
	{
		LOG_ERR("Stop LE scan failed (err %d)", err);

		send_through_uart("Stop LE scan failed\n");
	}
}

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

	LOG_INF("Disconnected: %s (reason %u)", addr, reason);

	uint8_t buffer_t[100] = {'\0'};
	sprintf(buffer_t, "Disconnected: %s (reason %u)", addr, reason);

	send_through_uart(buffer_t);

	if (default_conn != conn)
	{
		return;
	}

	bt_conn_unref(default_conn);
	default_conn = NULL;

	err = bt_scan_start(BT_SCAN_TYPE_SCAN_ACTIVE);
	if (err)
	{
		LOG_ERR("Scanning failed to start (err %d)",
				err);

		send_through_uart("Scanning failed to start\n");		
	}
}

static void security_changed(struct bt_conn *conn, bt_security_t level,
							 enum bt_security_err err)
{
	uint8_t ddata[100] = {'\0'};
	char addr[BT_ADDR_LE_STR_LEN];

	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

	if (!err)
	{
		LOG_INF("Security changed: %s level %u", addr, level);

		send_through_uart("Security changed:\n");
	}
	else
	{
		LOG_WRN("Security failed: %s level %u err %d", addr,
				level, err);

		sprintf(ddata, "Security failed: %s level %u err %d\n", addr, level, err);
		send_through_uart(ddata);
	}

	gatt_discover(conn);
}

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

	// TODO: commented now
	.security_changed = security_changed
	};

static void scan_filter_match(struct bt_scan_device_info *device_info,
							  struct bt_scan_filter_match *filter_match,
							  bool connectable)
{
	char addr[BT_ADDR_LE_STR_LEN];

	bt_addr_le_to_str(device_info->recv_info->addr, addr, sizeof(addr));

	LOG_INF("Filters matched. Address: %s connectable: %d",
			addr, connectable);

	send_through_uart("Filters matched\n");
}

static void scan_connecting_error(struct bt_scan_device_info *device_info)
{
	LOG_WRN("Connecting failed");

	send_through_uart("Connecting failed\n");
}

static void scan_connecting(struct bt_scan_device_info *device_info,
							struct bt_conn *conn)
{
	default_conn = bt_conn_ref(conn);
}

static int nus_client_init(void)
{
	int err;
	struct bt_nus_client_init_param init = {
		.cb = {
			.received = ble_data_received,
			.sent = ble_data_sent,
		}};

	err = bt_nus_client_init(&nus_client, &init);
	if (err)
	{
		LOG_ERR("NUS Client initialization failed (err %d)", err);

		send_through_uart("NUS Client initialization failed\n");

		return err;
	}

	LOG_INF("NUS Client module initialized");

	send_through_uart("NUS Client module initialized\n");

	return err;
}

BT_SCAN_CB_INIT(scan_cb, scan_filter_match, NULL,
				scan_connecting_error, scan_connecting);

static int scan_init(void)
{
	int err;
		// TODO:need to un comment that
		// struct bt_scan_init_param scan_init = {
		// 	.connect_if_match = 1,
		// };

	 struct bt_scan_init_param scan_init = {
        .scan_param = &scan1_param,
		.connect_if_match = 1,
		.conn_param = &conn1_param,
	};

	bt_scan_init(&scan_init);
	bt_scan_cb_register(&scan_cb);

	err = bt_scan_filter_add(BT_SCAN_FILTER_TYPE_UUID, BT_UUID_NUS_SERVICE);
	if (err)
	{
		LOG_ERR("Scanning filters cannot be set (err %d)", err);

		send_through_uart("Scanning filters cannot be set\n");

		return err;
	}

	err = bt_scan_filter_enable(BT_SCAN_UUID_FILTER, false);
	if (err)
	{
		LOG_ERR("Filters cannot be turned on (err %d)", err);

		send_through_uart("Filters cannot be turned on\n");

		return err;
	}

	LOG_INF("Scan module initialized");

	send_through_uart("Scan module initialized\n");

	return err;
}

static void auth_cancel(struct bt_conn *conn)
{
	char addr[BT_ADDR_LE_STR_LEN];

	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

	LOG_INF("Pairing cancelled: %s", addr);

	send_through_uart("Pairing cancelled:\n");
}

static void pairing_complete(struct bt_conn *conn, bool bonded)
{
	char addr[BT_ADDR_LE_STR_LEN];

	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

	LOG_INF("Pairing completed: %s, bonded: %d", addr, bonded);

	send_through_uart("Pairing completed: , bonded\n");
}

static void pairing_failed(struct bt_conn *conn, enum bt_security_err reason)
{
	char addr[BT_ADDR_LE_STR_LEN];

	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

	LOG_WRN("Pairing failed conn: %s, reason %d", addr, reason);

	send_through_uart("Pairing failed conn:\n");
}

static struct bt_conn_auth_cb conn_auth_callbacks = {
	.cancel = auth_cancel,

	// TODO: changed
	.passkey_display = NULL,
	.passkey_confirm = NULL,
	.pairing_confirm = NULL,
};

static struct bt_conn_auth_info_cb conn_auth_info_callbacks = {
	.pairing_complete = pairing_complete,
	.pairing_failed = pairing_failed};

void bluetooth_init(void)
{
	int err;

	// TODO: commented Now
	err = bt_conn_auth_cb_register(&conn_auth_callbacks);
	if (err)
	{
		LOG_ERR("Failed to register authorization callbacks.");

		send_through_uart("Failed to register authorization callbacks.\n");
		return;
	}

	err = bt_conn_auth_info_cb_register(&conn_auth_info_callbacks);
	if (err)
	{
		printk("Failed to register authorization info callbacks.\n");

		send_through_uart("Failed to register authorization info callbacks.\n");
		return;
	}

	err = bt_enable(NULL);
	if (err)
	{
		LOG_ERR("Bluetooth init failed (err %d)", err);

		send_through_uart("Bluetooth init failed\n");
		return;
	}
	LOG_INF("Bluetooth initialized");

	send_through_uart("Bluetooth initialized\n");

	if (IS_ENABLED(CONFIG_SETTINGS))
	{
		settings_load();
	}
}

void scan_start(void)
{
	int err;
	err = bt_scan_start(BT_SCAN_TYPE_SCAN_ACTIVE);
	if (err)
	{
		LOG_ERR("Scanning failed to start (err %d)", err);

		send_through_uart("Scanning failed to start \n");
		return;
	}
	else
	{
		send_through_uart("Scanning started\n");
	}
}

Scanner can able do MTU exchange and service discovery but it not receiving data, here is debug prints prints

18-08-2023 10:01:04.668 [RX] - <NUL>*** Booting Zephyr OS build v3.2.99-ncs2 ***<CR><LF>

18-08-2023 10:01:08.046 [RX] - Bluetooth initialized<LF>
Scan module initialized<LF>
NUS Client module initialized<LF>
GND Scanner Application Started<CR><LF>
TIME:UTC<CR><LF>

18-08-2023 10:01:12.880 [RX] - TIME:ACK<CR><LF>
Scanning started<LF>

18-08-2023 10:01:20.195 [RX] - Filters matched<LF>
Connected<LF>
MTU exchange done<LF>
Service discovery completed<LF>

18-08-2023 10:01:22.192 [RX] - Disconnected: FF:15:11:11:11:C3 (random) (reason 19)

after sending data from peripheral I'm disconnecting from peripheral side that data I'm not able to see in scanner.

RE: nRF52 SDK peripheral is not connecting to nRF-Connect SDK central device

Hung Bui — Mon, 14 Aug 2023 11:18:12 GMT

Hi Kumar,

It's pretty strange. They should be compatible.
Could you try to do only scanning and no connecting. Just to see if you can scan the advertising packet of nRF5 SDK advertiser on NCS scanner.

After that if you can see the advertising packet, you can try to connect. If it doesn't work check if you receive a timeout.

Also use nRF Sniffer and check if you see any connect request sent from the scanner.

Please try to test using some simple application in our SDK, for example peripheral lbs and central lbs (ble_app_blinky and ble_app_blinky_c)