ESP32 BLE on Arduino IDE with UART Test

Today, in this tutorial we use BLE with UART Test in ESP32 Board. You need to have the ESP32 add-on installed on the Arduino IDE. Follow one of the next tutorials to prepare your Arduino IDE to work with the ESP32, if you haven’t already.

Visit these Articles http://iotbyhvm.ooo/arduino-esp32-support-on-windows-and-ubuntu/  and http://iotbyhvm.ooo/esp32-bluetooth-low-energy-ble-on-arduino-ide/

What is Bluetooth Low Energy?

Bluetooth Low Energy, BLE for short, is a power-conserving variant of Bluetooth. BLE’s primary application is short distance transmission of small amounts of data (low bandwidth). Unlike Bluetooth that is always on, BLE remains in sleep mode constantly except for when a connection is initiated.

This makes it consume very low power. BLE consumes approximately 100x less power than Bluetooth (depending on the use case).

Take a look at the table below that compares BLE and Bluetooth in more detail.

Bluetooth Low Energy (LE) Bluetooth Basic Rate/
Enhanced Data Rate (BR/EDR)
Optimized For… Short burst data transmission Continuous data streaming
Frequency Band 2.4GHz ISM Band (2.402 – 2.480 GHz Utilized) 2.4GHz ISM Band (2.402 – 2.480 GHz Utilized)
Channels 40 channels with 2 MHz spacing
(3 advertising channels/37 data channels)
79 channels with 1 MHz spacing
Channel Usage Frequency-Hopping Spread Spectrum (FHSS) Frequency-Hopping Spread Spectrum (FHSS)
Modulation GFSK GFSK, π/4 DQPSK, 8DPSK
Power Consumption ~0.01x to 0.5x of reference
(depending on use case)
1 (reference value)
Data Rate LE 2M PHY: 2 Mb/s
LE 1M PHY: 1 Mb/s
LE Coded PHY (S=2): 500 Kb/s
LE Coded PHY (S=8): 125 Kb/s
EDR PHY (8DPSK): 3 Mb/s
EDR PHY (π/4 DQPSK): 2 Mb/s
BR PHY (GFSK): 1 Mb/s
Max Tx Power* Class 1: 100 mW (+20 dBm)
Class 1.5: 10 mW (+10 dbm)
Class 2: 2.5 mW (+4 dBm)
Class 3: 1 mW (0 dBm)
Class 1: 100 mW (+20 dBm)
Class 2: 2.5 mW (+4 dBm)
Class 3: 1 mW (0 dBm)
Network Topologies Point-to-Point (including piconet)
Broadcast
Mesh
Point-to-Point (including piconet)

for more information please visit https://www.bluetooth.com/

ESP32 BLE on Arduino IDE with UART Test

Flash this code in ESP32 Board via Ar. If you don’t know please visit links given in first paragraph.

/*
   Create a BLE server that, once we receive a connection, will send periodic notifications.
   The service advertises itself as: 6E400001-B5A3-F393-E0A9-E50E24DCCA9E
   Has a characteristic of: 6E400002-B5A3-F393-E0A9-E50E24DCCA9E - used for receiving data with "WRITE"
   Has a characteristic of: 6E400003-B5A3-F393-E0A9-E50E24DCCA9E - used to send data with  "NOTIFY"

   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.

   In this example rxValue is the data received (only accessible inside that function).
   And txValue is the data to be sent, in this example just a byte incremented every second.
*/

#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>

BLECharacteristic *pCharacteristic;
bool deviceConnected = false;
float txValue = 0;
const int readPin = 32; // Use GPIO number. See ESP32 board pinouts
const int LED = 25; // Could be different depending on the dev board. I used the DOIT ESP32 dev board.

//std::string rxValue; // Could also make this a global var to access it in loop()

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

#define SERVICE_UUID           "6E400001-B5A3-F393-E0A9-E50E24DCCA9E" // UART service UUID
#define CHARACTERISTIC_UUID_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
#define CHARACTERISTIC_UUID_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"

class MyServerCallbacks: public BLEServerCallbacks {
    void onConnect(BLEServer* pServer) {
      deviceConnected = true;
    };

    void onDisconnect(BLEServer* pServer) {
      deviceConnected = false;
    }
};

class MyCallbacks: public BLECharacteristicCallbacks {
    void onWrite(BLECharacteristic *pCharacteristic) {
      std::string rxValue = pCharacteristic->getValue();

      if (rxValue.length() > 0) {
        Serial.println("*********");
        Serial.print("Received Value: ");

        for (int i = 0; i < rxValue.length(); i++) { Serial.print(rxValue[i]); } Serial.println(); // Do stuff based on the command received from the app if (rxValue.find("ON") != -1) { Serial.println("Turning ON!"); digitalWrite(LED, HIGH); } else if (rxValue.find("OFF") != -1) { Serial.println("Turning OFF!"); digitalWrite(LED, LOW); } Serial.println(); Serial.println("*********"); } } }; void setup() { Serial.begin(115200); pinMode(LED, OUTPUT); // Create the BLE Device BLEDevice::init("ESP32 UART Test"); // Give it a name // Create the BLE Server BLEServer *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_TX,
                      BLECharacteristic::PROPERTY_NOTIFY
                    );
                      
  pCharacteristic->addDescriptor(new BLE2902());

  BLECharacteristic *pCharacteristic = pService->createCharacteristic(
                                         CHARACTERISTIC_UUID_RX,
                                         BLECharacteristic::PROPERTY_WRITE
                                       );

  pCharacteristic->setCallbacks(new MyCallbacks());

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

  // Start advertising
  pServer->getAdvertising()->start();
  Serial.println("Waiting a client connection to notify...");
}

void loop() {
  if (deviceConnected) {
    // Fabricate some arbitrary junk for now...
    txValue = analogRead(readPin) / 3.456; // This could be an actual sensor reading!

    // Let's convert the value to a char array:
    char txString[8]; // make sure this is big enuffz
    dtostrf(txValue, 1, 2, txString); // float_val, min_width, digits_after_decimal, char_buffer
    
//    pCharacteristic->setValue(&txValue, 1); // To send the integer value
//    pCharacteristic->setValue("Hello!"); // Sending a test message
    pCharacteristic->setValue(txString);
    
    pCharacteristic->notify(); // Send the value to the app!
    Serial.print("*** Sent Value: ");
    Serial.print(txString);
    Serial.println(" ***");

    // You can add the rxValue checks down here instead
    // if you set "rxValue" as a global var at the top!
    // Note you will have to delete "std::string" declaration
    // of "rxValue" in the callback function.
//    if (rxValue.find("ON") != -1) {
//      Serial.println("Turning ON!");
//      digitalWrite(LED, HIGH);
//    }
//    else if (rxValue.find("OFF") != -1) {
//      Serial.println("Turning OFF!");
//      digitalWrite(LED, LOW);
//    }
  }
  delay(1000);
}




Pin Diagram

Now Connect a LED with ESP 32 Board.

+       ===========> PIN 25

 

 

–        ===========> GND

Now Install BLE Scanner Android App (Link given above) and connect with ESP32 UART Test and click on RX UUID.

Here Type ON for Turn On LED and Type OFF for Turn Off LED.

Remember :

The service advertises itself as: 6E400001-B5A3-F393-E0A9-E50E24DCCA9E

Has a characteristic of: 6E400002-B5A3-F393-E0A9-E50E24DCCA9E – used to send data with  “write”

Has a characteristic of: 6E400003-B5A3-F393-E0A9-E50E24DCCA9E – used for receiving data with “notify”

Download an android appin your mobile BLE Scanner App https://play.google.com/store/apps/details?id=com.macdom.ble.blescanner&hl=en_IN

Or you can use another app nRF Connect for Mobile App

https://play.google.com/store/apps/details?id=no.nordicsemi.android.mcp&hl=en_IN


You may like also:


 

Harshvardhan Mishra

i am an IoT Enthusiast and Part Time Tech Blogger.

2 thoughts on “ESP32 BLE on Arduino IDE with UART Test

Leave a Reply

%d bloggers like this: