Bonjour,
J'ai un problème lors de l'envoi de données par Bluetooth Low Energy (BLE) entre deux cartes ESP32. Le souci est que la première carte détecte correctement la deuxième tant qu'elles sont proches l'une de l'autre, mais dès qu'elles s'éloignent d'environ 10 cm, la connexion est perdue.
Quelqu'un aurait-il une idée de ce qui pourrait causer ce problème ou comment y remédier ?
Merci d'avance pour votre aide !
Post mis dans la mauvaise section, on parle anglais dans les forums généraux, je viens de déplacer le post dans la section francophone.
Merci de prendre en compte les recommandations listées dans "Les bonnes pratiques du Forum Francophone".
Bonjour @user65877 , Bienvenue sur le forum Francophone !
De quelles cartes s'agit-il ?
Il y a sur le marché une très grande diversité de cartes dotées d'une puce ESP32
Pour certaines l'antenne WIFi/BLE est de mauvaise qualité, pour d'autres la liaison entrela puce ESP32 et l'antenne n'a pas été réalisée correctement (mauvaise adaptation d'impédance)..... les deux défauts pouvant coexister ce sui réduit fortement la portée en BLE et WiFI
Le module d'Espresif présent sur ces cartes devrait éliminer les défauts évoqués au dessus.
Donner ici les codes utilisés de part et d'autre.
J'ai utilisé plusieurs exemples qui sont disponibles sur les librairies et sur internet voilà un exemple ;
Code serveur :
#include <Arduino.h>
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
#define SERVICE_UUID "0000180D-0000-1000-8000-00805F9B34FB"
#define CHARACTERISTIC_UUID "00002A37-0000-1000-8000-00805F9B34FB"
BLECharacteristic *pCharacteristic;
bool deviceConnected = false;
std::string valueToSend = "Bonjour"; // Message à envoyer
std::string clientMACAddress = "XX:XX:XX:XX:XX:XX"; // Adresse MAC du client
class MyServerCallbacks : public BLEServerCallbacks {
void onConnect(BLEServer *pServer) {
deviceConnected = true;
Serial.println("Client connecté");
}
void onDisconnect(BLEServer *pServer) {
deviceConnected = false;
Serial.println("Client déconnecté");
}
};
void setup() {
Serial.begin(115200);
BLEDevice::init("ESP32_Server");
BLEServer *pServer = BLEDevice::createServer();
pServer->setCallbacks(new MyServerCallbacks());
BLEService *pService = pServer->createService(SERVICE_UUID);
pCharacteristic = pService->createCharacteristic(
CHARACTERISTIC_UUID,
BLECharacteristic::PROPERTY_NOTIFY
);
pCharacteristic->addDescriptor(new BLE2902());
pService->start();
BLEAdvertising *pAdvertising = pServer->getAdvertising();
pAdvertising->start();
Serial.println("Serveur BLE démarré, en attente de connexion...");
}
void loop() {
if (deviceConnected) {
// Envoie du message "Bonjour" si un appareil est connecté
pCharacteristic->setValue(valueToSend);
pCharacteristic->notify();
Serial.println("Message envoyé : Bonjour");
delay(1000); // Envoie toutes les secondes
}
}
Code client :
#include <Arduino.h>
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEScan.h>
#include <BLEAdvertisedDevice.h>
#define SERVICE_UUID "0000180D-0000-1000-8000-00805F9B34FB"
#define CHARACTERISTIC_UUID "00002A37-0000-1000-8000-00805F9B34FB"
bool deviceConnected = false;
BLECharacteristic *pCharacteristic;
std::string receivedMessage = ""; // Variable pour stocker le message reçu
// Adresse MAC du serveur
std::string serverMACAddress = "XX:XX:XX:XX:XX:XX"; // Adresse MAC du serveur
class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
void onResult(BLEAdvertisedDevice advertisedDevice) {
if (advertisedDevice.getAddress().toString() == serverMACAddress) {
Serial.println("Serveur trouvé !");
BLEDevice::getScan()->stop();
advertisedDevice.getScan()->getDevice(advertisedDevice);
}
}
};
void setup() {
Serial.begin(115200);
BLEDevice::init("");
BLEScan* pBLEScan = BLEDevice::getScan();
pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
pBLEScan->setActiveScan(true);
pBLEScan->start(5, false);
// Attente de connexion
Serial.println("Recherche de périphériques BLE...");
}
void loop() {
if (deviceConnected) {
// Affiche le message reçu si connecté
Serial.print("Message reçu: ");
Serial.println(receivedMessage.c_str());
}
delay(1000);
}
// Callback lors de la connexion avec le serveur BLE
class MyClientCallback : public BLEClientCallbacks {
void onConnect(BLEClient* pClient) {
Serial.println("Connecté au serveur !");
}
void onDisconnect(BLEClient* pClient) {
Serial.println("Déconnecté du serveur.");
deviceConnected = false;
}
};
// Fonction pour se connecter au serveur BLE
void connectToServer() {
BLEClient* pClient = BLEDevice::createClient();
pClient->setClientCallbacks(new MyClientCallback());
Serial.println("Connexion au serveur...");
if (pClient->connect(serverMACAddress)) {
Serial.println("Connexion réussie !");
BLERemoteService* pRemoteService = pClient->getService(SERVICE_UUID);
if (pRemoteService != nullptr) {
pCharacteristic = pRemoteService->getCharacteristic(CHARACTERISTIC_UUID);
if (pCharacteristic != nullptr) {
pCharacteristic->registerForNotify(notifyCallback);
}
}
}
}
// Fonction de réception du message
void notifyCallback(BLERemoteCharacteristic* pRemoteCharacteristic, uint8_t* pData, size_t length, bool isNotify) {
receivedMessage = std::string((char*)pData, length);
deviceConnected = true;
}
voir les 'Bonnes Patiques du Form francophone' pour la présentation des codes dans les messages, tels quels ils n'auront pas beaucoup de lecteurs.
This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.
