B4R Question BLE Chat with ESP32

Humberto

Active Member
Licensed User
I wrote an application as a chat using BLE between Android and ESP32. ( using same sample code )

The Android apk find the ESP32 than connect and receive a "Wellcome" text.

Then everthing that you write and send to ESP 32 comes back.

I´d like to write the ESP32 application in B4R.

Someone can help translate it?



B4X:
/*
    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

   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>

BLEServer *pServer = NULL;
BLECharacteristic * pTxCharacteristic;
bool deviceConnected = false;
bool oldDeviceConnected = false;
uint8_t txValue = 0;
bool flag_wait_resp = true;


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

#define SERVICE_UUID           "00000001-B5A3-F393-E0A9-E50E24DCCA9E" // UART service UUID
#define CHARACTERISTIC_UUID_RX "00001002-B5A3-F393-E0A9-E50E24DCCA9E"
#define CHARACTERISTIC_UUID_TX "00001003-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 == "OK:" ){
        flag_wait_resp = false;
        // acknologe receiving infromation
      }
      if ( rxValue != "OK:" ){
        // echo the text received
        pTxCharacteristic->setValue(rxValue);
        pTxCharacteristic->notify();
      }
      if (rxValue.length() > 0) {
        Serial.println("*********");
        Serial.print("Received Value: ");
        for (int i = 0; i < rxValue.length(); i++){
          Serial.print(rxValue[i]);
          
        } 

        Serial.println();
        Serial.println("*********");
      }
    }
};

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

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

  // 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
  pTxCharacteristic = pService->createCharacteristic(
                                        CHARACTERISTIC_UUID_TX,
                                        BLECharacteristic::PROPERTY_NOTIFY
                                    );
                      
  pTxCharacteristic->addDescriptor(new BLE2902());

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

  pRxCharacteristic->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 && flag_wait_resp ) {
//        pTxCharacteristic->setValue(&txValue, 1);
        pTxCharacteristic->setValue("Wellcome");
        pTxCharacteristic->notify();
//        txValue++;
            delay(1000); // send until acknologe from cellphone
    }

    // 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;
    }
}
 

Attachments

  • ble_chat.zip
    11.5 KB · Views: 133

Humberto

Active Member
Licensed User
This example for B4a and B4i communicate with an HM-10 interface.

My problem is how to setup the ESP32 to receive and transmit information.

My code in arduino SDK setup an ESP32 to act like a HM-10 interface.

I could not find the commands to do with the ESP32SimpleBLE library to do it.
 
Upvote 0

Humberto

Active Member
Licensed User
To be compatible with IOS

The project is an alarm button and I need communication to setup the button with information
 
Upvote 0

Humberto

Active Member
Licensed User
There is a way to execute the software in the first post so I can use the other routines in B4R to setup the button ?
 
Upvote 0

Humberto

Active Member
Licensed User
I developed already the button software using B4R and ESP8266 to work with Wifi, now I´m using the ESP32 to do the same job with Wifi and I´m implementing the BLE ( To be compatible with IOS too ) version too.

If I have to use the Arduino SDK I´ll need to develop the Wifi solution again there.

But thank you anyway
 
Upvote 0

Humberto

Active Member
Licensed User
Done

The project configurate the ESP32 to transmit and receive information using BLE ( to be compatible with IOS ).

The bytes to transmit and receive is in a global variable.

The setup of ESP32 is done with inline routines

The android example connect when recognize a BLE that contains "B4X" in the name transmiting any information then after connect send "OK:" to acknolege and the ESP32 stop advertising and start to wait message from Android.
 

Attachments

  • Ble_Inline.zip
    2.4 KB · Views: 194
  • ble_chat.zip
    11.5 KB · Views: 198
Upvote 0
Top