How to enumerate characteristics UUIDs

[BigJBehr]

I am attempting to use the BLE Client on an ESP32 to connect with a bluetooth device that has a joystick and some buttons. I was able to discover the service UUID and change the service UUID in the example BLE Client. Now I can connect to the remote device. However, I do not know what the characteristic UUIDs are. Would you be so kind as to please provide an example of how to enumerate the characteristic UUIDs once a device is connected.

[chegewara]

One quick question, is it standard bluetooth ble joystick? Which is recognised by windows as a joystick?

[nkolban]

You bring up an interesting question ... one that I personally have never considered before and I'm not sure what the right answer should be ... so let's chat about it together.

Imagine we have an "alien" BLE Server. This is a server that we know nothing about. It is not an ESP32. We now have an ESP32 client and wish to "work" with that BLE server. I have assumed up till now that you would use a tool (eg. nRFConnect or bluetoothctl) to examine the BLE server and manually learn "what it is and what it does". Typically, you are given a "specification" sheet of such a device and are told "This device exposes a service with UUID xyz and this service has characteristics with UUIDS abc, def and ghi". You would then write an app that uses these values and you are good to go.

What I think I am hearing from you here is a desire to "dynamically" interrogate a BLE server and, at run-time, determine the IDs contained within it. While this is technically possible (and in fact is already performed within the internals of BLE) I don't think we considered it as a capability to be externally exposed to BLE programmers. We can most certainly change that.

However, before I go off into the darkness to implement some code, I want to understand in greater depth what it is you are looking for and how it would be used. Would you be able to describe a "user story" or patterns where such a feature would be useful and how it would be used?

[nkolban]

A colleague pointed out to me that we actually already have the ability to determine the characteristics.

When we connect to a remote BLE Server, we use a class called BLEClient. Once we have a BLEClient object, we can call its getServices() method. This returns a C++ map object that contains all the services exposed by the remote BLE Server. This includes a BLERemoteService reference for each service.

From a BLERemoteService object, we can call its getCharacteristics() method which returns a map of all the characteristics associated with that service (remember .. there is a tree structure here). A BLE Server can have 1 or more services and each service can have one or more characteristics.

The C++ map object might possibly be new to you. Investing time studying the docs on C++ maps generically will be the way to go and then you can apply those skills in the BLE environment.

try a google using "c++ map iterator" for examples.

[BigJBehr]

Thanks for looking into this for me. I will look into C++ maps. I have worked with C/C++ for decades and still do not know everything about C++. Seems like I learn what I need to get by and no more.

I found that an app on my Android device gives me all of the service UUIDs and characteristic UUIDs for each service. Using this information I was able to twist your BLE Client for the ESP32 to work with the hand-held mouse/pointer device I wanted to interface with.
The main service UUID is 0x1812 (HID device). This service has 10 characteristic UUIDs associated with it. Of those 10, six are reports (UUID 0x2A4D). I have handles for each of the reports.

New questions;
1 - How can I get the BLE Client to receive notifications from multiple reports under one service ?
2 - How can I get the BLE Client to use multiple services at the same time ?

Multiple notification is because different reports are reporting different sets of buttons an the device. No single report has all of the button data.
Multiple services because the HID Device service has the button reports and the Battery Service (UUID 0x180F ) has the battery voltage.

One last question, Is there any Arduino libraries for the ESP32 that allow working with classic Bluetooth ?
I have a Bluetooth gamepad that I would love to use, but it is Bluetooth 2.0 EDR, not BLE.
Thanks in advance.

[chegewara]

Hi @BigJBehr
I see you are trying to build esp32 hid host and i dont want to scare you at all, but when ive been building hid peripheral library ive found how hard it is. Its a lot esier if you want to create hid host for one particular peripheral because you know its data structure. Now back to your questions.
For each characteristic you can have function that will handle notification. So if you have 6 report characteristics you can have 6 functions to handle its notifications. It does not matter what service its belongs to because notifications are bonded to characteristic. If you have more questions i will be happy to answer here or on irc.

[limeylemons80]

Hello! I have a similar question. I am trying to do the same but for a BLE HID selfie stick as a server connecting to an ESP32 WROOM 32 Client. So far I have been able to connect and authenticate the selfie stick but it has been hard to receive any notifications. By the way, I am only a student so most of my code has been copy pasting.

`#include "BLEDevice.h"

// The remote service and characteristic we wish to connect to
static BLEUUID serviceUUID("00001812-0000-1000-8000-00805f9b34fb");
static BLEUUID charUUID("00002a4d-0000-1000-8000-00805f9b34fb");

static boolean doConnect = false;
static boolean connected = false;
static boolean doScan = false;

static BLERemoteCharacteristic* pRemoteCharacteristic;
static BLEAdvertisedDevice* myDevice;
BLEClient* pClient;
BLERemoteService* pRemoteService;

boolean haveChar = true;

static void notifyCallback(
BLERemoteCharacteristic* pBLERemoteCharacteristic,
uint8_t* pData,
size_t length,
bool isNotify) {

Serial.println("Notification received!");
Serial.print("From characteristic UUID: ");
Serial.println(pBLERemoteCharacteristic->getUUID().toString().c_str());
Serial.print("Data length: ");
Serial.println(length);
Serial.print("Data: ");
for (size_t i = 0; i < length; i++) {
Serial.printf("%02X ", pData[i]);
}
Serial.println();
}

class MyClientCallback : public BLEClientCallbacks {
void onConnect(BLEClient* pclient) {}
void onDisconnect(BLEClient* pclient) {
connected = false;
Serial.println("❌ Disconnected from server");
}
};

bool connectToServer() {
Serial.print("🔗 Connecting to ");
Serial.println(myDevice->getAddress().toString().c_str());

BLEDevice::setEncryptionLevel(ESP_BLE_SEC_ENCRYPT);

pClient = BLEDevice::createClient();
Serial.println(" - Created client");

pClient->setClientCallbacks(new MyClientCallback());
pClient->connect(myDevice);

Serial.println("✅ Connected to server");

connected = true;
return true;
}

class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
void onResult(BLEAdvertisedDevice advertisedDevice) {
Serial.print("📡 BLE Device found: ");
Serial.println(advertisedDevice.toString().c_str());

if (!strcmp(advertisedDevice.getName().c_str(), "Selfie")) {
  BLEDevice::getScan()->stop();
  myDevice = new BLEAdvertisedDevice(advertisedDevice);
  doConnect = true;
  doScan = true;
}

}
};
class MySecurity : public BLESecurityCallbacks {
uint32_t onPassKeyRequest() {
Serial.println("🔐 Passkey request");
return 123456; // Default/fallback if needed
}

void onPassKeyNotify(uint32_t pass_key) {
Serial.printf("🔐 Passkey notify: %06d\n", pass_key);
}

bool onConfirmPIN(uint32_t pass_key) {
Serial.printf("🔐 Confirming PIN: %06d\n", pass_key);
return true;
}

bool onSecurityRequest() {
Serial.println("🔐 Security request received");
return true;
}

void onAuthenticationComplete(esp_ble_auth_cmpl_t auth_cmpl) {
if (auth_cmpl.success) {
Serial.println("✅ Authentication succeeded");
} else {
Serial.printf("❌ Authentication failed, reason: 0x%x\n", auth_cmpl.fail_reason);
}
}
};

void setup() {
Serial.begin(115200);
Serial.println("🚀 Starting Arduino BLE Client...");

BLEDevice::init("");
BLESecurity* pSecurity = new BLESecurity();

pSecurity->setAuthenticationMode(ESP_LE_AUTH_REQ_SC_MITM_BOND); // Secure bonding
pSecurity->setCapability(ESP_IO_CAP_IO); // Display/keyboard I/O capability
pSecurity->setInitEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);

BLEDevice::setSecurityCallbacks(new MySecurity());

BLEScan* pBLEScan = BLEDevice::getScan();
pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
pBLEScan->setInterval(1349);
pBLEScan->setWindow(449);
pBLEScan->setActiveScan(true);
pBLEScan->start(5, false);
}

void loop() {
if (doConnect == true) {
if (connectToServer()) {
Serial.println("🎉 Connected to BLE Server.");
} else {
Serial.println("❌ Failed to connect.");
}
doConnect = false;
}

if (Serial.available()) {
if (haveChar) {
haveChar = false;
String incoming = Serial.readString();
serviceUUID = BLEUUID::fromString(incoming.c_str());
} else {
haveChar = true;
String incoming = Serial.readString();
charUUID = BLEUUID::fromString(incoming.c_str());

  if (connected) {
    pRemoteService = pClient->getService(serviceUUID);
    if (pRemoteService == nullptr) {
      Serial.print("Failed to find service UUID: ");
      Serial.println(serviceUUID.toString().c_str());
      pClient->disconnect();
    }

    Serial.print(" - Found service: ");
    Serial.println(serviceUUID.toString().c_str());

    pRemoteCharacteristic = pRemoteService->getCharacteristic(charUUID);
    if (pRemoteCharacteristic == nullptr) {
      Serial.print("Failed to find characteristic UUID: ");
      Serial.println(charUUID.toString().c_str());
      pClient->disconnect();
    }

    Serial.print(" - Found characteristic: ");
    Serial.println(charUUID.toString().c_str());

    Serial.print("Characteristic properties: ");
    Serial.print("Characteristic properties:");

if (pRemoteCharacteristic->canRead()) Serial.print(" Read");
if (pRemoteCharacteristic->canWrite()) Serial.print(" Write");
if (pRemoteCharacteristic->canNotify()) Serial.print(" Notify");
if (pRemoteCharacteristic->canIndicate()) Serial.print(" Indicate");
Serial.println();

    if (pRemoteCharacteristic->canNotify()) {
      pRemoteCharacteristic->registerForNotify(notifyCallback);
      Serial.println("✅ Registered for notify");

      BLERemoteDescriptor* pDescriptor = pRemoteCharacteristic->getDescriptor(BLEUUID((uint16_t)0x2902));
      if (pDescriptor != nullptr) {
        pDescriptor->writeValue((uint8_t*)"\x01\x00", 2, true);
        Serial.println("✅ Notifications manually enabled via CCCD");
      } else {
        Serial.println("❌ CCCD descriptor not found");
      }
    } else {
      Serial.println("Characteristic does not support notify");
    }

    if (pRemoteCharacteristic->canRead()) {
      String value = pRemoteCharacteristic->readValue();
      Serial.print("Characteristic value: ");
      Serial.println(value.c_str());
    }
  }
}

}

if (!connected && doScan) {
BLEDevice::getScan()->start(0); // Restart scan if disconnected
}

delay(1000);
}
`