Speed of the ESP32 BLE Client

[foxchoi]

Hi

I currently working on BLE connection between two Xiao ESP32C3 board, one for central and one for server.

I`m trying to sync read and write between two board in 100Hz.

But while I`m performing write and read in central MCU, the time required to perform writeValue and readValue is around 50ms.

The data I`m sending and receiving now is just 1byte data (0x01).

Is there any solution to minimize the time cost of writeValue and readValue function?

      #include "BLEDevice.h"
      //#include "BLEScan.h"
      
      BLEClient*  pClient;
      
      // The remote service we wish to connect to.
      static BLEUUID serviceUUID("4fafc201-1fb5-459e-8fcc-c5c9c331914b");
      // The characteristic of the remote service we are interested in.
      static BLEUUID    charUUID("beb5483e-36e1-4688-b7f5-ea07361b26a8");
      #define target_server "MyESP32"
      
      static boolean doConnect = false;
      static boolean connected = false;
      static boolean doScan = false;
      static BLERemoteCharacteristic* pRemoteCharacteristic;
      static BLEAdvertisedDevice* myDevice;
      
      // Callback function when notify sended
      
      // callback function about the connection
      class MyClientCallback : public BLEClientCallbacks {
        void onConnect(BLEClient* pclient) {
        }
      
        void onDisconnect(BLEClient* pclient) {
          connected = false;
          Serial.println("onDisconnect");
        }
      };
      
      bool connectToServer() {
          Serial.print("Forming a 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);  // if you pass BLEAdvertisedDevice instead of address, it will be recognized type of peer device address (public or private)
          Serial.println(" - Connected to server");
          pClient->setMTU(517); //set client to request maximum MTU from server (default is 23 otherwise)
      //    pClient->setMTU(23); //set client to request maximum MTU from server (default is 23 otherwise)
        
          // 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 characteristic in the service of the remote BLE server.
          pRemoteCharacteristic = pRemoteService->getCharacteristic(charUUID);
          if (pRemoteCharacteristic == nullptr) {
            Serial.print("Failed to find our characteristic UUID: ");
            Serial.println(charUUID.toString().c_str());
            pClient->disconnect();
            return false;
          }
          Serial.println(" - Found our characteristic");
          connected = true;
          return true;
      }
      
      // When device is found
      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());
          Serial.println(advertisedDevice.getServiceDataUUID().toString().c_str());
      
          // We have found a device, let us now see if it contains the service we are looking for.
      //    if (advertisedDevice.haveServiceUUID() && advertisedDevice.isAdvertisingService(serviceUUID)) {
            if(advertisedDevice.getName() == target_server){
            BLEDevice::getScan()->stop();
            myDevice = new BLEAdvertisedDevice(advertisedDevice);
            doConnect = true;
            doScan = true;
            Serial.println("UUID_same");
          } // Found our server
        } // onResult
      }; // MyAdvertisedDeviceCallbacks
      
      
      void setup() {
        Serial.begin(115200);
        while(!Serial){}
        Serial.println("Starting Arduino BLE Client application...");
        BLEDevice::init("");
      
        // Retrieve a Scanner and set the callback we want to use 
        BLEScan* pBLEScan = BLEDevice::getScan();
        pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
        pBLEScan->setInterval(1349);
        pBLEScan->setWindow(449);
        pBLEScan->setActiveScan(true);
        // scan to run for 5 seconds.
        pBLEScan->start(5, false);
      }
      
      
      // This is the Arduino main loop function.
      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.  Once we are 
        // connected we set the connected flag to be true.
        if (doConnect == true) {
          if (connectToServer()) {
            Serial.println("We are now connected to the BLE Server.");
          } else {
            Serial.println("We have failed to connect to the server; there is nothin more we will do.");
          }
          doConnect = false;
        }
      
        // If we are connected to a peer BLE Server, update the characteristic each time we are reached
        // with the current time since boot.
        if (connected) {
          Serial.println(micros());
          // Set the characteristic's value to be the array of bytes that is actually a string.
          pRemoteCharacteristic->writeValue(0x01, 1);
        
          Serial.print(micros());
          Serial.print(" , ");
          if(pRemoteCharacteristic->canRead()) {
            std::string value = pRemoteCharacteristic->readValue();
            Serial.print(" , ");
      //    }
          Serial.println(micros());
        }else if(doScan){
          BLEDevice::getScan()->start(0);  // this is just example to start scan after disconnect, most likely there is better way to do it in arduino
        }
        else{
          BLEDevice::getScan()->start(5);
        }
      } // End of loop