BLE Peripheral Acts Inconsitently

[MrYsLab]

I would like to begin by stating what I am trying to accomplish, followed by the problem I am currently experiencing.

I am attempting to build a version of Telemtrix for the RPi Pico W that uses BLE as its data transport. The WIFI version works without issue. I have built a Telemetrix version for the ESP32 and Arduino Uno R4 WiFi, both of which utilize the BLE Nordic BLE UART service.

I started by running the BTstack peripheral example from the Arduino IDE. Although there is a comment at the top of the code, I was still able to compile and run it. I was able to connect to it using the LightBlue iOS app and could send and receive data.

Now the issue. If I use a Python client that works for the UNO R4 and ESP32, I am unable to connect to the BTStack peripheral. I receive a timeout message. The device is detected when I run a scan, but I am unable to establish a connection with it.

Do you know why I can connect using my phone app, but not run a Bluetooth Python program that works for two other processor boards?

To sum up, I have two working examples of using Python to communicate with a BLE peripheral. Both of these working examples utilize similar Python code that utilizes the Bleak library, and the peripherals are built using ArduinoBLE.

For the RPi Pico W, I can run the BTstack example only if I connect using an iOS app. Connection fails with similar code used for the two other microcontroller boards.

Here is the code for the peripheral:

// LE Peripheral Example - not working yet
#include <BTstackLib.h>
#include <SPI.h>

/*
   EXAMPLE_START(LEPeripheral): LE Peripheral

   @text BTstack allows to setup a GATT Services and Characteristics directly
   from the setup function without using other tools outside of the Arduino IDE.

   @section Setup

   @text First, a number of callbacks are set. Then, a Service with a Read-only
   Characteristic and a dynamic Characteristic is added to the GATT database.
   In BTstack, a dynamic Characteristic is a Characteristic where reads and writes
   are forwarded to the Sketch. In this example, the dynamic Characteristic is
   provided by the single byte variable characteristic_data.
*/

/* LISTING_START(LEPeripheralSetup): Setup */
static char characteristic_data = 'H';

void setup(void) {

  Serial.begin(9600);

  // set callbacks
  BTstack.setBLEDeviceConnectedCallback(deviceConnectedCallback);
  BTstack.setBLEDeviceDisconnectedCallback(deviceDisconnectedCallback);
  BTstack.setGATTCharacteristicRead(gattReadCallback);
  BTstack.setGATTCharacteristicWrite(gattWriteCallback);

  // setup GATT Database
  BTstack.addGATTService(new UUID("B8E06067-62AD-41BA-9231-206AE80AB551"));
  BTstack.addGATTCharacteristic(new UUID("f897177b-aee8-4767-8ecc-cc694fd5fcef"), ATT_PROPERTY_READ, "This is a String!");
  BTstack.addGATTCharacteristicDynamic(new UUID("f897177b-aee8-4767-8ecc-cc694fd5fce0"), ATT_PROPERTY_READ | ATT_PROPERTY_WRITE | ATT_PROPERTY_NOTIFY, 0);

  // startup Bluetooth and activate advertisements
  BTstack.setup();
  BTstack.startAdvertising();
}
/* LISTING_END(LEPeripheralSetup): Setup */

void loop(void) {
  BTstack.loop();
}

/*
   @section Device Connected Callback

   @text When a remove device connects, device connected callback is callec.
*/
/* LISTING_START(LEPeripheralDeviceConnectedCallback): Device Connected Callback */
void deviceConnectedCallback(BLEStatus status, BLEDevice *device) {
  (void) device;
  switch (status) {
    case BLE_STATUS_OK:
      Serial.println("Device connected!");
      break;
    default:
      break;
  }
}
/* LISTING_END(LEPeripheralDeviceConnectedCallback): Device Connected Callback */

/*
   @section Device Disconnected Callback

   @text If the connection to a device breaks, the device disconnected callback
   is called.
*/
/* LISTING_START(LEPeripheralDeviceDisconnectedCallback): Device Disconnected Callback */
void deviceDisconnectedCallback(BLEDevice * device) {
  (void) device;
  Serial.println("Disconnected.");
}
/* LISTING_END(LEPeripheralDeviceDisconnectedCallback): Device Disconnected Callback */

/*
   @section Read Callback

   @text In BTstack, the Read Callback is first called to query the size of the
   Characteristic Value, before it is called to provide the data.
   Both times, the size has to be returned. The data is only stored in the provided
   buffer, if the buffer argument is not NULL.
   If more than one dynamic Characteristics is used, the value handle is used
   to distinguish them.
*/
/* LISTING_START(LEPeripheralReadCallback): Read Callback */
uint16_t gattReadCallback(uint16_t value_handle, uint8_t * buffer, uint16_t buffer_size) {
  (void) value_handle;
  (void) buffer_size;
  if (buffer) {
    Serial.print("gattReadCallback, value: ");
    Serial.println(characteristic_data, HEX);
    buffer[0] = characteristic_data;
  }
  return 1;
}
/* LISTING_END(LEPeripheralDeviceDisconnectedCallback): Read Callback */

/*
   @section Write Callback

   @text When the remove device writes a Characteristic Value, the Write callback
   is called. The buffer arguments points to the data of size size/
   If more than one dynamic Characteristics is used, the value handle is used
   to distinguish them.
*/
/* LISTING_START(LEPeripheralWriteCallback): Write Callback */
int gattWriteCallback(uint16_t value_handle, uint8_t *buffer, uint16_t size) {
  (void) value_handle;
  (void) size;
  characteristic_data = buffer[0];
  Serial.print("gattWriteCallback , value ");
  Serial.println(characteristic_data, HEX);
  return 0;
}
/* LISTING_END(LEPeripheralWriteCallback): Write Callback */

And now the Python client.

import asyncio
from bleak import BleakClient, BleakScanner
from bleak.backends.device import BLEDevice


async def connect_to_peripheral(device_name_or_address: str):
    """
    Scans for a BLE device by name or address and attempts to connect.
    """
    print(f"Scanning for device: {device_name_or_address}...")

    # Discover devices
    devices = await BleakScanner.discover()

    # target_device: BLEDevice = None
    target_device = None
    for d in devices:
        if d.name == device_name_or_address or d.address == device_name_or_address:
            target_device = d
            break

    if target_device is None:
        print(f"Device '{device_name_or_address}' not found.")
        return

    print(f"Found device: {target_device.name} ({target_device.address})")

    try:
        # Connect to the device using the asynchronous context manager
        async with BleakClient(target_device.address) as client:
            try:
                await self.client.connect()
            except bleak.exc.BleakDBusError:
                raise KeyboardInterrupt
            if client.is_connected:
                print(f"Successfully connected to {target_device.name}!")
                # You can now interact with the peripheral, e.g., read/write characteristics
                # Example: print all services and characteristics
                for service in client.services:
                    print(f"  Service: {service.uuid} (Handle: {service.handle})")
                    for char in service.characteristics:
                        print(
                            f"    Characteristic: {char.uuid} (Handle: {char.handle}, Properties: {char.properties})")
            else:
                print(f"Failed to connect to {target_device.name}.")
    except Exception as e:
        print(f"An error occurred during connection: {e}")


if __name__ == "__main__":
    # Replace with the actual name or address of your BLE peripheral
    peripheral_identifier = "BTstack LE Shield"
    asyncio.run(connect_to_peripheral(peripheral_identifier))

[earlephilhower]

Can you run wireshark and capture the BT comms from the PC side for both working and non-working cases? That would help narrow down what differences are seen.

There is also a debug mode on the Pico. Set Tools->Debug Port->Serial and then Tools->Debug Level->Bluetooth to get the Pico side of the comms. That's at the BTStack HCI level and not the BTStackLib Arduino wrappers, but it's better than nothing to start.

BTStackLib was last updated by the BTStack guys about 7-8 years ago and it could be that you're hitting some bitrot in it. There was a recent discovery and fix #2968 using the above debug process.

[MrYsLab]

@earlephilhower Finally, some progress. I adapted the pico-stdio-ble library for the Arduino build environment.

I can connect and send data to the PICO from a small test program written in Bleak. I still need to test sending data from the Pico to the client.

My goal is to create an Arduino library for Nordic BLE UART support.

I've quite a lot of work ahead to complete this, but at least it's a start.

[earlephilhower]

Ah, good work. You might want to just look at the code they based that off of from the BTStack SDK examples.

Writing for BTStack reminds me a lot of Windows 3.1 and the whole cooperative multitasking message loop processing. But with waaaaaay longer function names and no Charles Petzold to make it understandable by mere humans.

[earlephilhower]

Also be sure to lock around your BTStack calls. See:

arduino-pico/cores/rp2040/cyw43_wrappers.h

Lines 30 to 31 in 93a23fd

	void __lockBluetooth();
	void __unlockBluetooth();

If you don't, it will work sometimes but when an IRQ comes and the CYW43 processing task starts up and does some BT stuff, it will become very unhappy!

[MrYsLab]

So that you know, I placed a pull request to update a typo in the documentation - unlockBluetooth changed to __unlockBluetooth.
A quick question about using the locks and their granularity. Can I lock around a large number of lines of code, or do I need to lock around each BTstack API call?

For example, would this be correct?

void setup(){
    //cyw43_arch_init();
    Serial.begin(115200);

    __lockBluetooth() ;

    hci_event_callback_registration.callback = &hci_packet_handler;
    hci_add_event_handler(&hci_event_callback_registration);

    l2cap_init();
    sm_init();


    att_server_init(profile_data, att_read_callback, NULL);

    // setup Nordic SPP service
    nordic_spp_service_server_init(&nordic_spp_packet_handler);
    att_server_register_packet_handler(att_packet_handler);

    hci_power_control(HCI_POWER_ON);

    BTstack.setup("TelemetrixPicoWX");
    BTstack.startAdvertising();

    __unlockBluetooth() ;
}

Also, should I be locking in the loop section like this?

void loop(void){
    __lockBluetooth() ;
    BTstack.loop();
    __unlockBluetooth() ;
}

I am still having my issues with the port, but will continue to fight through ;-).

[earlephilhower]

I think trying to combine BTStackLib and raw calls will lead to much heartache and gnashing of teeth. Just use the raw calls, they're down in the BTStack examples files (not BTStackLib, the raw ones in pico-sdk/lib/BTStack/examples).

The locking is most important around the BLE SPP character write/read methods since your main app will be doing BT calls and an interrupt could come in. When you're in a BTStack callback handler, things are already locked by the time you're called.