RE: Service discovery failed in the BLE connection with Zephyr

dejans — Thu, 01 Feb 2024 17:20:28 GMT

Hi,

Could you share complete log which shows the error?

Best regards,
Dejan

RE: Service discovery failed in the BLE connection with Zephyr

Ankit_chauhan — Wed, 31 Jan 2024 07:43:06 GMT

Hi,

Thanks for your reply.

I am using v2.4.0 and the Bluetooth Central Multilink sample code from the Zephyr sample to implement the solution.

I have updated the handling functions as per my requirement but maintain the operation flow similar to the sample.

Here are the functions that I am currently using from the sample code.

1. The BLE connection handling

/* The scan function to connect the BLE peripherals */
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) {
		LOG_ERR("Scanning failed to start (err %d)\n", err);
		return;
	}

	printk("Scanning successfully started\n");
}


/* The scan function Callback handler */
static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
			 struct net_buf_simple *ad)
{
	if(!strcmp(name, sensor_tag_details.name)) {
		printk("Your Device Found.\n");
		memset(Connection_device_detail, 0x00, sizeof(Connection_device_detail));
		if(sensor_tag_details.type == SENSOR_1) {
			strcpy(Connection_device_detail,"sensor_1");
		} else {
			strcpy(Connection_device_detail,"sensor_2");
		}

		err = bt_le_scan_stop();
		if (err) {
			printk("%s: Stop LE scan failed (err %d)\n", __func__, err);
			return;
		}

		static struct bt_conn *tempconn;
		err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN,
				BT_LE_CONN_PARAM_DEFAULT, &tempconn);
		if (err) {
			printk("%s: Create conn failed (err %d)\n", __func__, err);
			start_scan();
		} else {
			uint8_t conn_index = bt_conn_index(tempconn);
			connecting_index = conn_index;
			printk("Connection index= %d.\n", conn_index);
			connections[conn_index] = tempconn;
			tempconn = NULL;
			is_conn_cmd_rcvd = false;
		}
	}
}


/* Connected callback function */
static void connected(struct bt_conn *conn, uint8_t err)
{
	char addr[BT_ADDR_LE_STR_LEN];
	uint8_t conn_err;

	struct bt_conn_info info;
    bt_conn_get_info(conn, &info);

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

	if(info.role == BT_CONN_ROLE_MASTER) {
		if (err) {
			printk("Failed to connect to %s (%u)\n", addr, err);
			start_scan();
			return;
		}
		
		conn_index = bt_conn_index(conn);
		printk("Connected_conn_index: %s %d\n", addr, conn_index);
		
		if (conn == connections[conn_index]) {
			conn_count++;
		#if defined(CONFIG_BT_SMP)
			conn_err = bt_conn_set_security(connections[conn_index], BT_SECURITY_L1);
			if (conn_err) {
				printk("Failed to set security: %d\n", conn_err);
				return;
			}
		#endif


		#if defined(CONFIG_BT_GATT_CLIENT)
			mtu_exchange(connections[conn_index]);
		#endif

			service_disc.tagtype = sensor_tag_details.type;
			sh_discover_primary_svc(conn, &sys_uuid.uuid);
		}
		if (conn_count < CONFIG_BT_MAX_CONN) {
			start_scan();
		}
	}

	if(info.role == BT_CONN_ROLE_SLAVE) {
		if(err) {
			printk("Failed to connect to %s (%u)\n", addr, err);
		} else {
			printk("Connected: %s\n", addr);
		}
	}

}

2. BLE service discovery handling

/* Service discovery function to initiate all the services and characteristics of the sensors */
static uint8_t sh_discover_primary_svc(struct bt_conn *conn,
							const struct bt_uuid *uuid)
{
	int err;

	char *dev_type = get_sensor_type_by_index(ble_manager, bt_conn_index(conn));
	printk("Origial device type = %s.\n", dev_type);
	discover_params.uuid = uuid;
	if(!strcmp("sensor_1", dev_type)) {
		printk("Received device type: sensor_1");
		discover_params.func = sensor_1_discover_func;
	} else {
		printk("Received device type: sensor_2");
		discover_params.func = sensor_2_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(conn, &discover_params);
	if (err) {
		LOG_ERR("Discover failed (err %d)\n", err);
	}
	return err;
}


/* Service discovery hanlder function of the sensors */
static __attribute__((unused)) uint8_t sensor_1_discover_func(struct bt_conn *conn,
			     const struct bt_gatt_attr *attr,
			     struct bt_gatt_discover_params *params)
{
	//My descover function that handls the discovery of services, characteristics, and descriptors
}

static __attribute__((unused)) uint8_t sensor_2_discover_func(struct bt_conn *conn,
			     const struct bt_gatt_attr *attr,
			     struct bt_gatt_discover_params *params)
{
	//My descover function that handls the discovery of services, characteristics, and descriptors
}

3. This is how I am reading the sensor characteristics

/* Function to read a characteristic given its UUID */
void read_characteristic(struct bt_conn *conn, char *device_type) {
    struct bt_conn *read_conn;
    // struct bt_gatt_read_params read_params;
	bt_addr_le_t addr;
	struct bt_conn_info info;
	int err;

	// Check if the connection pointer is not NULL
	if (conn != NULL) {
		printk("Before bt_conn_lookup_addr_le\n");
		bt_addr_le_copy(&addr, bt_conn_get_dst(conn));
		printk("After bt_conn_lookup_addr_le\n");

		// Now you can use 'addr' for further processing
	} else {
		printk("Error: Connection pointer is NULL\n");
		return;
	}

    /* Get the default connection */
    read_conn = bt_conn_lookup_addr_le(BT_ID_DEFAULT, &addr);
    if (!read_conn) {
        printk("Not connected\n");
        return;
    } else {
		printk("Get the connection.\n");
	}
	if(!strcmp(device_type, "sensor_1")) {
		for (int i = 0; i < 4; i++) {
			if(!read_conn) {
			printk("No connection found.\n");
			return;
			} else {

				/* Start reading the characteristic */
				int err = bt_gatt_read(read_conn, &sensor_1_read_params_array[i]);
				printk("starting read: %d\n", err);
				if (err) {
					printk("Error starting read: %d\n", err);
				} {
					printk("read sucessfully.\n");
				}
				// if (read_conn) {
				// 	bt_conn_unref(read_conn);
				// }
			}
		}
	} else if (!strcmp(device_type, "sensor_2")) {
		for (int i = 0; i < 6; i++) {
			if(!read_conn) {
			printk("No connection found.\n");
			return;
			} else {

				/* Start reading the characteristic */
				int err = bt_gatt_read(read_conn, &sensor_1_read_params_array[i]);
				printk("starting read: %d\n", err);
				if (err) {
					printk("Error starting read: %d\n", err);
				} {
					printk("read sucessfully.\n");
				}
				// if (read_conn) {
				// 	bt_conn_unref(read_conn);
				// }
			}
		}
	}

	if (read_conn) {
		bt_conn_unref(read_conn);
	}
}

static struct bt_gatt_read_params sensor_1_read_params_array[] = {
    {
        .func = temp_read_cb,
        .handle_count = 1,
		.single.handle = 45,
        .single.offset = 0,
    },
    {
        .func = hr_read_cb,
        .handle_count = 1,
		.single.handle = 64,
        .single.offset = 0,
    },
    {
        .func = bat_read_cb,
        .handle_count = 1,
		.single.handle = 48,
        .single.offset = 0,
    },
	{
        .func = sys_stat_cb,
        .handle_count = 1,
		.single.handle = 60,
        .single.offset = 0,
    },
	
};



/* Callback function for characteristic read */
static void temp_read_cb(struct bt_conn *conn, uint8_t err,
                    struct bt_gatt_read_params *params, const void *data,
                    uint16_t length, uint16_t handle) {

	// printk("In temp_read_cb.\n");
    if (err) {
        printk("Error reading data: %u\n", err);
        return;
    }

    if (!data) {
        printk("No data received\n");
        return;
    }

	uint8_t* notif_data = (uint8_t*) data;
	 
	
    // printk("Read data \n: ");
    // for(int i = 0; i<length; i++)
	// {
	// 	printk("%x ", notif_data[i]);
	// }

    // printk("\n");

	printk("Temprature value = %d.\n", notif_data[4]);

	// chest_tmp = notif_data[4];
	atomic_set(&chest_tmp, notif_data[4]);
}

I have identified that the connection, service discovery, and all other operations are working fine for individual sensors.

But when I started reading the sensor_1 data continuously every second using the read_characteristic function, and then I tried to connect the sensor_2 it did not discover its services and reported the error as I mentioned in my first question.

Regards...

RE: Service discovery failed in the BLE connection with Zephyr

dejans — Fri, 26 Jan 2024 11:13:20 GMT

Hi,

Which NCS version do you use?

Is your application based on any of existing NCS samples? If so, have you modified the sample in any way?

Best regards,
Dejan