Using ESP32S3 with Bluetooth for Camera Control - NO commands work

[jonebersole]

I've spent the better part of 4 full days trying to get my ESP32S3 device to connect and issue the simplest commands; shutter commands. I've read all of the bluetooth online docs and went through as many tutorials as I can find, as well as many many online searches. I've tried using AdruinoBLE, straight BLE, and NimBLE libraries. I can scan, see, and connect (pair) to the GoPro ServiceUUID "fea6" and then poll the different UUID's for communicating the GoPro.

I'm using a GoPro Hero 13 Black. Running firmware v02.10.00
I'm using using a SparkFun ESP32-S3 with 2.4GHz Wifi and BLE 5 capabilities
I am using latest BLE libraries built into Arduino and AurduioBLE, NimBLE.
I ran the .net C# version of the demo project with my Windows11 computer and it connects and issues the shutter commands fine.
I ran the LightBlue app on my iPhone, selected Big Endian, 4byte max and set to Hex and wrote the value 03010101 followed by 03010100 to the "b5f90072-aa8d-11e3-9046-0002a5d5c51b" characteristic and it turns on/off the camera just fine.

If I run my Arduino code and send a characteristic->writeValue() command using any of the combinations below, nothing works. The camera doesn't respond and the command 'appears' to be successful. No failures, but no responses either with the notify property "b5f90073-aa8d-11e3-9046-0002a5d5c51b"

This the reference;
https://gopro.github.io/OpenGoPro/ble/protocol/data_protocol.html

(yes, i realize some of these aren't really valid, but i was grasping for straws)
uint8_t data[4] = { 0x03, 0x01, 0x01, 0x01 };
uint8_t data[4] = { 0x01, 0x01, 0x01, 0x03 };
uint8_t data[4] = { 0x3, 0x1, 0x1, 0x1 };
uint8_t data[4] = { 0x1, 0x1, 0x1, 0x3 };
uint8_t data[4] = { 3, 1, 1, 1 };
uint8_t data[4] = { 1, 1, 1, 3 };
uint8_t data = 0x3111;
uint8_t data = 0x1113;

The list above is hardly all of the different variations and attempts I made to issue a command. Including using other characteristics for other commands as well. I also tries creating a uint32_t string and doing a big-endian conversion of it to uint8_t and either i wasn't doing it right or

From all of my research, the Open GoPro documentation indicates that you should send Big Endian data unless otherwise specified. The ESP32-S3 libraries (from my research) indicate they they use Little Endian. So I'm at a complete loss here. I can normally figure this kind of problem out, but I think its time to ask for some help. I typically code in other languages, so it's been a while since i did a lot of c/c++ dev work, so forgive my mess. At this point, I'm just building the skills/framework in test projects.

Below is the code I'm using, which is an example sketch that comes with Arduino. Most of it doesn't apply. I just commented out what i wasn't using for testing. After it creates a BLE connection to the GoPro, it simply tries to write a shutter on command every 5 seconds inside the loop. Any help on how to properly send these commands would be GREATLY appreciated!

/*
  Secure client with static passkey and IRK retrieval

  This example demonstrates how to create a secure BLE client that connects to
  a secure BLE server using a static passkey without prompting the user.
  The client will automatically use the same passkey (123456) as the server.

  After successful bonding, the example demonstrates how to retrieve the
  server's Identity Resolving Key (IRK) in multiple formats:
  - Comma-separated hex format: 0x1A,0x1B,0x1C,...
  - Base64 encoded (for Home Assistant Private BLE Device service)
  - Reverse hex order (for Home Assistant ESPresense)

  This client is designed to work with the Server_secure_static_passkey example.

  Note that ESP32 uses Bluedroid by default and the other SoCs use NimBLE.
  Bluedroid initiates security on-connect, while NimBLE initiates security on-demand.
  This means that in NimBLE you can read the insecure characteristic without entering
  the passkey. This is not possible in Bluedroid.

  IMPORTANT:
  - MITM (Man-In-The-Middle protection) must be enabled for password prompts to work.
  - Bonding must be enabled to store and retrieve the IRK.
  - The server must distribute its Identity Key during pairing.

  Based on examples from Neil Kolban and h2zero.
  Created by lucasssvaz.
*/

#include "BLEDevice.h"
#include "BLESecurity.h"
#include "nvs_flash.h"

// The remote service we wish to connect to.
static BLEUUID serviceUUID("fea6");
// The characteristics of the remote service we are interested in.
static BLEUUID insecureCharUUID("b5f90072-aa8d-11e3-9046-0002a5d5c51b");
// static BLEUUID secureCharUUID("ff1d2614-e2d6-4c87-9154-6625d39ca7f8");

// This must match the server's passkey
#define CLIENT_PIN 123456

static boolean doConnect = false;
static boolean connected = false;
static boolean doScan = false;
static BLEClient *pClient = nullptr;
static BLERemoteCharacteristic *pRemoteInsecureCharacteristic;
static BLERemoteCharacteristic *pRemoteSecureCharacteristic;
static BLEAdvertisedDevice *myDevice;

// Print an IRK buffer as hex with leading zeros and ':' separator
static void printIrkBinary(uint8_t *irk) {
  for (int i = 0; i < 16; i++) {
    if (irk[i] < 0x10) {
      Serial.print("0");
    }
    Serial.print(irk[i], HEX);
    if (i < 15) {
      Serial.print(":");
    }
  }
}

static void get_peer_irk(BLEAddress peerAddr) {
  Serial.println("\n=== Retrieving peer IRK (Server) ===\n");

  uint8_t irk[16];

  // Get IRK in binary format
  if (BLEDevice::getPeerIRK(peerAddr, irk)) {
    Serial.println("Successfully retrieved peer IRK in binary format:");
    printIrkBinary(irk);
    Serial.println("\n");
  }

  // Get IRK in different string formats
  String irkString = BLEDevice::getPeerIRKString(peerAddr);
  String irkBase64 = BLEDevice::getPeerIRKBase64(peerAddr);
  String irkReverse = BLEDevice::getPeerIRKReverse(peerAddr);

  if (irkString.length() > 0) {
    Serial.println("Successfully retrieved peer IRK in multiple formats:\n");
    Serial.print("IRK (comma-separated hex): ");
    Serial.println(irkString);
    Serial.print("IRK (Base64 for Home Assistant Private BLE Device): ");
    Serial.println(irkBase64);
    Serial.print("IRK (reverse hex for Home Assistant ESPresense): ");
    Serial.println(irkReverse);
    Serial.println();
  } else {
    Serial.println("!!! Failed to retrieve peer IRK !!!");
    Serial.println("This is expected if bonding is disabled or the peer doesn't distribute its Identity Key.");
    Serial.println("To enable bonding, change setAuthenticationMode to: pSecurity->setAuthenticationMode(true, true, true);\n");
  }

  Serial.println("=======================================\n");
}

// Callback function to handle notifications
static void notifyCallback(BLERemoteCharacteristic *pBLERemoteCharacteristic, uint8_t *pData, size_t length, bool isNotify) {
  Serial.print("Notify callback for characteristic ");
  Serial.print(pBLERemoteCharacteristic->getUUID().toString().c_str());
  Serial.print(" of data length ");
  Serial.println(length);
  Serial.print("data: ");
  Serial.write(pData, length);
  Serial.println();
}

class MyClientCallback : public BLEClientCallbacks {
  void onConnect(BLEClient *pclient) {
    Serial.println("Connected to secure server");
  }

  void onDisconnect(BLEClient *pclient) {
    connected = false;
    Serial.println("Disconnected from server");
  }
};

// Security callbacks to print IRKs once authentication completes
class MySecurityCallbacks : public BLESecurityCallbacks {
#if defined(CONFIG_BLUEDROID_ENABLED)
  void onAuthenticationComplete(esp_ble_auth_cmpl_t desc) override {
    // Print the IRK received by the peer
    BLEAddress peerAddr(desc.bd_addr);
    get_peer_irk(peerAddr);
  }
#endif

#if defined(CONFIG_NIMBLE_ENABLED)
  void onAuthenticationComplete(ble_gap_conn_desc *desc) override {
    // Print the IRK received by the peer
    BLEAddress peerAddr(desc->peer_id_addr.val, desc->peer_id_addr.type);
    get_peer_irk(peerAddr);
  }
#endif
};

bool connectToServer() {
  Serial.print("Forming a secure connection to ");
  Serial.println(myDevice->getAddress().toString().c_str());

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

  pClient->setClientCallbacks(new MyClientCallback());

  // Connect to the remote BLE Server.
  pClient->connect(myDevice);
  Serial.println(" - Connected to server");

  // Set MTU to maximum for better performance
  pClient->setMTU(517);

  // Obtain a reference to the service we are after in the remote BLE server.
  BLERemoteService *pRemoteService = pClient->getService(serviceUUID);
  if (pRemoteService == nullptr) {
    Serial.print("Failed to find our service UUID: ");
    Serial.println(serviceUUID.toString().c_str());
    pClient->disconnect();
    return false;
  }
  Serial.println(" - Found our service");

  // Obtain a reference to the insecure characteristic
  pRemoteInsecureCharacteristic = pRemoteService->getCharacteristic(insecureCharUUID);
  if (pRemoteInsecureCharacteristic == nullptr) {
    Serial.print("Failed to find insecure characteristic UUID: ");
    Serial.println(insecureCharUUID.toString().c_str());
    pClient->disconnect();
    return false;
  }
  Serial.print(" - Found insecure characteristic ");
  Serial.println(insecureCharUUID.toString().c_str());

  // // Obtain a reference to the secure characteristic
  // pRemoteSecureCharacteristic = pRemoteService->getCharacteristic(secureCharUUID);
  // if (pRemoteSecureCharacteristic == nullptr) {
  //   Serial.print("Failed to find secure characteristic UUID: ");
  //   Serial.println(secureCharUUID.toString().c_str());
  //   pClient->disconnect();
  //   return false;
  // }
  // Serial.println(" - Found secure characteristic");
  Serial.println("checking can write property");
  Serial.println(pRemoteInsecureCharacteristic->getUUID().toString().c_str());
  // Read the value of the insecure characteristic (should work without authentication)
  if (pRemoteInsecureCharacteristic->canWrite()) {
    // String value = pRemoteInsecureCharacteristic->readValue();
    Serial.println("Insecure characteristic can write");
    // Serial.println(value.c_str());
  }

  Serial.println("setting auth");
  // For Bluedroid, we need to set the authentication request type for the secure characteristic
  // This is not needed for NimBLE and will be ignored.
  // pRemoteSecureCharacteristic->setAuth(ESP_GATT_AUTH_REQ_MITM);
  Serial.println("set auth complete");
  // // Try to read the secure characteristic (this will trigger security negotiation in NimBLE)
  // if (pRemoteSecureCharacteristic->canRead()) {
  //   Serial.println("Attempting to read secure characteristic...");
  //   String value = pRemoteSecureCharacteristic->readValue();
  //   Serial.print("Secure characteristic value: ");
  //   Serial.println(value.c_str());
  // }

  // Register for notifications on both characteristics if they support it
  if (pRemoteInsecureCharacteristic->canNotify()) {
    pRemoteInsecureCharacteristic->registerForNotify(notifyCallback);
    Serial.println(" - Registered for insecure characteristic notifications");
  } else Serial.println("not registered for notify");

  // if (pRemoteSecureCharacteristic->canNotify()) {
  //   pRemoteSecureCharacteristic->registerForNotify(notifyCallback);
  //   Serial.println(" - Registered for secure characteristic notifications");
  // }

  connected = true;
  return true;
}

/**
 * Scan for BLE servers and find the first one that advertises the service we are looking for.
 */
class MyAdvertisedDeviceCallbacks : public BLEAdvertisedDeviceCallbacks {
  /**
   * Called for each advertising BLE server.
   */
  void onResult(BLEAdvertisedDevice advertisedDevice) {
    Serial.print("BLE Advertised Device found: ");
    // Serial.println(advertisedDevice.toString().c_str());

    // We have found a device, let us now see if it contains the service we are looking for.
    Serial.println(serviceUUID.toString().c_str());

    if (advertisedDevice.haveServiceUUID() && advertisedDevice.isAdvertisingService(serviceUUID)) {
      Serial.println("Found our secure server!");
      BLEDevice::getScan()->stop();
      myDevice = new BLEAdvertisedDevice(advertisedDevice);
      doConnect = true;
      doScan = true;
    }
  }
};

void setup() {
  Serial.begin(115200);
  Serial.println("Starting Secure BLE Client application...");

  // Clear NVS to remove any cached pairing information
  // This ensures fresh authentication for testing
  Serial.println("Clearing NVS pairing data...");
  // nvs_flash_erase();
  // nvs_flash_init();

  BLEDevice::init("Secure BLE Client");

  // Set up security with the same passkey as the server
  BLESecurity *pSecurity = new BLESecurity();

  // Set security parameters
  // Default parameters:
  // - IO capability is set to NONE
  // - Initiator and responder key distribution flags are set to both encryption and identity keys.
  // - Passkey is set to BLE_SM_DEFAULT_PASSKEY (123456). It will warn if you don't change it.
  // - Key size is set to 16 bytes

  // Set the same static passkey as the server
  // The first argument defines if the passkey is static or random.
  // The second argument is the passkey (ignored when using a random passkey).
  pSecurity->setPassKey(true, CLIENT_PIN);

  // Set authentication mode to match server requirements
  // Enable bonding, MITM (for password prompts), and secure connection for this example
  // Bonding is required to store and retrieve the IRK
  pSecurity->setAuthenticationMode(true, true, true);

  // Set IO capability to KeyboardOnly
  // We need the proper IO capability for MITM authentication even
  // if the passkey is static and won't be entered by the user
  // See https://www.bluetooth.com/blog/bluetooth-pairing-part-2-key-generation-methods/
  pSecurity->setCapability(ESP_IO_CAP_IN);

  // Set callbacks to handle authentication completion and print IRKs
  BLEDevice::setSecurityCallbacks(new MySecurityCallbacks());

  // Retrieve a Scanner and set the callback we want to use to be informed when we
  // have detected a new device. Specify that we want active scanning and start the
  // scan to run for 5 seconds.
  BLEScan *pBLEScan = BLEDevice::getScan();
  pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
  pBLEScan->setInterval(1349);
  pBLEScan->setWindow(449);
  pBLEScan->setActiveScan(true);
  pBLEScan->start(5, false);
}

void loop() {
  // If the flag "doConnect" is true then we have scanned for and found the desired
  // BLE Server with which we wish to connect. Now we connect to it.
  if (doConnect == true) {
    if (connectToServer()) {
      Serial.println("We are now connected to the secure BLE Server.");
    } else {
      Serial.println("We have failed to connect to the server; there is nothing more we will do.");
    }
    doConnect = false;
  }

  // If we are connected to a peer BLE Server, demonstrate secure communication
  **if (connected) {
    // Write to the insecure characteristic
    String insecureValue = "Client time: " + String(millis() / 1000);
    if (pRemoteInsecureCharacteristic->canWrite()) {      
      uint8_t d[] = { 0x01, 0x01, 0x01, 0x03 };
      pRemoteInsecureCharacteristic->writeValue(d,false);
      // pRemoteInsecureCharacteristic->writeValue(insecureValue.c_str(), insecureValue.length());
      Serial.println("Wrote to insecure characteristic: " + insecureValue);
    }**

    // Write to the secure characteristic
    // String secureValue = "Secure client time: " + String(millis() / 1000);
    // if (pRemoteSecureCharacteristic->canWrite()) {
    //   pRemoteSecureCharacteristic->writeValue(secureValue.c_str(), secureValue.length());
    //   Serial.println("Wrote to secure characteristic: " + secureValue);
    // }
  } else if (doScan) {
    // Restart scanning if we're disconnected
    BLEDevice::getScan()->start(0);
  }

  delay(5000);  // Delay 2 seconds between loops
}

[coliseumdiscomovil-lgtm]

Hola, no se si te podrá servir, pero yo tuve problemas para obtener el ssid y la contraseña de la wifi de mi gopro 10, no habia manera siguiendo la api de gopro. Al final lo conseguí creando un archivo de consulta de parametros a la misma gopro, ahi pude ver como obtener la ssid y la contraseña, el caso es que eran unos parametros distintos (era mas como entrar por otra puerta) y así lo pude hacer funcionar. Se que no es el mismo caso, pero hacer una consulta con codigo a la gopro puede que te diga lo que tienes que poner exactamente.
Un saludo

Google transalte:
Hi, I don't know if this will help, but I had trouble getting the SSID and Wi-Fi password for my GoPro 10. I couldn't get it using the GoPro API. I finally managed to do it by creating a parameter query file for the GoPro itself. That way I could see how to get the SSID and password. The thing is, the parameters were different (it was more like going through a different door), and that's how I got it working. I know it's not the same situation, but querying the GoPro with code might tell you exactly what you need to enter.
Cheers

[jonebersole]

Ok, I eventually did get this to work. The trick was that I needed to use BLE security during my connection to the GoPro. In all of my testing, straight BLE pairing (without security) doesn't let you send commands. I hope this helps others. Thanks for the reply.