Boolena transmission with arduinoBle

eadelion · December 22, 2024, 12:24pm

Bonjour à tous.

J'ai un problème de transmission entre 2 modules (central = arduino R4 Wifi et peripheral = Waveshare ESP32-S3-zero).
En gros, je suis obligé d'utiliser le Bluetooth car le wifi est trop perturbé par l'environnement.

Je dois échanger :

central -> peripheral
3 booleéns (true/false) que le peripheral enregistre pour son programme propre
peripheral -> central
*4 booleens (true/false) que le central renverra sur le cloud.

code central

#include <ArduinoBLE.h>

// Définir les caractéristiques pour la communication
BLEService pumpService("19b10000-e8f2-537e-4f6c-d104768a1214");  // UUID du service personnalisé
BLECharacteristic sendCharacteristic("19b10000-e8f2-537e-4f6c-d104768a1214", BLEWrite, 1);  // Caractéristique pour envoyer les données (1 octet)
BLECharacteristic receiveCharacteristic("19b10000-e8f2-537e-4f6c-d104768a1214", BLERead, 1);  // Caractéristique pour recevoir les données (1 octet)

bool esp32_man_start = 1;
bool esp32_time = 1;
bool esp32_man_auto = 0;

bool LSHH = false;
bool LSH = false;
bool LSL = false;
bool pump = false;

void setup() 
{
  Serial.begin(115200);
  Serial.println("Arduino R4 Démarré");



  // Initialiser le BLE
  if (!BLE.begin()) 
  {
    Serial.println("Échec de l'initialisation du BLE !");
    while (1);
  }

  BLE.setLocalName("Central_Device");  // Nom du périphérique BLE
  BLE.setAdvertisedService(pumpService);  // Annonce le service
  pumpService.addCharacteristic(sendCharacteristic);  //ajouter la caractéristique send (central->device)
  pumpService.addCharacteristic(receiveCharacteristic); //ajouter la caractéristique receive (device->peripheral)
  BLE.addService(pumpService);

  BLE.advertise();  // Commence la publicité pour que le périphérique puisse se connecter
  Serial.println("En attente de connexion...");
  BLE.scanForUuid("19b10000-e8f2-537e-4f6c-d104768a1214");

}

void loop() 
{
  // Vérifier si un périphérique s'est connecté
  BLEDevice peripheral = BLE.available();

  if (peripheral) 
  {
  
    Serial.print("Connecté à ");
    Serial.println(peripheral.address());
    Serial.println(peripheral.localName());
    BLE.stopScan();

    if(peripheral.connect())
    {
      byte data = 0;
      data |= esp32_man_start;        // Placer man_start dans le bit 0
      data |= (esp32_time << 1);       // Placer time dans le bit 1
      data |= (esp32_man_auto << 2);  // Placer man_auto dans le bit 2
      sendCharacteristic.writeValue(data);  // Envoie des données
      Serial.print("Envoyé: ");
      Serial.println(data,BIN);  // Affiche les données envoyées en binaire
      // Attendre une seconde avant d'envoyer de nouvelles données
      delay(1000);

         const uint8_t *received_Data = receiveCharacteristic.value();
         byte receivedData = *received_Data;
         LSHH = (receivedData >> 3);
         LSH = (receivedData >> 2);
         LSL = (receivedData >> 1);
         pump = receivedData;

        Serial.print("Reçu: LSHH=");
        Serial.print(LSHH);
        Serial.print(" LSH=");
        Serial.print(LSH);
        Serial.print(" LSL=");
        Serial.print(LSL);
        Serial.print(" pump=");
        Serial.println(pump);
    
    }
    BLE.disconnect();
    Serial.print("Déconnecté de ");
    Serial.println(peripheral.address());
    
  }
  delay(5000);
  BLE.scanForUuid("19b10000-e8f2-537e-4f6c-d104768a1214");
}

code du peripheral

#include <ArduinoBLE.h>

// Définir les caractéristiques pour la communication
BLEService pumpService("19b10000-e8f2-537e-4f6c-d104768a1214");  // UUID du service personnalisé
BLECharacteristic sendCharacteristic("19b10000-e8f2-537e-4f6c-d104768a1214", BLERead, 1);  // Caractéristique pour envoyer les données (1 octet)
BLECharacteristic receiveCharacteristic("19b10000-e8f2-537e-4f6c-d104768a1214", BLEWrite, 1);  // Caractéristique pour recevoir les données (1 octet)


// Variables pour stocker les valeurs booléennes reçues
bool man_auto = false;
bool bitTime = false;
bool man_start = false;

//variables pour stocker les valeurs booléennes à envoyer
bool LSHH = false;
bool LSH = false;
bool LSL = false;
bool pump = false;

/* Définition et type des IO */
#define readLSL       1
#define readLSH       2
#define readLSHH      3
#define Pump      4
#define led       21


void setup() {
  Serial.begin(115200);
  /*déclaration des pins*/
  pinMode(readLSL, INPUT_PULLUP);
  pinMode(readLSH, INPUT_PULLUP);
  pinMode(readLSHH, INPUT_PULLUP);
  pinMode(Pump, OUTPUT);
  digitalWrite(Pump,LOW);

  // Initialiser le BLE
  if (!BLE.begin()) {
    Serial.println("Échec de l'initialisation du BLE !");
    while (1);
  }

  BLE.setLocalName("Peripheral_Device");  // Nom du périphérique BLE
  BLE.setAdvertisedService(pumpService);  // Annonce le service
  pumpService.addCharacteristic(sendCharacteristic);
  pumpService.addCharacteristic(receiveCharacteristic);
  BLE.addService(pumpService);

  BLE.advertise();  // Commence la publicité pour que le périphérique central puisse se connecter
  Serial.println("En attente de connexion...");
  BLE.scanForUuid("19b10000-e8f2-537e-4f6c-d104768a1214");
  delay(10000);
}

void loop() 
{
  BLEDevice central = BLE.available();    // Vérifier si un périphérique s'est connecté

  if (central) 
  {
    Serial.print("Connecté à ");
    Serial.println(central.address());
    Serial.println(central.localName());
    BLE.stopScan();

    if(central.connect())
    {
        const uint8_t*  received_Data = sendCharacteristic.value();
        byte receivedData = *received_Data;
        man_auto = (receivedData >> 2);
        bitTime = (receivedData >> 1);
        man_start = receivedData;
        Serial.println(receivedData,BIN);
        Serial.print("Reçu: man_auto=");
        Serial.print(man_auto);
        Serial.print(" time=");
        Serial.print(bitTime);
        Serial.print(" man_start=");
        Serial.println(man_start);
      
     /*Encoder les valeurs booléennes dans un byte (1 octet)*/
      byte data = 0;
      data |= (LSHH << 3);  // Placer LSHH dans le bit 3 (exemple de valeurs envoyées)
      data |= (LSH << 2);  // Placer LSH dans le bit 2
      data |= (LSL << 1);  // Placer LSL dans le bit 1
      data |= Pump;         // Placer pump dans le bit 0

      receiveCharacteristic.writeValue(data);  // Envoie des données
      Serial.print("Envoyé: LSHH=");
      Serial.print((data >> 3));
      Serial.print(" LSH=");
      Serial.print((data >> 2));
      Serial.print(" LSL=");
      Serial.print((data >> 1));
      Serial.print(" pump=");
      Serial.println(data);
    
    }
  }
  BLE.disconnect();

delay(10000);
BLE.scanForUuid("19b10000-e8f2-537e-4f6c-d104768a1214");
}

En résumé, lorsque j'envoie 7 du central je recois 163 sur le peripheral et je remarque que sans reset, la valeur lue par le peripheral est toujours la même.

Quelqu'un peut il m'aiguiller sur cette bibliothèque ?

UKHeliBob · December 22, 2024, 12:25pm

Post mis dans la mauvaise section, on parle anglais dans les forums généraux. déplacé vers le forum francophone.

Merci de prendre en compte les recommandations listées dans Les bonnes pratiques du Forum Francophone

fdufnews · December 22, 2024, 2:03pm

eadelion:

//variables pour stocker les valeurs booléennes à envoyer
bool LSHH = false;
bool LSH = false;
bool LSL = false;
bool pump = false;

     /*Encoder les valeurs booléennes dans un byte (1 octet)*/
      byte data = 0;
      data |= (LSHH << 3);  // Placer LSHH dans le bit 3 (exemple de valeurs envoyées)
      data |= (LSH << 2);  // Placer LSH dans le bit 2
      data |= (LSL << 1);  // Placer LSL dans le bit 1
      data |= Pump;         // Placer pump dans le bit 0

LSHH, LSH, LSL, Pump sont de type bool. On ne décale pas des booléens. On décale des entiers.
Il vaudrait mieux écrire comme cela

      byte data = 0;
      data |= LSHH ? 8 : 0;   // Placer LSHH dans le bit 3 (exemple de valeurs envoyées)
      data |= LSH ? 4 : 0;      // Placer LSH dans le bit 2
      data |= LSL ? 2 : 0;       // Placer LSL dans le bit 1
      data |= Pump; ? 1 : 0;  // Placer pump dans le bit 0

fdufnews · December 22, 2024, 2:14pm

La même remarque s'applique dans l'autre sens

L'écriture suivante n'est pas rigoureuse car tu affectes un byte à un booléen et en plus tu ne fais pas de masque pour isoler le bit qui t'intéresse.

eadelion:

         const uint8_t *received_Data = receiveCharacteristic.value();
         byte receivedData = *received_Data;
         LSHH = (receivedData >> 3);
         LSH = (receivedData >> 2);
         LSL = (receivedData >> 1);
         pump = receivedData;

Il vaudrait mieux écrire comme cela

const uint8_t msk_LSHH = 8;
const uint8_t msk_LSH = 4;
const uint8_t msk_LSL = 2;
const uint8_t msk_pump = 1;

uint8_t *received_Data = receiveCharacteristic.value();
byte receivedData = *received_Data;
LSHH = (receivedData & msk_LSHH) != 0;
LSH = (receivedData & msk_LSH) != 0;
LSL = (receivedData & msk_LSL) != 0;
pump = (receivedData & msk_pump) != 0;

system · June 20, 2025, 2:14pm

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.

Topic		Replies	Views
Communication bluetooth entre 2 arduinos Français	4	789	May 6, 2021
[Non réglé] transmission de donnée PC => module bluetooth => arduino nano Français	1	1898	May 6, 2021
[Conseil]Dialogue bluetooth entre 2 arduino Français	9	5759	May 6, 2021
Communication Bluetooth entre deux modules XBee Français	1	664	May 6, 2021
connect 2 arduinos 101 with BLE 101	1	1469	May 6, 2021

Boolena transmission with arduinoBle

Related topics