IOT

A Quick Guide on how to use BLE in ESP32?

Posted by author-avatar
0

In this blog, we will study ESP32’s BLE functionality. Along with Classic Bluetooth, the ESP32 platform also supports Bluetooth low Energy or BLE. The ESP32 BLE is designed for wireless battery-powered, low-power communication between various BLE Devices. In order to use BLE in ESP32 and set it up as both a Server and a Client, we will master all the necessary skills. Additionally, we’ll look at how to link a smartphone to an ESP32 BLE server.

ESP32-BLE-Image-1

BLE (Bluetooth Low Energy)

The incorporation of Bluetooth Low Energy, or simply BLE, was the key component of the Bluetooth 4.0 Specification. A highly optimized version of Classic Bluetooth created exclusively for low-power wireless communication is BLE (formerly branded as Bluetooth Smart).

While the Classic Bluetooth was made to replace cable connectivity with short-range wireless communication, it is sometimes referred to as Basic Rate and Enhanced Dara Rate in technical documentation. Large file transfers, wireless audio, and other uses were taken into consideration when it was designed.

BLE, on the other hand, is created with IoT and battery-operated applications in mind and is intended for low power consumption rather than faster communication speeds. Smartwatches, activity trackers, health monitors, radio beacons, and other gadgets are some of the prominent BLE applications.

BLE-Applications

Unlike Classic Bluetooth, which is always connected, BLE often sleeps and only wakes up when necessary. So, there is extremely low power usage.

Additionally operating on the same 2.4 GHz ISM frequency range is Bluetooth Low Energy. This implies that Wi-Fi and both Bluetooth variants can be used with a single antenna.

Different Layers in BLE

A BLE device consists of three layers:

  • Controller
  • Host
  • Application
BLE-Layers

The controller contains the following:

  • PHY – The Physical Layer
  • LL – The Link Layer
  • HCI – Controller side Host-Controller Interface

The host contains the following:

  • HCI – Host side Host-Controller Interface
  • L2CAP – Logical Link Control and Application Protocol
  • SM – Security Manager
  • ATT – Attribute Protocol
  • GAP – Generic Access Profile
  • GATT – Generic Attribute Profile

The user interface, data handling, and logical components of the application are all contained in the application layer, which is the topmost layer.

Important Terms in BLE

  • GATT: Generic Attribute Profile is abbreviated as GATT. Through the use of Service and Characteristics, it establishes the requirements for data flow between BLE devices.
  • Characteristic: A characteristic is a collection of data termed an attribute, and an attribute is a collection of data that is sent from one device to another. Typically, a characteristic includes the following qualities:
  • Value:  The characteristic’s data value
  • Declaration:  Characteristic properties (location, type like read, write, notify, indicate etc.)
  • Description: ASCII String describing the characteristic.
  • Service:A service is a group of traits. Each Service has a distinct UUID, which might be 16 or 128 bits in length.
  • UUID: Each service and feature in a profile is assigned a 128-bit UUID, or universally unique identifier. To create distinctive IDs, use the website UUIDGenerator. A special 16-bit or 128-bit ID called a UUID is assigned to each service and attribute. An example of a UUID looks like this:
    •  583f8b30-74b4-4757-8143-56048fd88b25 

BLE States

A BLE device can have 5 possible states:

  • Standby
  • Advertising
  • Scanning
  • Initiating
  • Connected
BLE-Device-States

BLE Network Topologies

There are two different types of BLE communication: connection type and broadcast type. The “broadcaster” BLE Device transmits data to any “observer” BLE Device while broadcasting. One-way data flow is what it is.

You require a “Connection” between the BLE Devices in order to communicate in both directions. From peripheral (slave) BLE devices that transmit the packets, a central (master) BLE device repeatedly scans for advertising data packets.

BLE in ESP32

We are aware that Wi-Fi is the ESP32’s primary feature. But in addition, the ESP32 SoC also supports Bluetooth. Dual-mode Bluetooth is used by the ESP32. This indicates that ESP32 is compatible with Bluetooth Classic and Bluetooth Low Energy (BLE).

Particularly, Bluetooth v4.2 Classic Bluetooth (BR/EDR) and BLE protocols are supported by the ESP32 Bluetooth system. We had looked at a few instances of how to use the ESP32 Classic Bluetooth in the previous tutorial. In this lesson, we will investigate ESP32’s BLE capability.

ESP32 BLE Server Client Model

Any BLE device can be set up as either a client or a server. This also applies to ESP32, which can function as a server that announces its presence so that clients can access its data or a client that searches for servers and connects to them in order to get data from them.

Two ESP32 Boards, one configured as a BLE Server and the other as a BLE Slave, will be used in this project.

ESP32 BLE Server

We will first look at setting up an ESP32 as a BLE server. Connect the ESP32 Board to the computer via a USB cable. This board will be referred to as the “ESP32-BLE Server.” Make sure the appropriate ESP32 Development Board and COM port are selected before starting the Arduino IDE.

Code

This is a code snippet from the “BLE server” example. I included comments throughout the code to clarify every step.

This code should be uploaded to the ESP32 server.

  #include <BLEDevice.h>
  #include <BLEUtils.h>
  #include <BLEServer.h>
   
  // 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-ea07361b26a8”
   
  /* BLEServer *pServer = BLEDevice::createServer();
  BLEService *pService = pServer->createService(SERVICE_UUID);
  BLECharacteristic *pCharacteristic = pService->createCharacteristic(
                                          CHARACTERISTIC_UUID,
                                          BLECharacteristic::PROPERTY_READ |
                                          BLECharacteristic::PROPERTY_WRITE
                                        ); */
   
  BLEServer *pServer;
  BLEService *pService;
  BLECharacteristic *pCharacteristic;
   
   
  void setup()
  {
  Serial.begin(115200);
  Serial.println(“Starting BLE Server!”);
   
  BLEDevice::init(“ESP32-BLE-Server”);
  pServer = BLEDevice::createServer();
  pService = pServer->createService(SERVICE_UUID);
  pCharacteristic = pService->createCharacteristic(
                                          CHARACTERISTIC_UUID,
                                          BLECharacteristic::PROPERTY_READ |
                                          BLECharacteristic::PROPERTY_WRITE
                                        );
   
   
  /* BLEServer *pServer = BLEDevice::createServer();
  BLEService *pService = pServer->createService(SERVICE_UUID);
  BLECharacteristic *pCharacteristic = pService->createCharacteristic(
                                          CHARACTERISTIC_UUID,
                                          BLECharacteristic::PROPERTY_READ |
                                          BLECharacteristic::PROPERTY_WRITE
                                        );*/
   
  pCharacteristic->setValue(“Hello, World!”);
  pService->start();
  //BLEAdvertising *pAdvertising = pServer->getAdvertising();
  BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
  pAdvertising->addServiceUUID(SERVICE_UUID);
  pAdvertising->setScanResponse(true);
  pAdvertising->setMinPreferred(0x06);  // functions that help with iPhone connections issue
  pAdvertising->setMinPreferred(0x12);
  BLEDevice::startAdvertising();
  //pAdvertising->start();
  Serial.println(“Characteristic defined! Now you can read it in the Client!”);
  }
   
  void loop()
  {
  std::string value = pCharacteristic->getValue();
  Serial.print(“The new characteristic value is: “);
  Serial.println(value.c_str());
  delay(2000);
  }

ESP32 BLE Client

Select ESP32-BLE Client from another ESP32 Board and attach it to the PC. Choose the COM port for this board in the Arduino IDE.

Code

The ESP32 BLE Library includes an example with the name “BLE client.” Here, I applied the same code (with small modifications). Put this code on the ESP32 client device.

  #include “BLEDevice.h”
   
  /* Specify the Service UUID of Server */
  static BLEUUID serviceUUID(“4fafc201-1fb5-459e-8fcc-c5c9c331914b”);
  /* Specify the Characteristic UUID of Server */
  static BLEUUID    charUUID(“beb5483e-36e1-4688-b7f5-ea07361b26a8”);
   
  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)
  {
    
  }
   
  void onDisconnect(BLEClient* pclient)
  {
    connected = false;
    Serial.println(“onDisconnect”);
  }
  };
   
  /* Start connection to the BLE Server */
  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 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”);
   
    /* 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 */
  /* Initial value is ‘Hello, World!’ */
  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;
   
    }
  }
  };
   
   
  void setup()
  {
  Serial.begin(115200);
  Serial.println(“Starting Arduino BLE Client application…”);
  BLEDevice::init(“ESP32-BLE-Client”);
   
  /* 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.  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()/2000);
    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());
    /* You can see this value updated in the Server’s Characteristic */
  }
  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
  }
   
  delay(2000); /* Delay a second between loops */
  }

Working

You must keep an eye on the serial ports of both ESP32 boards after uploading code to them in order to check how they are communicating. For this, I’m opening the COM port on the ESP32 BLE Client Device using the Arduino IDE’s Serial Monitor and the serial port on the ESP32 BLE Server Device using another programme (like Putty or Terminal).

Reset both boards by pressing the corresponding ENABLE (EN) buttons after accessing the corresponding serial port terminals for the ESP32 BLE Server and Client.

ESP32-BLE-Tutorial-Working

Starting the BLE Server and promoting its services is done by the ESP32 BLE Server device. If you look at the code for the Client ESP32, you’ll see that we utilised the Service UUID and Characteristic UUID of the Server ESP32. This implies that when the Client ESP32 searches for BLE devices, it connects only if it finds a BLE with the specific UUIDs.

The ESP32 BLE Client first reads the characteristic value from the server (which we set to “Hello, World!” in the Server’s code) and prints it on the console after the connection has been made.

Following that, the client tries to change the server’s characteristic value every few seconds. The client’s terminal is seen in the picture below.

In relation to the Server, it reads its own characteristic value every few seconds after launching the BLE Server. The following graphic shows how the client updates the server’s characteristic value as the server reads it.

ESP32-BLE-Server-Terminal

Testing ESP32 BLE Server with SmartPhone

Let’s examine how to link our smartphones to an ESP32 BLE server right away. Open the serial monitor in the Arduino IDE and upload the following code to the ESP32 Board, which we’ll refer to as the ESP32 BLE Server.

  #include <BLEDevice.h>
  #include <BLEUtils.h>
  #include <BLEServer.h>
   
  // 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-ea07361b26a8”
   
   
  class MyCallbacks: public BLECharacteristicCallbacks
  {
  void onWrite(BLECharacteristic *pCharacteristic)
  {
    std::string value = pCharacteristic->getValue();
   
    if (value.length() > 0)
    {
      Serial.println(“*********”);
      Serial.print(“New value: “);
      for (int i = 0; i < value.length(); i++)
      {
        Serial.print(value[i]);
      }
   
      Serial.println();
      Serial.println(“*********”);
    }
  }
  };
   
  void setup()
  {
  Serial.begin(115200);
   
  Serial.println(“1- Download and install an BLE scanner app in your phone”);
  Serial.println(“2- Scan for BLE devices in the app”);
  Serial.println(“3- Connect to ESP32-BLE_Server”);
  Serial.println(“4- Go to CUSTOM CHARACTERISTIC in CUSTOM SERVICE and write something”);
  Serial.println(“5- See the magic =)”);
   
  BLEDevice::init(“ESP32-BLE-Server”);
  BLEServer *pServer = BLEDevice::createServer();
   
  BLEService *pService = pServer->createService(SERVICE_UUID);
   
  BLECharacteristic *pCharacteristic = pService->createCharacteristic(
                                          CHARACTERISTIC_UUID,
                                          BLECharacteristic::PROPERTY_READ |
                                          BLECharacteristic::PROPERTY_WRITE
                                        );
   
  pCharacteristic->setCallbacks(new MyCallbacks());
   
  pCharacteristic->setValue(“Hello World”);
  pService->start();
   
  BLEAdvertising *pAdvertising = pServer->getAdvertising();
  pAdvertising->start();
  }
   
  void loop()
  {
  delay(2000);
  }

Go to the Google Play Store on the smartphone, download the “BLE Scanner” application by Bluepixel Technologies, open it after installation, and enable Bluetooth and Location (both are required for scanning BLE devices) in the phone (the app will prompt the same), and then click the “scan” icon in the top right corner.

You can notice ‘ESP32-BLE-Server’ in the list of BLE Devices that are listed out by the app as it begins to scan for them.

BLE-Scanner-1

Since we have just configured ESP32 with one service, you can see the Service UUID and also the Characteristic UUID under the ‘CUSTOM SERVICE’ section. Once you click ‘CONNECT,’ your smart phone connects to the ESP32 BLE server and displays the list of services and their characteristics.

BLE-Scanner-2

When you tap the ‘R’ icon in the ‘CUSTOM SERVICE’ section, the app reads the value from the server and shows it in the ‘Value’ option, allowing you to view the service’s first characteristic value.

BLE-Scanner-3

Since the characteristic’s settings have been set to allow both reading and writing, setting its value is as simple as pressing on the “W” icon, which causes a text box to appear where the value may be entered, and then clicking “OK” to set the value in the server.

BLE-Scanner-4

Instead of continuously monitoring the ‘value’ field like we did in the previous example, we are actually using the callback feature of the BLE Library, which will be called if and only if a ‘write’ option is initiated. If you open the Serial Monitor of the Server, you can see the server prints out newly set value.

BLE-Scanner-5

Conclusion

I hope all of you understand how to use BLE in ESP32.  We MATHA ELECTRONICS will be back soon with more informative blogs soon.

Newer
A Quick Overview on Embedded System C Programming
Back to list
Older A Basic Introduction to ESP32 Bluetooth

Leave a Reply

Your email address will not be published. Required fields are marked *