Discussion :

[Baptou88]

Bonjour à tous!
je travaille actuellement sur un système de communication avec 3 LoRa ESP32
je possède actuellement 3 modules et chaque module possède 1 identifiant (0 pour le maitre , 1 et 2 pour les esclaves)
les 2 esclaves recoltes des données grace à des capteurs et doivent les envoyer au maitre qui les traitent

j’arrive facilement a envoyer et à recevoir des packets quelconques avec ces cartes.

mon gros problème est de savoir comment construire les paquets et comment extraire les informations de ce paquet:

je souhaiterais que dans le paquet je puisse savoir:

• l'identifiant de la carte qui l'envoi
• l'identifiant de la carte qui doit réagir au message
• les données récoltes par les capteurs situé sur les 2 esclaves

merci d'avance

[Baptou88]

[Jay M]

Le plus simple : mettez les données à transférer dans une structure et émettez la structure en binaire. À la lecture vous mettez ça dans la même structure et tous les champs deviennent automatiquement mis à jour sans a avoir à écrire de parser

Si vous voulez passer par des messages en ASCII vous pouvez utiliser sprintf() pour fabriquer la chaîne et sscanf() pour extraire les champs à la réception. (Il y a des fonctions plus avancées sinon comme strtok() pour parcourir un buffer texte et chercher des séparateurs et des fonctions comme atol() ou atoi() pour lire des valeurs entières our strstr() pour chercher une sous chaîne dans une chaîne

Si ça vous semble trop compliqué vous pouvez mettre la chaîne reçue dans un objet String et utiliser les fonctions De cette classe pour l’analyse de contenu

[jpbbricole]

Bonjour Baptou88

Pour transmettre des données "sur" LORA, le plus simple est de créer une structure, je te donne un exemple de ce que j'utilise.
Cet exemple n'a pas été essayé en "vrai" mais compile sans erreurs.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include <LoRa.h>                         // LoRa-0.3.0
 
struct loraPacketDef
{byte addrLocale; byte addrTraitant; float capteurTemperature; float capteurHumidite; float capteurNiveauEau;};
loraPacketDef loraPackTx;
loraPacketDef loraPackRx;
 
const byte loraAdresseEsclave1 = 1;
const byte loraAdresseEsclave2 = 2;
const byte loraAdresseMaitre = 0;
 
 void setup() 
 {
 
 }
 
 void loop() 
{
	lectureSondes();
	loraEnvoiDonnees();
 
}
 
void loraEnvoiDonnees()
{
	loraPackTx.addrLocale = loraAdresseEsclave1;
	loraPackTx.addrTraitant = loraAdresseMaitre;
 
	LoRa.beginPacket();
	LoRa.write((uint8_t*)&loraPackTx, sizeof(loraPackTx));
	LoRa.endPacket();
}		
 
void lectureSondes()
{
	loraPackTx.capteurHumidite = 12.7;
	loraPackTx.capteurTemperature = 24.0;
	loraPackTx.capteurNiveauEau = 75.0;
}		 
 
 
void loraReceptionDonnees()
{
	int packetSize = LoRa.parsePacket ();
	if (packetSize) // Only read if there is some data to read..
	{
		LoRa.readBytes((uint8_t *)&loraPackRx, packetSize);
 
		if (loraPackRx.addrTraitant == loraAdresseEsclave1)
		{
			// Ce poaquet est pour moi
		}
 
	}
}

Les informations sont ici.

Cordialement
jpbbricole

[Jay M]

Une petite suggestion de robustesse pour la réception de la structure: vérifier que packetSize correspond bien à la taille de la structure avant de copier tout dedans.

Et une petite suggestion pour être Plus tranquille sur l’agencement des données dans la structure de manière générale, la déclarer en

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 struct __attribute__ ((packed)) loraPacketDef {
  byte addrLocale; 
  byte addrTraitant; 
  float capteurTemperature; 
  float capteurHumidite; 
  float capteurNiveauEau;
};

[Baptou88]

merci pour vos retour !!

je ne savais pas du tout qu'on pouvait utiliser les structures de cette façon

actuellement j'envoyais juste du texte de cette manière:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
void SendData(int Emetteur,int Destinataire, String Data){
  LoRa.beginPacket();
  LoRa.print(String(Emetteur,DEC) + ":" + String(Destinataire,DEC) + ":" + Data);
  LoRa.endPacket();
  count += 1 ;}

mais étant débutant en Arduino je ne connais pas du tout les fonctions pour traiter du texte...

merci pour les morceaux de code que vous m'avez fourni il sont très interessant , j'ai cependant quelques questions

• a quoi correspond le "__attribute__ ((packed))" dans la définition de la structure ?
• comment je peux vérifier que que packetSize correspond bien à la taille de la structure ?
• j'ai également remarquer que je pouvais recevoir les packets envoyer par les LoRa d'autres personnes autour de chez moi, comment faire pour ne pas traiter ces messages ?

Cordialement Baptiste,

[jpbbricole]

Bonsoir Baptou88

...je ne savais pas du tout qu'on pouvait utiliser les structures de cette façon

actuellement j'envoyais juste du texte de cette manière:
mais étant débutant en Arduino je ne connais pas du tout les fonctions pour traiter du texte...

En mode texte ça va aussi, c'est ainsi que j'ai débuté le LORA, en utilisant toutes le fonctions "pour" du langage Arduino (String), c'est assez riche.
Mais en découvrant les structures et surtout le moyen de les envoyer, ça change tout, on travaille directement avec les valeurs.

j'ai également remarquer que je pouvais recevoir les packets envoyer par les LoRa d'autres personnes autour de chez moi, comment faire pour ne pas traiter ces messages ?

C'est pas facile de s'en protéger comme dans le RF24 avec les Pipes, il faut bien "marquer" tes paquets avec une clef quelconque afin de ne lire que les tiens.

Cordialement
jpbbricole

[Jay M]

Bonsoir

a quoi correspond le "__attribute__ ((packed))" dans la définition de la structure ?

Ça permet de dire au compilateur que l’on veut «*tasser*» les octets les uns derrière les autres dans la structure. Parfois sinon le compilateur peut décider de laisser des trous pour aligner les données sur des multiples de la largeur du bus par exemple. Si vous échangez aussi des messages entre deux plateformes différentes çà augmentent vos chances de recevoir les données dans le même ordre (et vu que LORA c’est pas super rapide si on peut envoyer moins d’octets pour un même message c’est plus efficace)

j'ai également remarqué que je pouvais recevoir les packets envoyés par les LoRa d'autres personnes autour de chez moi, comment faire pour ne pas traiter ces messages ?

C’est une des raisons pour lesquelles il faut Vérifier que la taille correspond et pas recevoir quelque chose plus grand que le buffer dispo. Ensuite si on veut aller plus loin vous pouvez rajouter un attribut à la structure qui sert d’identifiant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 struct __attribute__ ((packed)) loraPacketDef {
  uint32_t identifiant;
  byte addrLocale; 
  byte addrTraitant; 
  float capteurTemperature; 
  float capteurHumidite; 
  float capteurNiveauEau;
};

et avant l’envoi vous mettez dans l’identifiant une valeur spécifique (Hexspeak genre 0xDEADBEEF ou similaire) et a la réception vous vérifiez que les 4 premiers octets de la structure correspondent.
Ensuite si ce n’est pas suffisant et que vos voisins vous envoient des paquets ressemblant, on peut crypter et signer le message avec un certificat, c’est pour des systèmes plus sécurisés...

comment je peux vérifier que que packetSize correspond bien à la taille de la structure ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 void loraReceptionDonnees()
{
	int packetSize = LoRa.parsePacket ();
	if (packetSize == sizeof(loraPacketDef)) // Only read if there is some data to read and it looks like our packet
	{
		LoRa.readBytes((uint8_t *)&loraPackRx, packetSize);
 
		if (loraPackRx.addrTraitant == loraAdresseEsclave1) //  éventuellement testez d’abord  si loraPackRx.identifiant Vaut aussi 0xDEADBEEF;
		{
			// Ce paquet est pour moi
		}
 
	}
}

[Baptou88]

merci beaucoup pour vos retour !

[Baptou88]

dans la même optique je cherche a envoyer des ordres à mes esclaves, je voudrais par example declancher des procedures depuis le maitre
Comment faire ?

Cordialement Baptiste

[jpbbricole]

Bonsoir Baptou88

dans la même optique je cherche a envoyer des ordres à mes esclaves, je voudrais par example declancher des procedures depuis le maitre

Montres nous ton programme actuel, est-ce le maître qui demande les mesures ou est-ce l'esclave qui décide?
Mais, dans les grandes lignes, pour envoyer des ordres à l'esclave, c'est la même façon que d'envoyer les mesures au maitre, il faut peut-être créer une structure plus adaptée.

Cordialement
jpbbricole

[Jay M]

je cherche a envoyer des ordres à mes esclaves, je voudrais par example declancher des procedures depuis le maitre

Bonjour Baptiste et tous les autres participant(e)s

Comme le dit @JP si vous ne voulez échanger qu’un seul type de bloc d’octet entre tous vos ESP32 il faut adapter ce que l’on met dans le buffer envoyé et que l’un des champs de ce bloc permette de décider ce qu’il contient vraiment.

On peut typiquement mettre à profit quand on a une architecture uniforme (même compilateur et plateformes) ce qu’on appelle une UNION de structures, c’est à dire stocker dans les octets associés du bloc différentes choses en fonction de ce que l’on veut faire. Une union permet d’avoir différents types de données dans une zone mémoire et la taille de l’union est simplement la taille nécessaire pour contenir son plus grand membre.

Par exemple vous pouvez définir une liste (enum) de types de données et différentes structures qui contiennent le même début mais dont la suite varie en fonction de cet enum. Il permettra de savoir quel type de bloc on a reçu et donc d’accéder les champs avec le bon format, le compilateur se chargeant de tout.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
/*
   __attribute__ ((packed))
    Cet attribut, attaché à la définition de type struct ou union, spécifie que chaque membre
    (autre que les champs de bits de largeur nulle) de la structure ou de l'union est placé pour 
    minimiser la mémoire requise. Lorsqu'il est attaché à une définition enum, il indique que le 
    plus petit type intégral doit être utilisé.
*/

// les commandes possibles:
enum commandeDef : byte {NOTIFIER, LIRE, ECRIRE, DÉTRUIRE, CHANTER, DANSER};
// si la commande est NOTIFIER c’est une structure Qui contient des données
// sinon c’est une commande avec des paramètres

struct __attribute__ ((packed)) loraDonneesDef {
  uint32_t identifiant;
  byte addrLocale; 
  byte addrTraitant; 
  byte typeContenu; // permet de savoir si c’est une commande ou des données, ici NOTIFIER
  float capteurTemperature; 
  float capteurHumidite; 
  float capteurNiveauEau;
};

struct __attribute__ ((packed)) loraCommandeDef {
  uint32_t identifiant;
  byte addrLocale; 
  byte addrTraitant; 
  commandeDef typeContenu; // permet de savoir si c’est une commande ou des données ici diffèrent de NOTIFIER; 
  int unParametre;
  int unAutreParametre;
};

union __attribute__ ((packed)) commandeOuDonneesDef {
{
  loraDonneesDef donnees;
  loraCommandeDef commande;
};

notez la partie en rouge dans les définitions de structures qui change. L’indicateur qui nous dira quelle structure on a est dans typeContenu qui est en commun et au même endroit dans les 2 structures.

Avec cela au lieu d’envoyer une structure d’un des types, vous émettez un bloc de type commandeOuDonneesDef.

À la réception vous pouvez regarder les premiers attributs indifféremment par données ou commande pour voir si c’est pour vous, ils sont communs et au même endroit dans les deux structures et ensuite décider en fonction de la valeur de typeContenu Si vous accédez à la bonne spécification

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
commandeOuDonneesDef recu; // buffer mémoire ou recevoir ce qui est transmis

... // effectuer la réception et vérification de taille et destination comme avant

// si c’est pour nous
if (recu.donnees.typeContenu == NOTIFIER) {
  // ce sont des données, accéder au contenu avec recu.donnees.xxxx
  ....
} else {
  // c’est une commande, accéder au contenu avec recu.commande.xxx
  switch (recu.commande. typeContenu) {
    case LIRE:
      ....
    break;
  
    case ÉCRIRE:
      ...
    break;

   case ....

    default: break;
  }
}

J’ai tapé tout ça sur mon smartphone donc pas testé, il peut y avoir des erreurs, c’est le principe qu’il faut retenir.

PS: on peut aussi avoir une structure avec tout ce qui est partagé et seulement une union en dernier champ de la structure - ça évite de dupliquer les déclarations. Dans ce cas c’est cette structure qu’on envoie

[Baptou88]

Por le moment mon code est très basic ...
voici celui du maitre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
#include "heltec.h"
#define BAND    868E6  //you can set band here directly,e.g. 868E6,915E6
 
#define btn_PRG 0
#define LED 25
 
int sendintervall = 5000; //Interval between sends
int IdLora = 0;
int ButtonState= 0;
int PreviousButtonState = 0;
unsigned long previousMillis = 0;       
int count = 0000;
 
void LoraDisplay(long currentmillis ) {
Heltec.display -> clear();
  Heltec.display -> drawString(0,0,"LoRa " + String(IdLora,DEC));
  Heltec.display -> drawString(100,0,String(currentmillis,DEC));
  Heltec.display -> drawString(0,12,"Button: ");
  Heltec.display -> drawString(97,12,"|");
  if (ButtonState == LOW) {
     Heltec.display -> drawString(74,12,"True");
  } else {
   Heltec.display -> drawString(102,12,"False");
  }
 Heltec.display -> drawString (0,24,"Counter : " + String(count,DEC)+ " " + String(count,HEX) );
  Heltec.display -> display();
}
 
void SendData(int Emetteur,int Destinataire, String Data){
  LoRa.beginPacket();
  LoRa.print(String(Emetteur,DEC) + ":" + String(Destinataire,DEC) + ":" + Data);
  LoRa.endPacket();
  count += 1 ;
}
 
void setup() {
  // put your setup code here, to run once:
pinMode(btn_PRG, INPUT);
pinMode(LED, OUTPUT);
 
//Serial.begin(9600);
  Heltec.begin(true /*DisplayEnable Enable*/, true /*Heltec.LoRa Disable*/, true /*Serial Enable*/, true /*PABOOST Enable*/, BAND /*long BAND*/);
  delay(1000);
  Heltec.display -> clear();
 
  Heltec.display->setFont(ArialMT_Plain_10);
  Heltec.display -> drawString(40,1,"Hello World!");
  Heltec.display -> drawString(1,10,"Sender " + String(IdLora,DEC));
  Heltec.display -> display();
  delay(1500);
}
 
 
void loop() {
  // put your main code here, to run repeatedly:
 unsigned long currentMillis = millis(); 
 ButtonState = digitalRead(btn_PRG); 
if (PreviousButtonState != ButtonState ) {  
  PreviousButtonState = ButtonState;
 
    if (ButtonState == 0)  {
 
      //SendData(IdLora , 1 , "Button TRUE");
 
    } else {
 
       //SendData(IdLora , 1 , "Button False");
 
    }
}
if (currentMillis - previousMillis >= sendintervall) {
    // save the last time you blinked the LED
    previousMillis = currentMillis;
     if (ButtonState == 0)  {
 
      SendData(IdLora , 1 , "Button TRUE");
 
    } else {
 
       SendData(IdLora , 1 , "Button False");
 
    }
}
  digitalWrite (LED,!ButtonState);
 
LoraDisplay(currentMillis - previousMillis);
 
 
}

et celui de l'esclave:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include "heltec.h"
#define BAND    868E6  //you can set band here directly,e.g. 868E6,915E6
 
#define btn_PRG 0
#define LED 25
 
String rssi = "RSSI --";
String packet ;
String packSize = "--";
int IdLora = 1;
 
void LoRaData(){
 
  Heltec.display->clear();
  Heltec.display->setTextAlignment(TEXT_ALIGN_LEFT);
  Heltec.display->setFont(ArialMT_Plain_10);
  Heltec.display -> drawString(0,0 , "Lora " + String(IdLora,DEC));
  Heltec.display->drawString(0 , 15 , "Received "+ packSize + " bytes");
  Heltec.display->drawStringMaxWidth(0 , 26 , 128, packet);
  Heltec.display->drawString(0, 37, rssi);  
  Heltec.display->display();
}
void cbk(int packetSize) {
  packet ="";
  packSize = String(packetSize,DEC);
  for (int i = 0; i < packetSize; i++) { 
    packet += (char) LoRa.read(); 
   }
  rssi = "RSSI " + String(LoRa.packetRssi(), DEC) ;
  LoRaData();
}
 
void setup() {
  // put your setup code here, to run once:
  Heltec.begin(true /*DisplayEnable Enable*/, true /*Heltec.LoRa Disable*/, true /*Serial Enable*/, true /*PABOOST Enable*/, BAND /*long BAND*/);
  delay(1000);
  Heltec.display -> clear();
 
  Heltec.display -> drawString(10,1,"Hello World!");
  Heltec.display -> drawString(1,10,"Receiver " + String(IdLora,DEC));
  Heltec.display -> display();
  delay(1500);
}
 
void loop() {
  // put your main code here, to run repeatedly:
 int packetSize = LoRa.parsePacket();
  if (packetSize) { 
    cbk(packetSize);  
  }
  delay(10);
}

[Baptou88]

un grand merci pour vos réponse ! j'ai passé une bonne partie du weekend à analyser et à tester vos propositions et ca semble être très efficace !