How to send via bleak to ESP32 via BLE? Sketch does not work!

[ImmanuelT8]

Hello,

I manage to read using Notify and Bleak, but I just can't successfully send it to my ESP via BLE via Bleak. Tried this in a very simple example, here an INT of 5 should be sent to my BLE and when the variable is set to 5 then the internal LED should go on and the variable should be sent back to my Python console, but I get always 0 on my console and the LED does not come on. Here are the examples:

Small Test Python: https://pastebin.com/UikEpPZw
Small Test ESP: https://pastebin.com/5Az1u6Ys

That would be my real program, here I want to change several values on the sensor, although I'm not sure about the data type, it's text with numbers:

Normal Test Python: https://pastebin.com/YesUKnEC
Normal Test ESP: https://pastebin.com/40Uf9ayK

Haven't gotten it to work for 2 days, I would be grateful for any tip!

[dlech]

The pastbin links aren't working for me. Could you just paste the code here as a comment? Like this:

```python
# code goes here
```

[ImmanuelT8]

Sure, this is the first small example:

import asyncio
import bleak
import struct
 
# MAC address of the ESP32
mac_address = 'CC:50:E3:9C:15:02'  # Replace with the MAC address of your ESP32
 
 
UUID3 = "0000fff0-0000-1000-8000-00805f9b34fb"
 
async def run():
    # Connect to the ESP32 device
    async with bleak.BleakClient(mac_address) as client:
        # Send parameter to ESP32
 
        parameter = 5
        int_parameter = int(parameter)
        await client.write_gatt_char(UUID3, int_parameter.to_bytes(4, byteorder='little'))
 
 
        # Receive data from ESP32 via   BLE
 
 
        while True:
            data = await client.read_gatt_char(UUID3)
            if data:
                value = int.from_bytes(data, byteorder='little')  # Convert bytes to integer
                print(f"Received data: {value}")
 
 
asyncio.run(run())

#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
int LED_BUILTIN = 2;
 
BLECharacteristic *pCharacteristic;
bool deviceConnected = false;
int Parameter[1]; // Array für die empfangenen Daten
int parameter_int; // Variable für den empfangenen Integer-Wert
int parameter;
 
class MyServerCallbacks : public BLEServerCallbacks {
    void onConnect(BLEServer* pServer) {
      deviceConnected = true;
    };
 
    void onDisconnect(BLEServer* pServer) {
      deviceConnected = false;
    }
};
 
void setup() {
  Serial.begin(115200);
 
  BLEDevice::init("MyESP32");
  BLEServer *pServer = BLEDevice::createServer();
  pServer->setCallbacks(new MyServerCallbacks());
  BLEService *pService = pServer->createService(BLEUUID("0000fff0-0000-1000-8000-00805f9b34fb"));
 
  pCharacteristic = pService->createCharacteristic(
                      BLEUUID("0000fff0-0000-1000-8000-00805f9b34fb"),
                      BLECharacteristic::PROPERTY_READ |
                      BLECharacteristic::PROPERTY_WRITE |
                      BLECharacteristic::PROPERTY_NOTIFY
                    );
  pCharacteristic->addDescriptor(new BLE2902());
 
  pService->start();
 
  BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
  pAdvertising->addServiceUUID(BLEUUID("0000fff0-0000-1000-8000-00805f9b34fb"));
  pAdvertising->setScanResponse(false);
  pAdvertising->setMinPreferred(0x06);  // 10ms
  pAdvertising->setMinPreferred(0x12);  // 20ms
  BLEDevice::startAdvertising();
 
}
 
void loop() {
  parameter_int = (int)Parameter[0];
  Serial.println(parameter_int);
  
  if (deviceConnected) {
    if (parameter_int == 5) {
      digitalWrite(LED_BUILTIN, HIGH);
    } else {
      digitalWrite(LED_BUILTIN, LOW);
    }
    pCharacteristic->setValue(parameter_int);
    pCharacteristic->notify();
  }
  delay(2000);
}

The second

import tkinter as tk
import tkinter.ttk as ttk
import bleak
import asyncio
from bleak import BleakClient
 
address = 'CC:50:E3:9C:15:02'
UUID3 = "beb5483e-36e1-4688-b7f5-ea07361b26a7"
 
 
 
async def handle_uuid3_notify(sender, data):
    value = int.from_bytes(data, byteorder='little')
    print(f"Neuer Wert empfangen: {value}")
 
async def send_data():
    # Extrahiere Eingabewerte
    led_brightness = int(e1.get())
    sample_average = int(e2.get())
    led_mode = int(e3.get())
    sample_rate = int(e4.get())
    pulse_width = int(e5.get())
    adc_range = int(e6.get())
 
    # Erstelle Datenpaket
    data_packet = bytearray([led_brightness, sample_average, led_mode, sample_rate, pulse_width, adc_range])
 
    # Sende Daten über BLE
    async with BleakClient(address) as client:
        await client.write_gatt_char(UUID3, data_packet)
 
 
senden = send_data()
 
 
async def read_data():
    async with BleakClient(address) as client:
        await client.start_notify(UUID3, handle_uuid3_notify)
        while True:
            await asyncio.sleep(1)
 
 
 
 
async def main():
    loop = asyncio.get_running_loop()
    loop.create_task(send_data())
    loop.create_task(read_data())
    await asyncio.sleep(0)
 
root = tk.Tk()
root.geometry('400x400')
root.title("ESP32 Einstellungen")
 
# Erstelle Label und Eingabefelder
tk.Label(root, text="ledBrightness").grid(row=0)
tk.Label(root, text="sampleAverage").grid(row=1)
tk.Label(root, text="ledMode").grid(row=2)
tk.Label(root, text="sampleRate").grid(row=3)
tk.Label(root, text="pulseWidth").grid(row=4)
tk.Label(root, text="adcRange").grid(row=5)
 
e1 = ttk.Entry(root)
e2 = ttk.Entry(root)
e3 = ttk.Entry(root)
e4 = ttk.Entry(root)
e5 = ttk.Entry(root)
e6 = ttk.Entry(root)
 
e1.grid(row=0, column=1, padx=3, pady=3)
e2.grid(row=1, column=1, padx=3, pady=3)
e3.grid(row=2, column=1, padx=3, pady=3)
e4.grid(row=3, column=1, padx=3, pady=3)
e5.grid(row=4, column=1, padx=3, pady=3)
e6.grid(row=5, column=1, padx=3, pady=3)
 
 
# Erstelle Button zum Verbinden mit dem ESP
#connect_button = ttk.Button(root, text="Mit ESP verbinden", command=connect_to_esp)
 
 
#connect_button.grid(row=6, column=0, columnspan=2, pady=10)
#command=lambda: asyncio.create_task(connect_to_esp())
 
async def main(address):
    async with BleakClient(address) as client:
        model_number = await client.read_gatt_char(UUID3)
        print("Verbunden")
 
 
# Erstelle Button zum Senden der Daten
send_button = ttk.Button(root, text="Senden", command=senden)
send_button.grid(row=7, column=0, columnspan=2, pady=5)
 
 
asyncio.run(main(address))
 
root.mainloop()

and

#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
 
#include <DFRobot_MAX30102.h>
DFRobot_MAX30102 particleSensor;
 
int Wert;
 
// Datenarray zum Senden von Daten über das BLE-Charakteristikum
int data[100] = {0};  // 100 Integer-Werte, initialisiert mit 0
int dataIR[100] = {0};  // 100 Integer-Werte, initialisiert mit 0
 
uint32_t ledBrightness = 50;
uint8_t sampleAverage = SAMPLEAVG_4;
uint8_t ledMode = MODE_MULTILED;
int16_t sampleRate = SAMPLERATE_100;
uint16_t pulseWidth = PULSEWIDTH_411;
uint16_t adcRange = ADCRANGE_16384;
 
BLEServer* pServer = NULL;
BLECharacteristic* pCharacteristic = NULL;
BLECharacteristic* pCharacteristic2 = NULL;
BLECharacteristic* pCharacteristic3 = NULL;
 
bool deviceConnected = false;
bool oldDeviceConnected = false;
bool updateSensor = false;
uint32_t value;
 
 
 
// 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"
#define CHARACTERISTIC_UUID2 "beb5483e-36e1-4688-b7f5-ea07361b26a9"
#define CHARACTERISTIC_UUID3 "beb5483e-36e1-4688-b7f5-ea07361b26a7"
 
 
 
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 value = pCharacteristic->getValue();
        if (value.length() == 6) {
            ledBrightness = value[0];
            sampleAverage = value[1];
            ledMode = value[2];
            sampleRate = value[3];
            pulseWidth = value[4];
            adcRange = value[5];
            updateSensorConfig();
            Serial.println("Parameter upgedatet");
            Serial.print(", ");
            Serial.println("ledBrightness = " + String(ledBrightness));
            Serial.print(", ");
            Serial.println("sampleAverage = " + String(sampleAverage));
            Serial.print(", ");
            Serial.println("ledMode = " + String(ledMode));
            Serial.print(", ");
            Serial.println("pulseWidth = " + String(pulseWidth));
            Serial.print(", ");
            Serial.println("adcRange = " + String(adcRange));
            Serial.print(", ");
 
        }
    }
};
 
 
 
 
 
 
void updateSensorConfig() {
  // Sensor konfigurieren
  particleSensor.sensorConfiguration(ledBrightness, sampleAverage, ledMode, sampleRate, pulseWidth, adcRange);
  Serial.println("Sensor configuration updated");
}
 
 
void setup() {
  Serial.begin(115200);
 
  // Sensor initialisieren
  while (!particleSensor.begin()) {
    Serial.println("MAX30102 was not found");
    delay(1000);
  }
 
  // Sensor konfigurieren
  particleSensor.sensorConfiguration(/*ledBrightness=*/50, /*sampleAverage=*/SAMPLEAVG_4, \
      /*ledMode=*/MODE_MULTILED, /*sampleRate=*/SAMPLERATE_100, \
      /*pulseWidth=*/PULSEWIDTH_411, /*adcRange=*/ADCRANGE_16384);
 
  // Create the BLE Device
  BLEDevice::init("ESP_SPO2");
 
  // 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
                    );
  
  pCharacteristic2 = pService->createCharacteristic(
                      CHARACTERISTIC_UUID2,
                      BLECharacteristic::PROPERTY_READ   |
                      BLECharacteristic::PROPERTY_WRITE  |
                      BLECharacteristic::PROPERTY_NOTIFY |
                      BLECharacteristic::PROPERTY_INDICATE
                    );
 
  pCharacteristic3 = pService->createCharacteristic(
                      CHARACTERISTIC_UUID3 ,
                      BLECharacteristic::PROPERTY_READ   |
                      BLECharacteristic::PROPERTY_WRITE  |
                      BLECharacteristic::PROPERTY_NOTIFY |
                      BLECharacteristic::PROPERTY_INDICATE
                    );
 
 
  pCharacteristic3->setCallbacks(new MyCallbacks()); // Call backs sind Funktionen die Aufgerufen werden bei verschiedenen Ereignissen die in Zusammenhang mit einer UUID auftreten. 
  // Hier wird ein Objekt für Charakteristik 3 erzeugt 
 
  
 
 
 
  // https://www.bluetooth.com/specifications/gatt/viewer?attributeXmlFile=org.bluetooth.descriptor.gatt.client_characteristic_configuration.xml
  // Create a BLE Descriptor
  pCharacteristic->addDescriptor(new BLE2902());
  pCharacteristic2->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...");
}
 
 
int32_t SPO2; //SPO2
int8_t SPO2Valid; //Flag to display if SPO2 calculation is valid
int32_t heartRate; //Heart-rate
int8_t heartRateValid; //Flag to display if heart-rate calculation is valid
int red;
int IR;
 
 
void loop() {
 
 
 
  // Zuerst Daten im Array sammeln
 
  // Sammle Daten, Verschiebe alle Elemente im Array um eins nach rechts
 
 
  if (Wert <= 99) {
 
    Serial.println(Wert);
 
    // Füge den neuen Wert am Index 0 hinzu
    data[Wert] = particleSensor.getRed();
    dataIR[Wert] = particleSensor.getIR();
 
    Wert = Wert + 1;
 
  }
 
  else {
 
    // Reset meines Parameters Wert
    Wert = 0;
 
    // Array voll
    Serial.println("100 Werte im Array gesammelt");
 
    Serial.println("Bin in vor Schleife Gerät Verbunden");
 
    // Ausgabe der gesammelten Daten
    Serial.println(); // Neue Zeile am Ende der Ausgabe
 
    Serial.print("ESP verbunden, sende Daten");
 
    Serial.println(); // Neue Zeile am Ende der Ausgabe
    pCharacteristic->setValue((uint8_t*)data, sizeof(data));
    pCharacteristic2->setValue((uint8_t*)dataIR, sizeof(dataIR));
 
 
    pCharacteristic->notify();
    pCharacteristic2->notify();
    Serial.println("Verbunden im Loop");
 
    //  memset(data, 0, sizeof(data));
 
    // Zurücksetzen der Variablen für die nächste Datensammlung
 
    if (!deviceConnected) {
 
      // Serial Print das Array wenn nicht verbunden
 
      Serial.println("ESP nicht verbunden. Daten: ");
 
      for (int i = 0; i < 100; i++) { // Durchlaufen des Arrays
        Serial.print(data[i]); // Ausgabe des aktuellen Elements
        Serial.print(" "); // Trennzeichen zwischen den Elementen
        Serial.println(); // Neue Zeile am Ende der Ausgabe
 
      }
    }
 
  }
 
 
  if (!deviceConnected) {
 
    if (Wert >= 99)
 
    {
 
      // Reset meines Parameters Wert
      Wert = 0;
 
      // Wenn nicht verbunden BLE bewerben
 
      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;
      }
    }
  }
 
    if (updateSensor) {
    updateSensorConfig();
    updateSensor = false;
  }
}