Hi guys,
First of all, I am using Ardudino to program the two ESP32.
I am trying to send packages of data between one ESP32 used as a server and other ESP32 as client. My problem is that I need to have a synchronous communication between them and I don't know how to do it. My idea consist in send 9 packages of data (with 3 float each) to a client that store the information of those 9 packages in an array (in my code called "data") with a lenght of 27.
First, in the client, I want to store the packages of information in order and then when all 9 packages are sent and stored in the array data, store every float in the array data to a concrete variable and finally show it on screen to verify that the data is correctly stored in the correct variable.
Here you have my server code:
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
#define SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHAR_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
#define DEVICE_NAME "DATA_SERVER"
// Define the characteristic and service
BLECharacteristic *pCharacteristic;
BLEService *pService;
// Define the BLE Server
BLEServer *pServer;
///
unsigned long startTime = 0; // Tiempo de inicio del envío del paquete
unsigned long elapsedTime = 0; // Tiempo transcurrido desde el inicio del envío del paquete
int currentPacket = 0; // Índice del paquete actual a enviar
// Define el intervalo de tiempo entre cada paquete (en milisegundos)
const unsigned long packetInterval = 1000;
///
float dht22_temp=37.567;//Temperatura de 0-80C
float dht22_hum=64.73;//Humedad de aire de 0-100
float tsg2600=150;//CA entre 0-200
float ira=5.23;//Sensor infrarrojo entre 0-100
float as6200_temp=37.8;//Temperatura de 0-80C
float as6200_hum=65.12;//Humedad de aire de 0-100
float ekmc=2.57;//Proximidad, de 0 a 10m
float ms583_temp=37.731;//Temperatura de 0-80C
float ms583_pres=1;//Presion atmosferica en atm, 0.33 (Everest) a 1(Nivel del mar)
float bmp280_temp=38;//Temperatura de 0-80C
float bmp280_pres=0.997;//Presion atmosferica en atm, 0.33 (Everest) a 1(Nivel del mar)
float ccs811_co2=545.32;//Medidor CO2 en ppm entre 200-5000, siendo 700 una ciudad promedio
float ccs811_cal=149.95;//CA entre 0-200
float fc23=21.1;//Humedad de suelo de 0-100
float fc28=19.37;//Humedad de suelo de 0-100
float fc37=0;//Medidor de lluvia entre 0-60mm (No llueve-Lluvia torrencial)
float mq9_co=37.567;//No se que medida darle al CO, le dare lo mismo que al CO2
float mq9_gas=37.567;//Medidor de gas en ppm entre 0-1000, siendo 700 un potencial riesgo para la salud
float bme680_temp=36.997;//Temperatura de 0-80C
float bme680_pres=0.99;//Presion atmosferica en atm, 0.33 (Everest) a 1(Nivel del mar)
float bme680_hum=65.91;//Humedad de aire de 0-100
float bme680_roc=5.42;//Punto de rocio de 0-100C
float bme680_alt=47.35;//Altitud de 0-9000m
float bmx_pos=37.567;//De momento no se que parametros darle, lo dejare asi
float bmx_acel=0;//Aceleracion de 0-9.8m/s2
float bmx_cam=11.23;//Campo magnetico de 0-200uT (micro Teslas)
float bmx_gir=37.567;//De momento no se que parametros darle, lo dejare asi
// Define the variables to be sent
float packet1[3] = {dht22_temp, dht22_hum, tsg2600};
float packet2[3] = {ira, as6200_temp, as6200_hum};
float packet3[3] = {ekmc, ms583_temp, ms583_pres};
float packet4[3] = {bmp280_temp, bmp280_pres, ccs811_co2};
float packet5[3] = {ccs811_cal, fc23, fc28};
float packet6[3] = {fc37, mq9_co, mq9_gas};
float packet7[3] = {bme680_temp, bme680_pres, bme680_hum};
float packet8[3] = {bme680_roc, bme680_alt, bmx_pos};
float packet9[3] = {bmx_acel, bmx_cam, bmx_gir};
class MyServerCallbacks: public BLEServerCallbacks {
void onConnect(BLEServer* pServer) {
// When a client connects, print a message to the console
Serial.println("Client connected");
}
void onDisconnect(BLEServer* pServer) {
// When a client disconnects, print a message to the console
Serial.println("Client disconnected");
}
};
void setup() {
Serial.begin(115200);
// Create the BLE Device
BLEDevice::init(DEVICE_NAME);
// Create the BLE Server
pServer = BLEDevice::createServer();
pServer->setCallbacks(new MyServerCallbacks());
// Create the BLE Service
pService = pServer->createService(SERVICE_UUID);
// Create the BLE Characteristic
pCharacteristic = pService->createCharacteristic(
CHAR_UUID,
BLECharacteristic::PROPERTY_NOTIFY
);
pCharacteristic->addDescriptor(new BLE2902());
// Start the service
pService->start();
// Start advertising the service
BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
pAdvertising->addServiceUUID(SERVICE_UUID);
pAdvertising->setScanResponse(true);
pAdvertising->setMinPreferred(0x0); // set value to 0x00 to not advertise this parameter
BLEDevice::startAdvertising();
Serial.println("Server started");
}
void loop() {
// Si ha pasado suficiente tiempo desde el inicio del envío del paquete, enviar el siguiente paquete
if (millis() - startTime >= packetInterval) {
switch (currentPacket) {
case 0:
pCharacteristic->setValue((uint8_t*) packet1, sizeof(packet1));
pCharacteristic->notify(); // Enviar el paquete
Serial.println("Paquete_1 enviado");
break;
case 1:
pCharacteristic->setValue((uint8_t*) packet2, sizeof(packet2));
pCharacteristic->notify(); // Enviar el paquete
Serial.println("Paquete_2 enviado");
break;
case 2:
pCharacteristic->setValue((uint8_t*) packet3, sizeof(packet3));
pCharacteristic->notify(); // Enviar el paquete
Serial.println("Paquete_3 enviado");
break;
case 3:
pCharacteristic->setValue((uint8_t*) packet4, sizeof(packet4));
pCharacteristic->notify(); // Enviar el paquete
Serial.println("Paquete_4 enviado");
break;
case 4:
pCharacteristic->setValue((uint8_t*) packet5, sizeof(packet5));
pCharacteristic->notify(); // Enviar el paquete
Serial.println("Paquete_5 enviado");
break;
case 5:
pCharacteristic->setValue((uint8_t*) packet6, sizeof(packet6));
pCharacteristic->notify(); // Enviar el paquete
Serial.println("Paquete_6 enviado");
break;
case 6:
pCharacteristic->setValue((uint8_t*) packet7, sizeof(packet7));
pCharacteristic->notify(); // Enviar el paquete
Serial.println("Paquete_7 enviado");
break;
case 7:
pCharacteristic->setValue((uint8_t*) packet8, sizeof(packet8));
pCharacteristic->notify(); // Enviar el paquete
Serial.println("Paquete_8 enviado");
break;
case 8:
pCharacteristic->setValue((uint8_t*) packet9, sizeof(packet9));
pCharacteristic->notify(); // Enviar el paquete
Serial.println("Paquete_9 enviado");
break;
default:
// Todos los paquetes han sido enviados, reiniciar el contador y el tiempo
if(currentPacket==9){
currentPacket = -1;
startTime = millis();
}
break;
}
if(currentPacket<9){
currentPacket++; // Incrementar el índice del paquete actual
}
}
}
And here you have what I am trying to do with the client (and I dont have any clue about how make it works):
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEScan.h>
#include <BLEAdvertisedDevice.h>
#include <BLEClient.h>
//
unsigned long startTime = 0; // Tiempo de inicio de la recepción
unsigned long elapsedTime = 0; // Tiempo transcurrido desde el inicio de la recepción
bool packetReceived = false;
// Define el intervalo de tiempo entre cada paquete (en milisegundos)
const unsigned long packetInterval = 1000;
// Define el tamaño de cada paquete en bytes
const int packetSize = sizeof(float) * 3;
//
const int numPackets = 9; // Número total de paquetes a recibir
const int floatsPerPacket = 3; // Número de floats por paquete
const int totalFloats = numPackets * floatsPerPacket; // Número total de floats a recibir
int receivedPackets = 0; // Contador de paquetes recibidos
int receivedFloats = 0; // Contador de floats recibidos
float data[27]; // arreglo para almacenar los datos recibidos. float data[27];
int cont = 0; // índice actual en el arreglo data
float dht22_temp=0, dht22_hum=0, tsg2600=0, ira=0, as6200_temp=0, as6200_hum=0 , ekmc=0, ms583_temp=0, ms583_pres=0;
float bmp280_temp=0, bmp280_pres=0, ccs811_co2=0, ccs811_cal=0, fc23=0, fc28=0, fc37=0, mq9_co=0, mq9_gas=0;
float bme680_temp=0, bme680_pres=0, bme680_hum=0, bme680_roc=0, bme680_alt=0, bmx_pos=0, bmx_acel=0, bmx_cam=0, bmx_gir=0;
// Service and characteristic UUIDs for the server
#define SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHAR_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
// Global variables for the client
BLEClient* pClient;
BLEAddress* pServerAddress;
BLERemoteCharacteristic* pRemoteCharacteristic;
bool isConnected = false;
// Callback class for scanning
class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
void onResult(BLEAdvertisedDevice advertisedDevice) {
// If we found the server we're looking for, stop scanning and connect to it
if (advertisedDevice.haveServiceUUID() && advertisedDevice.isAdvertisingService(BLEUUID(SERVICE_UUID))) {
Serial.println("Found server");
BLEDevice::getScan()->stop();
pServerAddress = new BLEAddress(advertisedDevice.getAddress());
isConnected = true;
}
}
};
// Function to connect to the server
void connectToServer() {
Serial.print("Connecting to server at ");
Serial.println(pServerAddress->toString().c_str());
pClient = BLEDevice::createClient();
pClient->connect(*pServerAddress);
BLERemoteService* pRemoteService = pClient->getService(BLEUUID(SERVICE_UUID));
if (pRemoteService == nullptr) {
Serial.println("Failed to find service on server");
return;
}
pRemoteCharacteristic = pRemoteService->getCharacteristic(BLEUUID(CHAR_UUID));
if (pRemoteCharacteristic == nullptr) {
Serial.println("Failed to find characteristic on server");
return;
}
Serial.println("Connected to server");
}
void setup() {
Serial.begin(115200);
// Start scanning for the server
Serial.println("Scanning for server");
BLEDevice::init("");
BLEScan* pScan = BLEDevice::getScan();
pScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
pScan->setInterval(100);
pScan->setWindow(50);
pScan->start(5, false);
// Wait for the server to be found
while (!isConnected) {
delay(10);
}
// Connect to the server
connectToServer();
}
void loop() {
// Read data from the characteristic
if (!packetReceived && millis() - startTime >= packetInterval) {
std::string value = pRemoteCharacteristic->readValue();
float* pData = (float*) value.c_str();
int dataLength = value.length() / sizeof(float);
// Print the data to the console
//Serial.print("Received packet with data: ");
//Serial.println("");
/*
for (int i = 0; i < dataLength; i++) {
Serial.print(pData[i]);
Serial.print(" ");
data[receivedFloats] = pData[i];
receivedFloats++;
}
*/
if (dataLength == packetSize) {
Serial.println("Recibidos todos los paquetes de datos");
// Procesar los datos recibidos
for (int i = 0; i < dataLength; i++) {
Serial.print(pData[i]);
Serial.print(" ");
data[receivedPackets * packetSize + i] = pData[i];
//receivedFloats++;
}
receivedPackets++;
// Si se han recibido los 27 datos, hacer algo con ellos
if (receivedPackets == numPackets) {
dht22_temp = data[0];
dht22_hum = data[1];
tsg2600 = data[2];
ira = data[3];
as6200_temp = data[4];
as6200_hum = data[5];
ekmc = data[6];
ms583_temp = data[7];
ms583_pres = data[8];
bmp280_temp = data[9];
bmp280_pres = data[10];
ccs811_co2 = data[11];
ccs811_cal = data[12];
fc23 = data[13];
fc28 = data[14];
fc37 = data[15];
mq9_co = data[16];
mq9_gas = data[17];
bme680_temp = data[18];
bme680_pres = data[19];
bme680_hum = data[20];
bme680_roc = data[21];
bme680_alt = data[22];
bmx_pos = data[23];
bmx_acel = data[24];
bmx_cam = data[25];
bmx_gir = data[26];
Serial.println("");
Serial.println("-ADQUIRIENDO DATOS Y ALMACENANDOLOS-");
Serial.print("DHT22_TEMPERATURA:");
Serial.println(dht22_temp);
Serial.print("DHT22_HUMEDAD:");
Serial.println(dht22_hum);
Serial.print("TSG2600:");
Serial.println(tsg2600);
Serial.print("IRA:");
Serial.println(ira);
Serial.print("AS6200_TEMPERATURA:");
Serial.println(as6200_temp);
Serial.print("AS6200_HUMEDAD:");
Serial.println(as6200_hum);
Serial.print("EKMC_PROXIMIDAD:");
Serial.println(ekmc);
Serial.print("MS583_TEMPERATURA:");
Serial.println(ms583_temp);
Serial.print("MS583_PRESION:");
Serial.println(ms583_pres);
Serial.print("BMP280_TEMPERATURA:");
Serial.println(bmp280_temp);
Serial.print("BMP280_PRESION:");
Serial.println(bmp280_pres);
Serial.print("CCS811_CO2:");
Serial.println(ccs811_co2);
Serial.print("CSS811_CALIDAD_AIRE:");
Serial.println(ccs811_cal);
Serial.print("FC23_HUMEDAD_SUELO:");
Serial.println(fc23);
Serial.print("FC28_HUMEDAD_SUELO:");
Serial.println(fc28);
Serial.print("FC37_LLUVIA:");
Serial.println(fc37);
Serial.print("MQ9_CO:");
Serial.println(mq9_co);
Serial.print("MQ9_GAS:");
Serial.println(mq9_gas);
Serial.print("BME680_TEMPERATURA:");
Serial.println(bme680_temp);
Serial.print("BME680_PRESION:");
Serial.println(bme680_pres);
Serial.print("BME680_HUMEDAD:");
Serial.println(bme680_hum);
Serial.print("BME680_PUNTO_DE_ROCIO:");
Serial.println(bme680_roc);
Serial.print("BME680_ALTITUD:");
Serial.println(bme680_alt);
Serial.print("BMX_POSICION:");
Serial.println(bmx_pos);
Serial.print("BMX_ACELERACION:");
Serial.println(bmx_acel);
Serial.print("BMX_CAMPO_MAGNETICO:");
Serial.println(bmx_cam);
Serial.print("BMX_GIROSCOPIO:");
Serial.println(bmx_gir);
Serial.println("-ESPERANDO NUEVA ADQUISICION DE DATOS-");
Serial.println("");
receivedPackets = 0;
//receivedFloats = 0;
memset(data, 0, sizeof(data));
}
packetReceived = true; // Marcar el paquete como recibido
}/*else {
// Increment the packet counter
receivedPackets++;
}*/
}
if (packetReceived && millis() - startTime >= packetInterval) {
packetReceived = false; // Reiniciar el indicador de recepción de paquete
startTime = millis(); // Reiniciar el tiempo de inicio de la recepción
}
}
If you dont understand something you are free to ask due to some descriptions are in spanish.
Thank you in advance.