Je ne vois pas de valeurs exploitables, il faut essayer de parcourir les services et caractéristiques, de s’abonner, cliquer sur lire et regarder si des valeurs apparaissent.
Est ce que l’un d’entre vous à demander le protocole Ble au fabricant?
J’ai acheté un sniffeur ble et j’arrive à observer les données en advertising, elles sont pour l’impossible à comprendre. Je vais analyser le code de l’appli android. Pour le constructeur j’ai envoyé un mail et ils m’ont gentiment envoyer me faire f#####.
Dommage que l’interoperabilitée ne soit pas une consideration pour certaines sociétés.
As tu essayer de donner les data a chatGPT avec ce que tu vois sur l’appareil. Il trouvera peut être le pattern
Les données que j’arrive à obtenir ont le format ADV_IND, qui est de l’advertising et ne semble pas contenir de data sur la température etc
Quand je me connecte avec mon téléphone je n’arrive plus à intercepter les communications entre les deux… et je pense que c’est celles-ci qui contiennent les précieuses données
Update de la situation:
Etape 1 : Récupération des logs ATT
N’ayant pas réussi à récupérer les logs ATT depuis le Sniffer Bluetooth, je me suis procuré un smartphone sous android capable de récupérer ce type de log. J’ai depuis l’application android envoyé une nouvelle consigne de pH ainsi que de production (tout en enregistrant les logs).
Etape 2 : Analyse des logs avec Wireshark:
Sur la première image, c’est le début des logs sous le protocole ATT, je ne comprend pas tout ici…
Sur la deuxième image c’est le premier log avec une valeur
En copiant cette valeur et en la comparant à celle d’un autre premier log d’un autre relevé avec différentes valeurs de pH et de température j’en ai déduis cela :
Etape 3: Codage de l’ESP32
C’est pour cette étape que je suis le moins confiant… Je souhaite coder l’esp32 de telle sorte qu’il se connecte à l’électrolyseur, et qu’il récupère la valeur de ce premier log. Ensuite il pourrait la convertir puis la transmettre à HA par mqtt. Pensez vous cela possible et avez vous des conseils ??
Est ce que tu as identifier le couple service/caractéristique qui permet d’avoir cette valeur ?
OMG permet de récupérer des valeurs à partir de ce couple:
Oui j’ai le couple Service/Caractéristique, je vais regarder ce doc MQTT. J’envoie dans la soirée le code que j’ai commencé à préparer.
#include <Arduino.h>
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>
#include <BLE2902.h>
#include <PubSubClient.h>
#include <WiFi.h>
// Définissez les informations de votre réseau WiFi
const char* ssid = "NomDeVotreReseau";
const char* password = "MotDePasseDeVotreReseau";
// Définissez les informations de votre broker MQTT
const char* mqtt_server = "AdresseIPDuBrokerMQTT";
const int mqtt_port = 1883;
const char* mqtt_user = "NomUtilisateurMQTT";
const char* mqtt_password = "MotDePasseMQTT";
const char* mqtt_topic_pH = "topic/ph"; // Topic MQTT pour le pH
const char* mqtt_topic_temperature = "topic/temperature"; // Topic MQTT pour la température
const char* mqtt_topic_production = "topic/production"; // Topic MQTT pour le taux de production
const char* mqtt_topic_salt = "topic/salt"; // Topic MQTT pour le taux de sel
// UUID de la caractéristique Bluetooth que vous souhaitez lire
const char* characteristicUUID = "ef785c2422bb463db6510b7445ba091c";
BLEClient* pClient;
WiFiClient wifiClient;
PubSubClient client(wifiClient);
bool isProcessing = false;
void setup() {
Serial.begin(115200);
BLEDevice::init("ESP32");
// Connexion au réseau WiFi
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.println("Connecting to WiFi...");
}
Serial.println("Connected to WiFi");
// Connexion au broker MQTT
client.setServer(mqtt_server, mqtt_port);
client.setCallback(callback);
while (!client.connected()) {
if (client.connect("ESP32", mqtt_user, mqtt_password)) {
Serial.println("Connected to MQTT");
} else {
Serial.println("MQTT connection failed, retrying...");
delay(5000);
}
}
// Connexion au périphérique BLE
pClient = BLEDevice::createClient();
BLEScan* pBLEScan = pClient->getScan();
pBLEScan->setActiveScan(true);
BLEAdvertisedDevice advertisedDevice;
while (true) {
if (!isProcessing) {
BLEScanResults foundDevices = pBLEScan->start(1);
for (int i = 0; i < foundDevices.getCount(); i++) {
advertisedDevice = foundDevices.getDevice(i);
if (advertisedDevice.haveServiceUUID() && advertisedDevice.getServiceUUID().equals(BLEUUID("099127567b324629aeb1b309d9a338ae"))) {
pClient->connect(advertisedDevice);
delay(1000);
// Lire la caractéristique
BLERemoteService* pRemoteService = pClient->getService(BLEUUID("099127567b324629aeb1b309d9a338ae"));
BLERemoteCharacteristic* pRemoteCharacteristic = pRemoteService->getCharacteristic(BLEUUID(characteristicUUID));
std::string value = pRemoteCharacteristic->readValue();
const char* hexValue = value.c_str();
// Convertir les valeurs et les envoyer à Home Assistant via MQTT
// Convertir le 6ème couple en décimal (pH)
const char* hexpH = hexValue + 4 * 2; // 4ème couple de valeur (0x0000 à 0x0001)
uint16_t pHValue = convertHexToDecimal(hexpH);
float pH = pHValue / 10.0;
// Envoyer la valeur du pH à Home Assistant via MQTT
char pHPayload[10];
sprintf(pHPayload, "%.1f", pH);
client.publish(mqtt_topic_pH, pHPayload);
// Convertir le 20ème couple en décimal (température)
const char* hexTemperature = hexValue + 18 * 2; // 18ème couple de valeur (0x0000 à 0x0001)
uint16_t temperatureValue = convertHexToDecimal(hexTemperature);
float temperature = temperatureValue / 10.0;
// Envoyer la valeur de la température à Home Assistant via MQTT
char temperaturePayload[10];
sprintf(temperaturePayload, "%.1f", temperature);
client.publish(mqtt_topic_temperature, temperaturePayload);
// Convertir le 23ème couple en décimal et diviser par 10 pour le taux de sel en g/L
const char* hexSalt = hexValue + 22 * 2; // 22ème couple de valeur (0x0000 à 0x0001)
uint16_t saltValue = convertHexToDecimal(hexSalt);
float saltValue_g_per_l = saltValue / 10.0;
// Envoyer la valeur du taux de sel à Home Assistant via MQTT
char saltPayload[10];
sprintf(saltPayload, "%.1f", saltValue_g_per_l);
client.publish(mqtt_topic_salt, saltPayload);
// Récupérer le 67ème couple de valeur (taux de production en %)
const char* hexProduction = hexValue + 66 * 2; // 66ème couple de valeur (0x0000 à 0x0001)
uint16_t productionValue = convertHexToDecimal(hexProduction);
// Envoyer la valeur du taux de production à Home Assistant via MQTT
char productionPayload[10];
sprintf(productionPayload, "%d", productionValue);
client.publish(mqtt_topic_production, productionPayload);
// Déconnexion du périphérique BLE
pClient->disconnect();
// Marquer le traitement comme terminé
isProcessing = true;
break;
}
}
}
// Attendre 5 minutes avant de reprendre
delay(300000);
isProcessing = false; // Réinitialiser le traitement pour le prochain cycle
}
}
void loop() {
// Ne rien faire dans la boucle principale
}
void callback(char* topic, byte* payload, unsigned int length) {
// Fonction de rappel MQTT (si nécessaire)
}
uint16_t convertHexToDecimal(const char* hexValue) {
uint16_t result = 0;
sscanf(hexValue, "%x", &result);
return result;
}
Ça avance on dirait. Merci d’avance
Oui un peu 
, faut que j’essaie de coder l’esp32 par esphome ça sera peut être plus simple pour renvoyer les données à HA…
Le problème c’est pour le couple service/caractéristique j’ai plusieurs trames avec différentes valeurs et je ne vais qu’une trame dont le début de la valeur commence par une certaine séquence. Je ne sais pas si c’est possible avec une seule commande…
ça peut t’intéresser:
1 « J'aime »
Bonjour
je viens de découvrir le topic
je préviens, je n’y connais pas grand chose, mais je suis volontaire !
effectivement , de passer par un ESP me semble pratique, car mon pool-house est loin de mon HA, mais a le wifi
Quel modèle ESP prendre ?
je vais installer nrf et je pourrais faire des tests dés demain
bonjour
simple question de débutant
n’est t’il pas plus pertinent de monter un Bluetooth Proxy dans le local technique
et de faire une intégration dans HA ?
Bonjour,
La difficulté ici est le protocole de communication utilisé par l’appareil et sa compréhension.
Ensuite l’implémentation peut être réalisée à différents endroits ESP ou serveur suivant l’architecture choisie.
Bonjours,
Je ne sais pas ou vous en êtes , du coup j’ai essayé de commencer avec ESPHome.
Je suis partie avec les dogmes suivants :
- le code précédemment posté est juste
- on possède @Mac du device
- ce qui m’intéresse dans un premier temps :
– détection du Justsalt ,si on ou off
– remonté des sondes (pas besoin de l’historique HA le ferra)
esphome:
name: justsalt
friendly_name: justsalt
esp32:
board: esp32dev
framework:
type: arduino
# Enable logging
logger:
# Enable Home Assistant API
api:
encryption:
key: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
ota:
password: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
wifi:
ssid: !secret wifi_ssid
password: !secret wifi_password
# Enable fallback hotspot (captive portal) in case wifi connection fails
ap:
ssid: "Justsalt Fallback Hotspot"
password: "ccccccccccccccc"
captive_portal:
#sensor:
# - platform: template
# name: "BLE Sensor"
# id: ble_sensor
esp32_ble_tracker:
on_ble_advertise:
- mac_address:
- AA:BB:CC:DD:EE:FF
then:
- lambda: |-
ESP_LOGD("ble_adv", "New BLE device");
ESP_LOGD("ble_adv", " address: %s", x.address_str().c_str());
ESP_LOGD("ble_adv", " name: %s", x.get_name().c_str());
ESP_LOGD("ble_adv", " X: %s", x);
ESP_LOGD("ble_adv", " Advertised service UUIDs:");
for (auto uuid : x.get_service_uuids()) {
ESP_LOGD("ble_adv", " - %s", uuid.to_string().c_str());
}
ESP_LOGD("ble_adv", " Advertised service data:");
for (auto data : x.get_service_datas()) {
ESP_LOGD("ble_adv", " - %s: (length %i)", data.uuid.to_string().c_str(), data.data.size());
}
ESP_LOGD("ble_adv", " Advertised manufacturer data:");
for (auto data : x.get_manufacturer_datas()) {
ESP_LOGD("ble_adv", " - %s: (length %i)", data.uuid.to_string().c_str(), data.data.size());
}
ble_client:
- mac_address: AA:BB:CC:DD:EE:FF
id: JustSaltPro
on_connect:
then:
- lambda: |-
ESP_LOGD("ble_client_lambda", "Connected to BLE device");
on_passkey_notification:
then:
- logger.log:
format: "Enter this passkey on your BLE device: %06d"
args: [ passkey ]
on_numeric_comparison_request:
then:
- logger.log:
format: "Compare this passkey with the one on your BLE device: %06d"
args: [ passkey ]
- ble_client.numeric_comparison_reply:
id: JustSaltPro
accept: True
binary_sensor:
- platform: ble_presence
mac_address: AA:BB:CC:DD:EE:FF
name: "JustSaltPro"
text_sensor:
- platform: ble_client
ble_client_id: JustSaltPro
name: "JustSaltPro text"
service_uuid: '09912756-7b32-4629-aeb1-b309d9a338ae'
characteristic_uuid: 'ef785c24-22bb-463d-b651-0b7445ba091c'
Apres avoir mis le JustSalt en « appairage » , l’esp ce connecte
malheureusement je n est pas encore reussi a remonter les valeur du Justsalt
si ca peut aider …
1 « J'aime »
Bonjour je me joint à vous, je viens d’être installé aussi, bon aparrement vous avez trouvé le couple des valeurs, je vais dommznder un esp 32 aussi en attente de vous lire.
bonjour
Je suis avec beaucoup d’intérêt vos avancées. Je suis équipé d’un electrolyseur E-pool justsalt duo, le e-pool command et une antenne Lr-MB.
Je débute avec home assistant alors tous mes espoirs reposent sur vous… 
Je suis bluffé par la simplicité d’intégration dans home assistant grâce au boulot de dinque fourni par les membres de ce forum!!!
Merci pour votre travail!!!