Actions
Forum Thread Details
  • State Not Answered
  • Replies 8 replies
  • Subscribers 385 subscribers
  • Views 3954 views
  • Users 0 members are here
Related

Stop connection between BLE Client and Server of custom UUID. And connect client to different server.

KKaushik

I'm working on BLE based on ESP32.

I configured a custom Service and Characteristics with UUID.

Using 2 ESP32 Dev modules. I can connect them together, but the Client module doesn't disconnect and connect to the new UUID.

I need help disconnecting the Client from Server (UUID suppose 001) and connecting it to Server with UUID (let 002).

I couldn't find any function to disconnect clients from servers.

Below code for Client Node 

/**
 * A BLE client example that is rich in capabilities.
 * There is a lot new capabilities implemented.
 * author unknown
 * updated by chegewara
 */

#include "BLEDevice.h"
//#include "BLEScan.h"

// The remote service we wish to connect to.
static BLEUUID serviceUUID("4fafc201-1fb5-459e-8fcc-c5c9c331915b");
// The characteristic of the remote service we are interested in.
static BLEUUID    charUUID("beb5483e-36e1-4688-b7f5-ea07361b215b");

static boolean doConnect = false;
static boolean connected = false;
static boolean doScan = false;
static BLERemoteCharacteristic* pRemoteCharacteristic;
static BLEAdvertisedDevice* myDevice;

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.println((char*)pData);
}

class MyClientCallback : public BLEClientCallbacks {
  void onConnect(BLEClient* pclient) {

    Serial.println("Conecction with server");
  }

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

uint8_t count =0;

bool connectToServer() {
    
    Serial.print("Forming a connection to ");
    Serial.println(myDevice->getAddress().toString().c_str());
    
    BLEClient*  pClient  = BLEDevice::createClient();
    Serial.println(" - Created client");
    
    pClient->setClientCallbacks(new MyClientCallback());
    
    // Connect to the remove 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)

    //
    if(count>5)
    {
      pClient->disconnect();
      static BLEUUID serviceUUID("4fafc201-1fb5-459e-8fcc-c5c9c331914b");
      static BLEUUID    charUUID("beb5483e-36e1-4688-b7f5-ea07361b214b");

      Serial.println("DISCONNECTION \n\n");
      return false;
    }
    
    // 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");

    // Read the value of the characteristic.
    if(pRemoteCharacteristic->canRead()) {
      std::string value = pRemoteCharacteristic->readValue();
      Serial.print("The characteristic value was: ");
      Serial.println(value.c_str());
    }
    
    if(pRemoteCharacteristic->canNotify())
      pRemoteCharacteristic->registerForNotify(notifyCallback);
      
    
    
    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.
    if (advertisedDevice.haveServiceUUID() && advertisedDevice.isAdvertisingService(serviceUUID)) {

      BLEDevice::getScan()->stop();
      myDevice = new BLEAdvertisedDevice(advertisedDevice);
      doConnect = true;
      doScan = true;

    } // Found our server
  } // onResult
}; // MyAdvertisedDeviceCallbacks


void setup() {
  Serial.begin(115200);
  Serial.println("Starting Arduino BLE Client application...");
  BLEDevice::init("");

  // 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);
} // End of setup.


// 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) {
    String newValue = "Time since boot: " + String(millis()/1000);
    Serial.println("Setting new characteristic value to \"" + newValue + "\"");
    
    // Set the characteristic's value to be the array of bytes that is actually a string.
    pRemoteCharacteristic->writeValue(newValue.c_str(), newValue.length());
  }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
  }
  count++;
  delay(1000); // Delay a second between loops.
} // End of loop

After Count reaches to greater than 5, I run below part for 

client->disconnect

 

if(count>5)
    {
      pClient->disconnect();
      static BLEUUID serviceUUID("4fafc201-1fb5-459e-8fcc-c5c9c331914b");
      static BLEUUID    charUUID("beb5483e-36e1-4688-b7f5-ea07361b214b");

      Serial.println("DISCONNECTION \n\n");
      return false;
    }

Below code for Server Node

/*
    Video: https://www.youtube.com/watch?v=oCMOYS71NIU
    Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleNotify.cpp
    Ported to Arduino ESP32 by Evandro Copercini
    updated by chegewara

   Create a BLE server that, once we receive a connection, will send periodic notifications.
   The service advertises itself as: 4fafc201-1fb5-459e-8fcc-c5c9c331914b
   And has a characteristic of: beb5483e-36e1-4688-b7f5-ea07361b26a8

   The design of creating the BLE server is:
   1. Create a BLE Server
   2. Create a BLE Service
   3. Create a BLE Characteristic on the Service
   4. Create a BLE Descriptor on the characteristic
   5. Start the service.
   6. Start advertising.

   A connect hander associated with the server starts a background task that performs notification
   every couple of seconds.
*/
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>

BLEServer* pServer = NULL;
BLECharacteristic* pCharacteristic = NULL;
bool deviceConnected = false;
bool oldDeviceConnected = false;
uint32_t value = 0;

// See the following for generating UUIDs:
// https://www.uuidgenerator.net/

#define SERVICE_UUID        "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b214b"


class MyServerCallbacks: public BLEServerCallbacks {
    void onConnect(BLEServer* pServer) {
      Serial.println("Conecction with client");
      deviceConnected = true;
      BLEDevice::startAdvertising();
    };

    void onDisconnect(BLEServer* pServer) {
      Serial.println("Disconnection with client");
      deviceConnected = false;
    }
};


uint8_t once1 = 0;

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

  // Create the BLE Device
  BLEDevice::init("ESP32");

  // Create the BLE Server
  pServer = BLEDevice::createServer();
  pServer->setCallbacks(new MyServerCallbacks());

  // Create the BLE Service
  BLEService *pService = pServer->createService(SERVICE_UUID);

  // Create a BLE Characteristic
  pCharacteristic = pService->createCharacteristic(
                      CHARACTERISTIC_UUID,
                      BLECharacteristic::PROPERTY_READ   |
                      BLECharacteristic::PROPERTY_WRITE  |
                      BLECharacteristic::PROPERTY_NOTIFY |
                      BLECharacteristic::PROPERTY_INDICATE
                    );

  // https://www.bluetooth.com/specifications/gatt/viewer?attributeXmlFile=org.bluetooth.descriptor.gatt.client_characteristic_configuration.xml
  // Create a BLE Descriptor
  pCharacteristic->addDescriptor(new BLE2902());

  // Start the service
  pService->start();

  // Start advertising
  BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();

  pAdvertising->addServiceUUID(SERVICE_UUID);

  pAdvertising->setScanResponse(false);
  pAdvertising->setMinPreferred(0x0);  // set value to 0x00 to not advertise this parameter
  BLEDevice::startAdvertising();
  Serial.println("Waiting a client connection to notify...");
}

void loop() {
  // notify changed value
  //  if (deviceConnected) {
  //    pCharacteristic->setValue((uint8_t*)&value, 4);
  //    pCharacteristic->notify();
  //  }
  value++;
  delay(2000); // bluetooth stack will go into congestion, if too many packets are sent, in 6 hours test i was able to go as low as 3ms


  // disconnecting
  if (!deviceConnected && oldDeviceConnected) {
    delay(500); // give the bluetooth stack the chance to get things ready
    pServer->startAdvertising(); // restart advertising
    Serial.println("start advertising");
    oldDeviceConnected = deviceConnected;
  }
  // connecting
  if (deviceConnected && !oldDeviceConnected) {
    // do stuff here on connecting
    oldDeviceConnected = deviceConnected;
  }

}

Anyone can guide me how can I achieve this? All I need is resetting way for Service and Characteristics for either client or server node.

  • 0

    Hi,

    Regarding:

    After Count reaches to greater than 5, I run below part for client->disconnect

    Are you saying that the Arduino disconnect method isn't functioning for you? If so, it could be a bug in the Arduino libraries, you should raise it as an issue on the Arduino site or forum.

    I can think of (ugly) workarounds, but getting the library problem raised and fixed should be one of the first things to consider.

    For a workaround, perhaps you could store the state in some non-volatile storage (hopefully there is an Arduino library for that, I have not checked), and then force a reboot of your client, from code.

    Or, if it is possible, re-architect what you're doing, so you don't need to do it (you've not mentioned what your actual requirement is, just that you wish to connect to many servers one at a time).

  • 0 in reply to shabaz

    It's home automation with 5 to 6 numbers of server module (Sensor, displays, servos) with fixed UUIDs, and a Client node in central which connects and disconnect to each of them as per requirement. 

    shabaz said:
    Are you saying that the Arduino disconnect method isn't functioning for you? If so, it could be a bug in the Arduino libraries, you should raise it as an issue on the Arduino site or forum.

    What i understood is Client/server is supposed to revoke "DisconnectCallback' on disconnection. But it doesn't.

    Also When I tried to restart Service with new UUIDs at client node it doesn't connect to new UUID server either.

    That's why I figured its probably doesn't disconnect in the first place, 

  • 0
    KKaushik said:
    I can connect them together, but the Client module doesn't disconnect and connect to the new UUID.

    This is not very helpful. Do you not have any serial output when you test this. What is it telling you.

    For example, in the server code you have this callback function:

    class MyServerCallbacks: public BLEServerCallbacks {
        void onConnect(BLEServer* pServer) {
          Serial.println("Conecction with client");
          deviceConnected = true;
          BLEDevice::startAdvertising();
        };

        void onDisconnect(BLEServer* pServer) {
          Serial.println("Disconnection with client");
          deviceConnected = false;
        }
    };

    So... do you ever get the "Disconnect with client" message...

  • 0 in reply to BigG

    After `count>5`, it stops serial output at the client node but doesn't get anything on the other server side such as a `disconnection with client" message.

  • 0

    I made a global variable

     

    BLEClient*  gpClient;

    ...

    bool connectToServer() {
...
BLEClient* pClient = BLEDevice::createClient();
gpClient = pClient;
...
}

    ...

    void loop() {
...
if (count > 5)
{
gpClient->disconnect();
count = 0;
Serial.println("DISCONNECTION \n\n");
setup();
}
delay(1000); // Delay a second between loops.
}//End of loop

    ...

    It can disconnect now properly, and shows a "Disconnection with client"  message. But now I don't know how to make the client to connect to a new server with a different UUID. Any suggestion?

  • 0 in reply to KKaushik
    KKaushik said:
    But now I don't know how to make the client to connect to a new server with a different UUID. Any suggestion?

    I'd suggest you look at the callback function MyAdvertisedDeviceCallbacks()

    Inside this function it is checks for serviceUUID and whether it is advertising this serviceUUID:


        // We have found a device, let us now see if it contains the service we are looking for.
        if (advertisedDevice.haveServiceUUID() && advertisedDevice.isAdvertisingService(serviceUUID)) {

          BLEDevice::getScan()->stop();
          myDevice = new BLEAdvertisedDevice(advertisedDevice);
          doConnect = true;
          doScan = true;

        } // Found our server

    So how will your code know which server this is. Is it server 1 or server 2.

    Maybe you can use the MAC address from the first connection to rule this one out so that it finds the next one etc.

    You'll have to experiment to determine what works best.

  • 0 in reply to BigG

    I am also working on same project. Can you share the whole code for this?

  • 0 in reply to santhoshi2904

    Hello, the whole code is not for ESP32 as I haven't worked on ESP32. I just took a reference from the ESP32 code and applied it to Adafruit Bluefruit nRF52832. For ESP32 you'll lot of help online.