NRF24L01 : Pas de message reçu

Version imprimable

Voir 40 message(s) de cette discussion en une page

1 pièce(s) jointe(s)

NRF24L01 : Pas de message reçu

Bonjour à Tous ,

J'ai souhaitais tester une liaison avec le NRF24L01
Emetteur : NANO + NRF24L01
Récepteur : WEMOS + NRF24L01

Pour ce faire je me suis inspiré d'un exemple

EMETTEUR

Code:

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
 
 
#include <SPI.h>
#include <RF24.h>
 
#define pinCE   7             // On associe la broche "CE" du NRF24L01 à la sortie digitale D7 de l'arduino
#define pinCSN  8             // On associe la broche "CSN" du NRF24L01 à la sortie digitale D8 de l'arduino
#define tunnel  "PIPE1"       // On définit un "nom de tunnel" (5 caractères), pour pouvoir communiquer d'un NRF24 à l'autre
 
RF24 radio(pinCE, pinCSN);    // Instanciation du NRF24L01
 
const byte adresse[6] = tunnel;               // Mise au format "byte array" du nom du tunnel
const char message[] = "Hello World!!!";     // Message à transmettre à l'autre NRF24 (32 caractères maxi, avec cette librairie)
 
void setup() {
  radio.begin();                      // Initialisation du module NRF24
  radio.openWritingPipe(adresse);     // Ouverture du tunnel en ÉCRITURE, avec le "nom" qu'on lui a donné
  radio.setPALevel(RF24_PA_MIN);      // Sélection d'un niveau "MINIMAL" pour communiquer (pas besoin d'une forte puissance, pour nos essais)
  radio.stopListening();              // Arrêt de l'écoute du NRF24 (signifiant qu'on va émettre, et non recevoir, ici)
}
 
void loop() {
  radio.write(&message, sizeof(message));     // Envoi de notre message
  delay(1000);                                // … toutes les secondes !
}

RECEPTEUR

Code:

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
 
//**********************************
// RECEPTEUR WEMOS + NFR24L01
//**********************************
 
#include <SPI.h>
#include <RF24.h>
 
#define pinCE   2            // On associe la broche "CE" du NRF24L01 à la sortie digitale GPIO2 D4 de l'arduino
#define pinCSN  15             // On associe la broche "CSN" du NRF24L01 à la sortie digitale GPIO15 D8 de l'arduino
#define tunnel  "PIPE1"       // On définit le "nom de tunnel" (5 caractères) à travers lequel on va recevoir les données de l'émetteur
 
RF24 radio(pinCE, pinCSN);    // Instanciation du NRF24L01
 
const byte adresse[6] = tunnel;       // Mise au format "byte array" du nom du tunnel
char message[32];                     // Avec cette librairie, on est "limité" à 32 caractères par message
 
void setup() {
  // Initialisation du port série (pour afficher les infos reçues, sur le "Moniteur Série" de l'IDE Arduino)
  Serial.begin(9600);
  Serial.println("Récepteur NRF24L01");
  Serial.println("");
 
  // Partie NRF24
  radio.begin();                      // Initialisation du module NRF24
  radio.openReadingPipe(0, adresse);  // Ouverture du tunnel en LECTURE, avec le "nom" qu'on lui a donné
  radio.setPALevel(RF24_PA_MIN);      // Sélection d'un niveau "MINIMAL" pour communiquer (pas besoin d'une forte puissance, pour nos essais)
  radio.startListening();             // Démarrage de l'écoute du NRF24 (signifiant qu'on va recevoir, et non émettre quoi que ce soit, ici)
}
 
void loop() {
  // On vérifie à chaque boucle si un message est arrivé
  if (radio.available()) {
    radio.read(&message, sizeof(message));                        // Si un message vient d'arriver, on le charge dans la variable "message"
    Serial.print("Message reçu : ");
    Serial.println(message);     // … et on l'affiche sur le port série !
    delay (5000);
  }
}

J'obtiens ceci sans le contenu du message
Mais je n'arrive pas à trouver mon erreur

30/01/2024, 11h27
Jay M

la majorité des soucis avec des RF24 proviennent généralement du montage et de l'alimentation
testez votre circuit avec un code réputé fonctionnel. Tant que ça ne fonctionne pas, c'est qu'il faut explorer la partie hardware (vous mentionnez par exemple un WEMOS, c'est du 3.3V - est-ce que vous avez adapté la tension de votre NRF24L01?)
30/01/2024, 12h43
cobra38
Bonjour Jay M

Citation:

c'est du 3.3V - est-ce que vous avez adapté la tension de votre NRF24L01?

J'utilise des adaptateurs pour l’Émetteur comme pour le Récepteur
En ce qui concerne l’Émetteur, l'envoi semble correct '
j'obtiens bien le message "Hello World!!! ( j'ai rajouté cela)
Code:

1 2 3 4 Serial.print("Message envoyé : "); Serial.println(message); // … et on l'affiche sur le port série ! delay(1000); // … toutes les secondes !
par contre pour le récepteur
je n’obtiens rien d'autre que : "Message reçu : " ce qui prouve qu'il a rçu quelque chose , le canal n'est peut-être pas le bon

J'ai vérifié les raccordements et aussi retiré l'adaptateur du récepteur pour voir si le pb venait de là ( en alimentant le module en 3.3v)
j'en suis là ....
30/01/2024, 14h10
Jay M

trouvez un tuto avec un petit code d'exemple et validez votre montage avec leur code
30/01/2024, 14h16
cobra38

Justement pour m'affranchir de mon propre programme
Ce que j'ai mis en exemple vient d'un tuto
https://passionelectronique.fr/tutorial-nrf24l01/
30/01/2024, 16h04
Jay M

vous avez exactement le même hardware?
30/01/2024, 16h37
cobra38

En Récepteur , j'ai un ESP8266 Wemos D1 Mini
En Emetteur un Nano
30/01/2024, 17h10
Jay M

la wemos parle en 3.3V.
avez vous un lien sur votre adaptateur ? (celui du tuto c'est pour connecter généralement vers un module et alim 5V)
30/01/2024, 17h25
cobra38

Citation:

la wemos parle en 3.3V.
avez vous un lien sur votre adaptateur ? (celui du tuto c'est pour connecter généralement vers un module et alim 5V)

J'alimente l'adaptateur du NRF24L01 via le 5v du Wemos , celui étant alimenté avec l'USB
30/01/2024, 17h32
Jay M

Citation:

Envoyé par cobra38

J'alimente l'adaptateur du NRF24L01 via le 5v du Wemos , celui étant alimenté avec l'USB

OK pour l'alim en 5V de l'adaptateur, mais vos GPIO "causent en 3.3V" alors que ce module attend des communications en 5V aussi
30/01/2024, 18h43
cobra38

j'ai fait l'essai sans adaptateur comme préconisé ici
https://electroniqueamateur.blogspot...ec-cartes.html
mais j'ai le même résultat

par contre je ne comprends pas pourquoi les pins
ne sont pas identifiées dans le programme seuls CE et CSN sont requises par RF24

CSN du nRF24L01 - GPIO5 (D1) de l'ESP8266
SCK du nRF24L01 - GPIO14 (D5) de l'ESP8266
MOSI du nRF24L01 - GPIO13 (D7) de l'ESP8266
MISO du nRF24L01 - GPIO12 (D6) de l'ESP8266
30/01/2024, 19h11
Jay M

Citation:

Envoyé par cobra38

par contre je ne comprends pas pourquoi les pins ne sont pas identifiées dans le programme seuls CE et CSN sont requises par RF24

la bibliothèque dépend de l'implémentation du SPI qui connait les pins MISO et MOSI (définie en hardware ou pour la plateforme cible choisie à la compilation )

---
le problème en branchant directement l'alim à 3.3V est la capacité à fournir le burst de courant nécessaire. ça peut marcher comme ça peut "merdouiller". La NRF24L01 est assez sensible à son alimentation

1 pièce(s) jointe(s)

j'ai fait une autre a^pproche
j'ai raccordé le Récepteur NRF24L01 avec un Nano ( tout en permutant les modules )
suivant le prog suivant :

Code:

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
 
//**********************************
// RECEPTEUR NANO + NFR24L01
//**********************************
 
#include <SPI.h>
#include <RF24.h>
 
#define pinCE   7            // On associe la broche "CE" du NRF24L01 à la sortie digitale GPIO2 D4 de l'arduino
#define pinCSN  8             // On associe la broche "CSN" du NRF24L01 à la sortie digitale GPIO15 D8 de l'arduino
#define tunnel  "PIPE1"       // On définit le "nom de tunnel" (5 caractères) à travers lequel on va recevoir les données de l'émetteur
 
RF24 radio(pinCE, pinCSN);    // Instanciation du NRF24L01
 
const byte adresse[6] = tunnel;       // Mise au format "byte array" du nom du tunnel
char Rmessage[32];                     // Avec cette librairie, on est "limité" à 32 caractères par message
 
void setup() {
  // Initialisation du port série (pour afficher les infos reçues, sur le "Moniteur Série" de l'IDE Arduino)
  Serial.begin(9600);
  // Partie NRF24
  radio.begin(); // Initialisation du module NRF24
  radio.setDataRate(RF24_250KBPS);  // en remplaçant « xxx » par RF24_250KBPS, RF24_1MBPS, ou encore, RF24_2MBPS
  radio.openReadingPipe(0,adresse);  // Ouverture du tunnel en LECTURE, avec le "nom" qu'on lui a donné
  radio.setPALevel(RF24_PA_MIN);      // Sélection d'un niveau "MINIMAL" pour communiquer (pas besoin d'une forte puissance, pour nos essais)
  radio.startListening();             // Démarrage de l'écoute du NRF24 (signifiant qu'on va recevoir, et non émettre quoi que ce soit, ici)
  Serial.println("Récepteur NRF24L01");
  Serial.println("");
  delay(100);
}
 
void loop() {
  if (radio.available()) {
    radio.read(&Rmessage,sizeof(Rmessage)); // Si un message vient d'arriver, on le charge dans la variable "message"
    Serial.print("reçu: ");
    Serial.println(Rmessage);     // … et on l'affiche sur le port série !
    delay (1000);
  }
}

J'ai le même problème
je ne pige pas .....

02/02/2024, 11h52
Jay M

le Wemos n'est plus utilisé ?
02/02/2024, 12h00
cobra38

Non , je suis passé au Nano pour essayer
mais j'ai le même problème que je situe au niveau
du traitement de la variable "message"

mais j'avoue ne plus rien comprendre
02/02/2024, 15h08
Jay M

donc vous avez bien 2 Arduino Nano 5V + adaptateur 5V + NRF24L01 et c'est branché correctement ?

photo du montage?

3 pièce(s) jointe(s)

Voici Jay M:
(merci encore)

Emetteur :

Code:

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
 
#include "SPI.h"
#include "nRF24L01.h"
#include "RF24.h"
 
#define pinCE   7             // On associe la broche "CE" du NRF24L01 à la sortie digitale D7 de l'arduino
#define pinCSN  8             // On associe la broche "CSN" du NRF24L01 à la sortie digitale D8 de l'arduino
#define tunnel  "1Node"       // On définit un "nom de tunnel" (5 caractères), pour pouvoir communiquer d'un NRF24 à l'autre
 
RF24 radio(pinCE, pinCSN);    // Instanciation du NRF24L01
 
const byte adresse[6] = tunnel;               // Mise au format "byte array" du nom du tunnel
const char message[] = "Hello World!!!";     // Message à transmettre à l'autre NRF24 (32 caractères maxi, avec cette librairie)
 
void setup() {
  Serial.begin(9600);
  Serial.println("Emetteur NRF24L01");
  Serial.println("");
  radio.begin();                      // Initialisation du module NRF24
  radio.openWritingPipe(adresse);     // Ouverture du tunnel en ÉCRITURE, avec le "nom" qu'on lui a donné
  radio.setDataRate(RF24_250KBPS);  // en remplaçant « xxx » par RF24_250KBPS, RF24_1MBPS, ou encore, RF24_2MBPS
  radio.setPALevel(RF24_PA_MIN);      // Sélection d'un niveau "MINIMAL" pour communiquer (pas besoin d'une forte puissance, pour nos essais)
  radio.stopListening();              // Arrêt de l'écoute du NRF24 (signifiant qu'on va émettre, et non recevoir, ici)
}
 
void loop() {
  radio.write(&message,sizeof(message)); // Envoi de notre message
  Serial.print("Message envoyé : ");
  Serial.println(message);     // … et on l'affiche sur le port série !
  delay(1000);                                // … toutes les secondes !
}

RECEPTEUR

Code:

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
 
//**********************************
// RECEPTEUR NANO + NFR24L01
//**********************************
 
#include <SPI.h>
#include <RF24.h>
 
#define pinCE   7            // On associe la broche "CE" du NRF24L01 à la sortie digitale GPIO2 D4 de l'arduino
#define pinCSN  8             // On associe la broche "CSN" du NRF24L01 à la sortie digitale GPIO15 D8 de l'arduino
#define tunnel  "1Node"       // On définit le "nom de tunnel" (5 caractères) à travers lequel on va recevoir les données de l'émetteur
 
RF24 radio(pinCE, pinCSN);    // Instanciation du NRF24L01
 
const byte adresse[6] = tunnel;       // Mise au format "byte array" du nom du tunnel
const char message[]="";                   // Avec cette librairie, on est "limité" à 32 caractères par message
 
void setup() {
  // Initialisation du port série (pour afficher les infos reçues, sur le "Moniteur Série" de l'IDE Arduino)
  Serial.begin(9600);
 
  // Partie NRF24
  radio.begin(); // Initialisation du module NRF24
  radio.setDataRate(RF24_250KBPS);  // en remplaçant « xxx » par RF24_250KBPS, RF24_1MBPS, ou encore, RF24_2MBPS
  radio.openReadingPipe(0,adresse);  // Ouverture du tunnel en LECTURE, avec le "nom" qu'on lui a donné
  delay(500); 
  radio.setPALevel(RF24_PA_MIN);      // Sélection d'un niveau "MINIMAL" pour communiquer (pas besoin d'une forte puissance, pour nos essais)
  radio.startListening();             // Démarrage de l'écoute du NRF24 (signifiant qu'on va recevoir, et non émettre quoi que ce soit, ici)
  Serial.println("Récepteur NRF24L01");
  Serial.println("");
 
  delay(100);
}
 
void loop() {
  if (radio.available()) {
    radio.read(&message,sizeof(message)); // Si un message vient d'arriver, on le charge dans la variable "message"
    Serial.print("reçu: ");
    Serial.println(message);     // … et on l'affiche sur le port série !
    delay (5000);
  }
}

02/02/2024, 16h24
Jay M

côté récepteur vous n'avez quasiment pas de mémoire allouée pour le message (juste 1 octet) et vous dites en plus que le texte n'est pas modifiable

Code:

const char message[]=""; // Avec cette librairie, on est "limité" à 32 caractères par message

donc quand vous faites

Code:

radio.read(&message,sizeof(message)); // Si un message vient d'arriver, on le charge dans la variable "message"

vous dites que votre buffer fait 1 octet

==>essayez avec

Code:

char message[50];

désolé , c'est idem
- j'avais déjà essayé avec 32 mais sans résultat
- j'ai aussi permuté les modules pour m'affranchir d'un défaut

je mets à toute fin utile le message à la compilation

Code:

1
2
3
4
5
6
7
8
9
10
11
 
D:\5- ELECTRONIQUE\Station Meteo\TEST\NRF24L01\R\R.ino: In function 'void loop()':
D:\5- ELECTRONIQUE\Station Meteo\TEST\NRF24L01\R\R.ino:36:16: warning: invalid conversion from 'const void*' to 'void*' [-fpermissive]
     radio.read(&message,sizeof(message)); // Si un message vient d'arriver, on le charge dans la variable "message"
                ^~~~~~~~
In file included from D:\5- ELECTRONIQUE\Station Meteo\TEST\NRF24L01\R\R.ino:6:0:
C:\Users\Utilisateur\Documents\Arduino\libraries\RF24/RF24.h:430:10: note:   initializing argument 1 of 'void RF24::read(void*, uint8_t)'
     void read(void* buf, uint8_t len);
          ^~~~
Le croquis utilise 3324 octets (10%) de l'espace de stockage de programmes. Le maximum est de 30720 octets.
Les variables globales utilisent 286 octets (13%) de mémoire dynamique, ce qui laisse 1762 octets pour les variables locales. Le maximum est de 2048 octets.

essayez avec ces code

EMETTEUR

Code:

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
 
// EMETTEUR
#include <RF24.h>
 
const byte CEPin = 8;
const byte CSNPin = 7;
RF24 radio(CEPin, CSNPin);
 
uint8_t adresse[] = {0xCC, 0xCE, 0xCC, 0xCE, 0xCC};
 
struct __attribute__ ((packed)) t_message {
  char payload[30];
} message;
 
void setup() {
  Serial.begin(115200);
 
  if (!radio.begin()) {
    Serial.println(F("erreur !!"));
    while (true) ; 
  }
 
  radio.setPALevel(RF24_PA_LOW);
  radio.setPayloadSize(sizeof(t_message));
  radio.openWritingPipe(adresse);
  radio.stopListening();
 
  strcpy(message.payload, "Hello, world");
  Serial.println(F("PRET"));
}
 
void loop() {
  if (!radio.write( &message, sizeof(t_message) ))
    Serial.println(F("erreur d'envoi"));
  else
    Serial.print(message.payload);
 
  delay(1000);
}

RECEPTEUR

Code:

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
// RECEPTEUR
#include <RF24.h>
 
const byte CEPin = 8;
const byte CSNPin = 7;
RF24 radio(CEPin, CSNPin);
 
uint8_t adresse[] = {0xCC, 0xCE, 0xCC, 0xCE, 0xCC};
 
struct __attribute__ ((packed)) t_message {
  char payload[30];
} message;
 
void setup() {
  Serial.begin(115200);
 
  if (!radio.begin()) {
    Serial.println(F("erreur !!"));
    while (true) ;
  }
 
  radio.setPALevel(RF24_PA_LOW);
  radio.setPayloadSize(sizeof(t_message));
  radio.openReadingPipe(1, adresse);
  radio.startListening();
  Serial.println(F("PRET"));
}
 
void loop() {
  if (radio.available()) {
    radio.read( &message, sizeof(t_message));
    Serial.print("Message = "); Serial.println(message.payload);
  }
}

03/02/2024, 09h45
cobra38
Bien merci Jay M

çà fonctionne mais vous serez-t-il possible de m'expliquer les 2 lignes suivante svp
car je n'en comprends pas bien la signification
Code:

1 2 3 4 5 6 uint8_t adresse[] = {0xCC, 0xCE, 0xCC, 0xCE, 0xCC}; // 204,206,204,206,204 (?) struct __attribute__ ((packed)) t_message { char payload[30]; } message;
Pourquoi cette adresse ?
Pourquoi passer par une structure pour définir une chaîne de caractères de 30 octets ?
03/02/2024, 10h21
Jay M
Citation:

Pourquoi cette adresse ?

la bibliothèque accepte des addresses sous différentes formes, vous utilisiez les 5 octets en ASCII du texte "1Node", c'est juste 5 autres octets "aléatoires" (de mémoire ils proviennent d'un vieil exemple de RF24)

Citation:

Pourquoi passer par une structure pour définir une chaîne de caractères de 30 octets ?

c'est une habitude, imaginez que vous vouliez transférer plusieurs variables et pas qu'une seule chaîne par exemple
Code:

1 2 3 4 5 6 struct __attribute__ ((packed)) t_message { float temperature; float pression; float humidite; char stationID[10]; } message;
le code de réception fonctionne aussi et vous avez directement les attributs disponibles dans la structure. j'ai donc un code générique qui peut s'adapter facilement à mes besoins. faut juste que la structure ne soit pas plus grande que le payload autorisé

merci Jay M

mon but final est de reprendre une ancienne application pour l'adapter à ma station météo actuelle ( j'ai changé d’écran TFT )
d'où mes posts précédents
pour ce faire j'ai donc fait un test de liaison NRF24L01 ( d'où ma demande actuelle)
et le programme qui équipe actuellement mon module distant est le suivant ( T° + Humidité + Vbat) :

Code:

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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
 
//***************************************************
// VERANDA 2021-11-30 V2
// Carte Arduino Pro ou Pro-mini 3.3v
//***************************************************
 
#define DEBUG
//#include <Vcc.h> 
 
 
#include <Adafruit_Sensor.h>
 
/////// DHT22 //////////////////////////////////////////
#include <DHT.h>
#define brocheDeBranchementDHT 3    // La ligne de communication du DHT22 sera donc branchée sur la pin D3 de l'Arduino
#define typeDeDHT DHT22
DHT dht(brocheDeBranchementDHT, typeDeDHT);
float dhtt,dhth;
unsigned long previousMillis = 0; // stockera la dernière température lue
const long interval = 2000; // intervalle auquel lire le capteur
 
/////////////////////////////////////////////////////////////////////////
#include <SPI.h>          // bibliothèque pour le fonctionnement du bus SPI
#include "nRF24L01.h"     // bibliothèque de modules radio
#include "RF24.h"         // plus de bibliothèque de modules radio
#include "LowPower.h"
 
byte address[][6] = {"1Node", "2Node", "3Node", "4Node", "5Node", "6Node"}; //nombre de tuyaux possibles
RF24 radio(7, 8);   // "créer" un module sur les broches 9 et 10 pour Mini Pro
 
 
//************************************************************************************************
const float VccMin   = 3.2;           // Niveau minimum attendu de Vcc, en Volts.
const float VccMax   = 4.2;           // Niveau maximum attendu de Vcc, en Volts.
const float VccCorrection = 0.99;  // Vcc mesuré par le multimètre divisé par le Vcc rapporté
const float VccEchelle = VccMax - VccMin;  // Vcc mesuré par le multimètre divisé par le Vcc rapporté
//Vcc vcc(VccCorrection);
 
 
const byte BROCHE_CAPTEUR_VIN = A0;
const float COEFF_PONT_DIVISEUR_VIN = 4.0;
 
 
//*************************************************
int tt ;
int hh ;
int pp ;
String kod="25UTH;";  // Outdoor Temp et Humidite
 
//--------------------------------------------------
// SETUP
//--------------------------------------------------
void setup()
{
  Serial.begin(115200);  
   dht.begin(); // Connect DHT sensor D3 
  ///////////////////////////////////////////////
  radio.begin(); //activer le module
  radio.setAutoAck(0);        	 // mode d'accusé de réception, 1 on 0 off
  radio.setRetries(0, 15);   	 //(délai entre les tentatives d'accès, nombre de tentatives)
  radio.enableAckPayload();  	 //activation de l'envoi de données en réponse à un signal entrant
  radio.setPayloadSize(32);      //taille du paquet, en octets
  radio.openWritingPipe(address[1]);   //nous sommes le tuyau 0, ouvrons le canal pour la transmission de données
  radio.setChannel(0x60);          //sélectionner le canal (dans lequel il n'y a pas de bruit !)
 
  radio.setPALevel (RF24_PA_MAX);    //niveau de puissance de l'émetteur. Sélectionnable RF24_PA_MIN, RF24_PA_LOW, RF24_PA_HIGH, RF24_PA_MAX
  radio.setDataRate (RF24_250KBPS); //taux de change. Sélectionnable RF24_2MBPS, RF24_1MBPS, RF24_250KBPS
  // doit être le même sur le récepteur et l'émetteur !// doit être le même sur le récepteur et l'émetteur !
  //à la vitesse la plus basse ont la sensibilité et la portée les plus élevées ! !!
 
  radio.powerUp();         //démarrer le travail
  radio.stopListening();  //pas d'écoute des ondes, nous sommes un émetteur
 
}
 
//-----------------------------------------------
// LOOP
//-----------------------------------------------
void loop()
{
	do_read_dht();
  do_vcc();
 
	for (int i=0; i <= 30; i++)
	{
		if (i<25)
		{
		if (tt!=-127)
			send_th(kod);
		else
			send_th("ER_T;");
		}
		else
		send_th("ENDD;");
		delay(150);
 
	}
	delay(2000);
 
 
  ////// avant de dormir
  byte etatSPI = SPCR;
  SPCR = 0;
  digitalWrite(13,LOW);
 
  ////////////////////////////////////////////////
  for (int i = 0; i < 7 ; i++) { // 1mn de sommeil // 
     LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
  } 
  ////  on remet l'état
  SPCR = etatSPI;
 
}
 
//*****************************************
void send_th(String kod)
{
 	String str=kod+String(tt+200)+";"+String(hh+200)+";"+String(pp+200)+";" ;
	byte str_len=str.length()+1;
	char buf[str_len];
	str.toCharArray(buf,str_len);
	radio.write(&buf, sizeof(buf)); // envoyer des données à l'autre Arduino. sizeof(TEST)))-indiquer combien d'octets nous voulons envoyer)(Le récepteur envoie un signal d'accusé de réception de données à l'émetteur (sans changer le mode de fonctionnement).
	#ifdef  DEBUG
		Serial.print("buf=");
		Serial.println(buf);
	#endif  
}
 
//***********************************************************
void do_read_dht()
 { 
    //float hum = dht.getHumidity();
    //float temp= dht.getTemperature();
    float hum = dht.readHumidity();              // Lecture du taux d'humidité (en %)
    float temp = dht.readTemperature();   // Lecture de la température, exprimée en degrés Celsius
 
    // Vérification si données bien reçues
    if (isnan(hum) || isnan(temp)) {
    Serial.println("Aucune valeur retournée par le DHT22. Est-il bien branché ?");
    delay(2000);
    return;         // Si aucune valeur n'a été reçue par l'Arduino, on attend 2 secondes, puis on redémarre la fonction loop()
    }
 
    float correction = 0 ;
    tt=(round(temp)-correction);
    hh=round(hum);
    // Check if any reads failed and exit early (to try again).
    if (isnan(tt) || isnan(hh))  {
    Serial.println("Impossible de lire la sonde DHT!");
    return;
    }
 
    Serial.print("Humidite: ");
    Serial.println(hh);
    Serial.print("Temperature: ");
    Serial.println(tt);
 
 
 }
 
//***********************************************************
 void do_vcc()
 
 {
     /*
     float v = vcc.Read_Volts();
     Serial.print("VCC = ");
     Serial.print(v);
     Serial.println(" Volts");
 
     float p = vcc.Read_Perc(VccMin, VccMax);
     pp = round(p);
     Serial.print("VCC = ");
     Serial.print(pp);
     Serial.println(" %");
     delay(2000);
     */
 
    /* Mesure la tension en RAW et la référence interne à 1.1 volts */
    unsigned int raw_vin = analogRead(BROCHE_CAPTEUR_VIN)*VccCorrection;
    unsigned int raw_ref = analogReadReference();
     /* Calcul de la tension réel avec un produit en croix */
    float v = ((raw_vin * 1.1) / raw_ref) * COEFF_PONT_DIVISEUR_VIN;
    Serial.print("VCC = ");
    Serial.print(v);
    Serial.println(" Volts");
 
    float p =((v-VccMin)/(VccEchelle))*100 ;
    pp = round(p);
    if (pp>100){  // max
      pp = 100 ;
    } else if (pp<0) {
      pp = 0 ;  
    }
    Serial.print("VCC = ");
    Serial.print(pp);
    Serial.println(" %");
    delay(2000);
 
 
 }
 
 
 //************************************************************
 /** Mesure la référence interne à 1.1 volts */
unsigned int analogReadReference(void) {
 
  /* Elimine toutes charges résiduelles */
#if defined(__AVR_ATmega328P__)
  ADMUX = 0x4F;
#elif defined(__AVR_ATmega2560__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5F;
#elif defined(__AVR_ATmega32U4__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5F;
#endif
  delayMicroseconds(5);
 
  /* Sélectionne la référence interne à 1.1 volts comme point de mesure, avec comme limite haute VCC */
#if defined(__AVR_ATmega328P__)
  ADMUX = 0x4E;
#elif defined(__AVR_ATmega2560__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5E;
#elif defined(__AVR_ATmega32U4__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5E;
#endif
  delayMicroseconds(200);
 
  /* Active le convertisseur analogique -> numérique */
  ADCSRA |= (1 << ADEN);
 
  /* Lance une conversion analogique -> numérique */
  ADCSRA |= (1 << ADSC);
 
  /* Attend la fin de la conversion */
  while(ADCSRA & (1 << ADSC));
 
  /* Récupère le résultat de la conversion */
  return ADCL | (ADCH << 8);
}

En fonction des éléments données précédement comment devrai-je modifier mon prg ?
comme ceci ?

Code:

1
2
3
4
5
6
7
 
  struct __attribute__ ((packed)) t_message {
  float tt;  // temperature
  float hh; // humidité
  float pp; // VBat
  char kod[10];
} message;

et pour l'adresse

Code:

1
2
 
byte address[][6] = {"1Node", "2Node", "3Node", "4Node", "5Node", "6Node"}; //nombre de tuyaux possibles

je peux laisser çà ?

03/02/2024, 12h10
Jay M

Citation:

et pour l'adresse

le code n'utilise que "2Node" ici en allant chercher la chaîne à l'indice 1

Code:

radio.openWritingPipe(address[1]); //nous sommes le tuyau 0, ouvrons le canal pour la transmission de données

donc ce n'est pas la peine de déclarer les 6 pipes possibles mais ça n'est pas très important

Pour le moment votre code transmet une chaîne de caractère. Si vous décidez d'envoyer une structure, ce sera une communication plus simple si le programme de réception doit utiliser les valeurs.
Si vous ne faites qu'afficher la chaîne reçue sur un écran sans aller extraire les données, alors pas la peine de passer par la structure
03/02/2024, 12h26
cobra38

1 pièce(s) jointe(s)

Citation:

Pour le moment votre code transmet une chaîne de caractère. Si vous décidez d'envoyer une structure, ce sera une communication plus simple si le programme de réception doit utiliser les valeurs.
Si vous ne faites qu'afficher la chaîne reçue sur un écran sans aller extraire les données, alors pas la peine de passer par la structure

Pour le moment je ne souhaite effectivement qu'afficher les valeurs
de T° , Humidité et le niveau batterie
mais j'extrais quand même la chaine qui est envoyée sous la forme par ex "25UTH;224;238;300;"
soit T° = 23°C , Humidité = 33% et Vbat = 100%
03/02/2024, 17h27
Jay M

L’envoi de la structure vous évitera le parsing de la chaîne
04/02/2024, 14h56
cobra38
Désolé Jay M
je n'y arrive pas
j'ai testé l'exemple Emetteur que vous m'avez donné en #20
avec la chaine qui est envoyée sous la forme par ex "25UTH;224;238;300"

Le récepteur en ayant pris soin de modifier l'adresse me donne : "PRET"
je soupçonne que :
Code:

1 2 char payload[30];
n'est pas adapté au type de chaine que j'envoie
alors comment configurer cette chaine qui contient à la fois des caractères et des chiffres telle que décrite

merci encore je suis perdu là !

modifiez la structure pour qu'elle contienne les champs pertinents et une variable globale qui s'appelle message

Code:

1
2
3
4
5
6
  struct __attribute__ ((packed)) t_message {
    char kod[10];
    int16_t tt ;
    int16_t hh ;
    int16_t pp ;
  } message;

vous modifiez alors votre fonction d'envoi pour remplir la structure à partie des vos variables

Code:

1
2
3
4
5
6
7
8
9
10
void send_th(String& kod) // passer un const char * serait plus efficace mais bon... mettez au moins le & pour dire qu'on passe en référence
{
 
  strlcpy(message.kod, kod.c_str(), sizeof message.kod); // on copie le code (au max 9 charactères)
  message.tt = tt + 200;
  message.hh = hh + 200;
  message.pp = pp + 200;
 
  if (!radio.write( &message, sizeof(t_message) )) Serial.println(F("erreur d'envoi"));
}

côté réception vous utilisez le code qui reçoit la structure (bien sûr il faut définir la structure de la même façon dans le code récepteur)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
 
  if (radio.available()) {
    radio.read( &message, sizeof(t_message));
 
    // ici vous avez les champs directement disponibles (tels qu'ils ont étés envoyés)
    // message.kod est le code
    // message.tt est la température
    // message.hh est l'humidité
    // message.pp est la pression
 
    // ==> vous pouvez vous en servir pour constituer l'affichage souhaité 
 
  }

Citation:

modifiez la structure pour qu'elle contienne les champs pertinents et une variable globale qui s'appelle message

Code:

1
2
3
4
5
6
7
 
  struct __attribute__ ((packed)) t_message {
    char kod[10];
    int16_t tt ;
    int16_t hh ;
    int16_t pp ;
  } message;

mais à chaque fois que j'utilise cette structure , la compilation me répond dès que j'utilise les variables hh,tt ou pp :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
D:\5- ELECTRONIQUE\Station Meteo\TEST\NRF24L01\Emetteur_V2\Emetteur_V2.ino: In function 'void send_th(String&)':
Emetteur_V2:132:16: error: 'tt' was not declared in this scope <=========
   message.tt = tt + 200;
                ^~
D:\5- ELECTRONIQUE\Station Meteo\TEST\NRF24L01\Emetteur_V2\Emetteur_V2.ino:132:16: note: suggested alternative: 'dhtt'
   message.tt = tt + 200;
                ^~
                dhtt
Emetteur_V2:133:16: error: 'hh' was not declared in this scope  <<===========
   message.hh = hh + 200;
                ^~
D:\5- ELECTRONIQUE\Station Meteo\TEST\NRF24L01\Emetteur_V2\Emetteur_V2.ino:133:16: note: suggested alternative: 'dhth'
   message.hh = hh + 200;
                ^~
                dhth
Emetteur_V2:134:16: error: 'pp' was not declared in this scope  <========
   message.pp = pp + 200;
                ^~
exit status 1
'tt' was not declared in this scope

pourtant ces variables sont bien déclarées initialement dans la structure (t_message) ?
qu'ai-je fait de mal ?

Décidement je ne suis pas doué

rien ne fonctionne , je n'arrive pas compiler la partie Emetteur
et quand j'arrive , il n'envoie rien
je mets le croquis

Code:

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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
 
#define DEBUG
#include <Adafruit_Sensor.h>
 
/////// DHT22 //////////////////////////////////////////
#include <DHT.h>
#define brocheDeBranchementDHT 3    // La ligne de communication du DHT22 sera donc branchée sur la pin D3 de l'Arduino
#define typeDeDHT DHT22
DHT dht(brocheDeBranchementDHT, typeDeDHT);
float dhtt,dhth;
unsigned long previousMillis = 0; // stockera la dernière température lue
const long interval = 2000; // intervalle auquel lire le capteur
 
/////////////////////////////////////////////////////////////////////////
#include <SPI.h>          // bibliothèque pour le fonctionnement du bus SPI
#include "nRF24L01.h"     // bibliothèque de modules radio
#include "RF24.h"         // plus de bibliothèque de modules radio
#include "LowPower.h"
 
//byte address[][6] = {"1Node", "2Node", "3Node", "4Node", "5Node", "6Node"}; //nombre de tuyaux possibles
uint8_t adresse[] = {0xCC, 0xCE, 0xCC, 0xCE, 0xCC};
RF24 radio(7, 8);   // "créer" un module sur les broches 9 et 10 pour Mini Pro
 
 
//************************************************************************************************
const float VccMin   = 3.2;           // Niveau minimum attendu de Vcc, en Volts.
const float VccMax   = 4.2;           // Niveau maximum attendu de Vcc, en Volts.
const float VccCorrection = 0.99;  // Vcc mesuré par le multimètre divisé par le Vcc rapporté
const float VccEchelle = VccMax - VccMin;  // Vcc mesuré par le multimètre divisé par le Vcc rapporté
//Vcc vcc(VccCorrection);
 
 
const byte BROCHE_CAPTEUR_VIN = A0;
const float COEFF_PONT_DIVISEUR_VIN = 4.0;
 
struct __attribute__ ((packed)) t_message {
   char kod [4];
   int16_t tt ;
   int16_t hh ;
   int16_t pp ;
} message;
 
//************************************************
int16_t tt ;
int16_t hh ;
int16_t pp ;
char kod [4]="ENV" ; // Outdoor Temp et Humidite
//***********************************************
 
//--------------------------------------------------
// SETUP
//--------------------------------------------------
void setup()
{
 
  Serial.begin(115200);  
  dht.begin(); // Connect DHT sensor D3 
  ///////////////////////////////////////////////
  radio.begin(); //activer le module
  radio.setAutoAck(0);           // mode d'accusé de réception, 1 on 0 off
  radio.setRetries(0, 15);     //(délai entre les tentatives d'accès, nombre de tentatives)
  radio.enableAckPayload();    //activation de l'envoi de données en réponse à un signal entrant
  radio.setPayloadSize(32);      //taille du paquet, en octets
  radio.openWritingPipe(adresse);   //nous sommes le tuyau 0, ouvrons le canal pour la transmission de données
  radio.setChannel(0x60);          //sélectionner le canal (dans lequel il n'y a pas de bruit !)
 
  radio.setPALevel (RF24_PA_LOW);    //niveau de puissance de l'émetteur. Sélectionnable RF24_PA_MIN, RF24_PA_LOW, RF24_PA_HIGH, RF24_PA_MAX
  //radio.setDataRate (RF24_250KBPS); //taux de change. Sélectionnable RF24_2MBPS, RF24_1MBPS, RF24_250KBPS
  // doit être le même sur le récepteur et l'émetteur !// doit être le même sur le récepteur et l'émetteur !
  //à la vitesse la plus basse ont la sensibilité et la portée les plus élevées ! !!
 
  radio.powerUp();         //démarrer le travail
  radio.stopListening();  //pas d'écoute des ondes, nous sommes un émetteur
 
}
 
//-----------------------------------------------
// LOOP
//-----------------------------------------------
void loop()
{
  do_read_dht();
  do_vcc();
 
  for (int i=0; i <= 30; i++)
  {
    /*
    if (i<25)
    {
      if (tt!=-127)
      {
        send_th("ENV");
      }else{
        send_th("ERR");
      }
    }else{
       send_th("END");
      
      delay(150);
    }
    */
    send_th(String(kod));
    delay(150);
  }
  delay(2000);
 
 
  ////// avant de dormir
  byte etatSPI = SPCR;
  SPCR = 0;
  digitalWrite(13,LOW);
 
  ////////////////////////////////////////////////
  for (int i = 0; i < 1 ; i++) { // 30mn de sommeil // 
     LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
  } 
  ////  on remet l'état
  SPCR = etatSPI;
 
}
 
//*************************************************************
void send_th(String& kod) // passer un const char * serait plus efficace mais bon... mettez au moins le & pour dire qu'on passe en référence
{
  strlcpy(message.kod, kod.c_str(), sizeof message.kod); // on copie le code (au max 9 charactères)
  message.tt = tt + 200;
  message.hh = hh + 200;
  message.pp = pp + 200;
 
  if (!radio.write( &message, sizeof(t_message) )) Serial.println(F("erreur d'envoi"));
}
 
void do_read_dht()
 { 
 
    dhtt = round(dht.readTemperature());   // Lecture de la température, exprimée en degrés Celsius
    dhth = round(dht.readHumidity());              // Lecture du taux d'humidité (en %)
 
    if (isnan(dhtt) || isnan(dhth)) {
      Serial.println("Aucune valeur retournée par le DHT22. Est-il bien branché ?");
      delay(2000);
    return;         // Si aucune valeur n'a été reçue par l'Arduino, on attend 2 secondes, puis on redémarre la fonction loop()
    }
 
    //float correction = 0 ;
    tt= dhtt;
    hh= dhth;
 
    Serial.print("Humidite: ");
    Serial.println(hh);
    Serial.print("Temperature: ");
    Serial.println(tt);
 
 }
 
//***********************************************************
 void do_vcc()
 {
    /* Mesure la tension en RAW et la référence interne à 1.1 volts */
    unsigned int raw_vin = analogRead(BROCHE_CAPTEUR_VIN)*VccCorrection;
    unsigned int raw_ref = analogReadReference();
     /* Calcul de la tension réel avec un produit en croix */
    float v = ((raw_vin * 1.1) / raw_ref) * COEFF_PONT_DIVISEUR_VIN;
    Serial.print("VCC = ");
    Serial.print(v);
    Serial.println(" Volts");
 
    float p =((v-VccMin)/(VccEchelle))*100 ;
    int16_t pp = round(p);
    if (pp>100){  // max
      pp = 100 ;
    } else if (pp<0) {
      pp = 0 ;  
    }
    Serial.print("VCC = ");
    Serial.print(pp);
    Serial.println(" %");
    delay(2000);
 
  }
 
 
 //************************************************************
 /** Mesure la référence interne à 1.1 volts */
unsigned int analogReadReference(void) {
 
  /* Elimine toutes charges résiduelles */
#if defined(__AVR_ATmega328P__)
  ADMUX = 0x4F;
#elif defined(__AVR_ATmega2560__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5F;
#elif defined(__AVR_ATmega32U4__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5F;
#endif
  delayMicroseconds(5);
 
  /* Sélectionne la référence interne à 1.1 volts comme point de mesure, avec comme limite haute VCC */
#if defined(__AVR_ATmega328P__)
  ADMUX = 0x4E;
#elif defined(__AVR_ATmega2560__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5E;
#elif defined(__AVR_ATmega32U4__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5E;
#endif
  delayMicroseconds(200);
 
  /* Active le convertisseur analogique -> numérique */
  ADCSRA |= (1 << ADEN);
 
  /* Lance une conversion analogique -> numérique */
  ADCSRA |= (1 << ADSC);
 
  /* Attend la fin de la conversion */
  while(ADCSRA & (1 << ADSC));
 
  /* Récupère le résultat de la conversion */
  return ADCL | (ADCH << 8);
}

je suis bloqué sur les variables "hh","tt" et "pp" que j'ai du déclarer en double
puis ensuite sur la conversion "kod" qu'il me refuse dès que je veux mettre des caractères comme par ex :"ENV"

Citation:

cannot bind non-const lvalue reference of type 'String&' to an rvalue of type 'String'

04/02/2024, 19h22
edgarjacobs
kod, tt, hh et pp sont des membres de la structure message (qui est de type struct t_message).
Pour utiliser un membre de la structure, il faut toujours indiquer le nom de la structure auquel il appartient:
Code:

1 2 message.tt = message.tt + 20; strcpy(message.kod, "Hello");
04/02/2024, 19h43
Jay M
mon code supposait que votre code précédent fonctionnait

la fonction send_th() a été juste modifiée pour remplir la structure au lieu de bâtir la chaîne de caractères, c'est tout. Donc si ça fonctionnait avant, ça devrait fonctionner maintenant avec juste cette modification sur la fonction d'envoi et la déclaration du type de la structure et la variable message.

Citation:

Envoyé par cobra38

puis ensuite sur la conversion "kod" qu'il me refuse dès que je veux mettre des caractères comme par ex :"ENV"

ah j'avais pas vu que vous ne passiez pas toujours une String mais parfois un literal

enlevez le & que j'avais rajouté au niveau du paramètre
Code:

1 2 3 4 void send_th(String kod) { ... }

2 pièce(s) jointe(s)

Grâce votre aide et vous en remercie , je progresse doucement
l'Emetteur semble fonctionner avec ce croquis

Code:

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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
 
#define DEBUG
#include <Adafruit_Sensor.h>
 
/////// DHT22 //////////////////////////////////////////
#include <DHT.h>
#define brocheDeBranchementDHT 3    // La ligne de communication du DHT22 sera donc branchée sur la pin D3 de l'Arduino
#define typeDeDHT DHT22
DHT dht(brocheDeBranchementDHT, typeDeDHT);
float dhtt,dhth;
unsigned long previousMillis = 0; // stockera la dernière température lue
const long interval = 2000; // intervalle auquel lire le capteur
 
/////////////////////////////////////////////////////////////////////////
#include <SPI.h>          // bibliothèque pour le fonctionnement du bus SPI
#include "nRF24L01.h"     // bibliothèque de modules radio
#include "RF24.h"         // plus de bibliothèque de modules radio
#include "LowPower.h"
 
//byte address[][6] = {"1Node", "2Node", "3Node", "4Node", "5Node", "6Node"}; //nombre de tuyaux possibles
uint8_t adresse[] = {0xCC, 0xCE, 0xCC, 0xCE, 0xCC};
RF24 radio(7, 8);   // "créer" un module sur les broches 9 et 10 pour Mini Pro
 
 
//************************************************************************************************
const float VccMin   = 3.2;           // Niveau minimum attendu de Vcc, en Volts.
const float VccMax   = 4.2;           // Niveau maximum attendu de Vcc, en Volts.
const float VccCorrection = 0.99;  // Vcc mesuré par le multimètre divisé par le Vcc rapporté
const float VccEchelle = VccMax - VccMin;  // Vcc mesuré par le multimètre divisé par le Vcc rapporté
//Vcc vcc(VccCorrection);
 
 
const byte BROCHE_CAPTEUR_VIN = A0;
const float COEFF_PONT_DIVISEUR_VIN = 4.0;
 
struct __attribute__ ((packed)) t_message {
   char kod [4];
   int16_t tt ;
   int16_t hh ;
   int16_t pp ;
} message;
 
//************************************************
 
//***********************************************
 
//--------------------------------------------------
// SETUP
//--------------------------------------------------
void setup()
{
 
  Serial.begin(115200);  
  dht.begin(); // Connect DHT sensor D3 
  ///////////////////////////////////////////////
  radio.begin(); //activer le module
  radio.setAutoAck(0);           // mode d'accusé de réception, 1 on 0 off
  radio.setRetries(0, 15);     //(délai entre les tentatives d'accès, nombre de tentatives)
  radio.enableAckPayload();    //activation de l'envoi de données en réponse à un signal entrant
  radio.setPayloadSize(32);      //taille du paquet, en octets
  radio.openWritingPipe(adresse);   //nous sommes le tuyau 0, ouvrons le canal pour la transmission de données
  radio.setChannel(0x60);          //sélectionner le canal (dans lequel il n'y a pas de bruit !)
  radio.setPALevel (RF24_PA_LOW);    //niveau de puissance de l'émetteur. Sélectionnable RF24_PA_MIN, RF24_PA_LOW, RF24_PA_HIGH, RF24_PA_MAX
  //radio.setDataRate (RF24_250KBPS); //taux de change. Sélectionnable RF24_2MBPS, RF24_1MBPS, RF24_250KBPS
   radio.powerUp();         //démarrer le travail
  radio.stopListening();  //pas d'écoute des ondes, nous sommes un émetteur
 
}
 
//-----------------------------------------------
// LOOP
//-----------------------------------------------
void loop()
{
  do_read_dht();
  do_vcc();
 
  for (int i=0; i <= 30; i++)
  {
    if (i<25)
    {
      if (message.tt!=-127)
      {
         strcpy(message.kod, "ENV");
         send_th(String(message.kod));
 
      }else{
        strcpy(message.kod, "ERR");
        send_th(String(message.kod));
        send_th("ERR");
      }
    }else{
       strcpy(message.kod, "END");
       send_th(String(message.kod));
       send_th("END");
       delay(150);
    }
  }
  delay(2000);
 
  ////// avant de dormir
  byte etatSPI = SPCR;
  SPCR = 0;
  digitalWrite(13,LOW);
 
  ////////////////////////////////////////////////
  for (int i = 0; i < 1 ; i++) { // 30mn de sommeil // 
     LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
  } 
  ////  on remet l'état
  SPCR = etatSPI;
 
}
 
//*************************************************************
void send_th(String kod) //
{
  strlcpy(message.kod, kod.c_str(), sizeof message.kod); // on copie le code (au max 9 charactères)
  message.tt; 
  message.hh; 
  message.pp; 
  Serial.print("Message: ");
  Serial.print(message.kod);Serial.print(message.tt);Serial.print(message.hh);Serial.print(message.pp);
  Serial.println();
  if (!radio.write( &message, sizeof(t_message) )) Serial.println(F("erreur d'envoi"));
}
 
void do_read_dht()
 { 
 
    dhtt = round(dht.readTemperature());   // Lecture de la température, exprimée en degrés Celsius
    dhth = round(dht.readHumidity());              // Lecture du taux d'humidité (en %)
 
    if (isnan(dhtt) || isnan(dhth)) {
      Serial.println("Aucune valeur retournée par le DHT22. Est-il bien branché ?");
      delay(2000);
    return;         // Si aucune valeur n'a été reçue par l'Arduino, on attend 2 secondes, puis on redémarre la fonction loop()
    }
 
    //float correction = 0 ;
    message.tt= dhtt +200;
    message.hh= dhth +200;
 
    Serial.print("Humidite: ");
    Serial.println(dhtt);
    Serial.print("Temperature: ");
    Serial.println(dhth);
 
 }
 
//***********************************************************
 void do_vcc()
 {
    /* Mesure la tension en RAW et la référence interne à 1.1 volts */
    unsigned int raw_vin = analogRead(BROCHE_CAPTEUR_VIN)*VccCorrection;
    unsigned int raw_ref = analogReadReference();
     /* Calcul de la tension réel avec un produit en croix */
    float v = ((raw_vin * 1.1) / raw_ref) * COEFF_PONT_DIVISEUR_VIN;
    Serial.print("VCC = ");
    Serial.print(v);
    Serial.println(" Volts");
 
    float p =round(((v-VccMin)/(VccEchelle))*100) ;
    message.pp = p + 200;
    if (p > 100){  // max
     message.pp = 300 ;
    } else if (message.pp<0) {
      message.pp = 0 ;  
    }
    Serial.print("VCC = ");
    Serial.print(p);
    Serial.println(" %");
    delay(2000);
 
  }
 
 
 //************************************************************
 /** Mesure la référence interne à 1.1 volts */
unsigned int analogReadReference(void) {
 
  /* Elimine toutes charges résiduelles */
#if defined(__AVR_ATmega328P__)
  ADMUX = 0x4F;
#elif defined(__AVR_ATmega2560__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5F;
#elif defined(__AVR_ATmega32U4__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5F;
#endif
  delayMicroseconds(5);
 
  /* Sélectionne la référence interne à 1.1 volts comme point de mesure, avec comme limite haute VCC */
#if defined(__AVR_ATmega328P__)
  ADMUX = 0x4E;
#elif defined(__AVR_ATmega2560__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5E;
#elif defined(__AVR_ATmega32U4__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5E;
#endif
  delayMicroseconds(200);
 
  /* Active le convertisseur analogique -> numérique */
  ADCSRA |= (1 << ADEN);
 
  /* Lance une conversion analogique -> numérique */
  ADCSRA |= (1 << ADSC);
 
  /* Attend la fin de la conversion */
  while(ADCSRA & (1 << ADSC));
 
  /* Récupère le résultat de la conversion */
  return ADCL | (ADCH << 8);
}

par contre pour le Récepteur même appliquant les modifications de traitement et d'adresse ( j'ai changé aussi d'UC; Nano , Wemos et maintenant Uno )
çà ne fonctionne la réponse est toujours identique

voici le croquis actuel pour avis :

Code:

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
 
// RECEPTEUR
#include <SPI.h>          // bibliothèque pour le fonctionnement du bus SPI
#include "nRF24L01.h"     // bibliothèque de modules radio
#include "RF24.h"         // plus de bibliothèque de modules radio
 
RF24 radio(7, 8);
 
uint8_t adresse[] = {0xCC, 0xCE, 0xCC, 0xCE, 0xCC};
struct __attribute__ ((packed)) t_message {
    char kod[4];
    int16_t tt ;
    int16_t hh ;
    int16_t pp ;
} message;
 
void setup() {
  Serial.begin(115200);
  Serial.println(F("Init"));
  if (!radio.begin()) {
    Serial.println(F("erreur !!"));
    while (true) ;
  }
  radio.setPALevel(RF24_PA_LOW);
  radio.setDataRate (RF24_250KBPS); //taux de change. Sélectionnable RF24_2MBPS, RF24_1MBPS, RF24_250KBPS
  radio.setPayloadSize(sizeof(t_message));
  radio.openReadingPipe(1, adresse);
  radio.startListening();
  Serial.println(F("PRET"));
}
 
void loop() {
  if (radio.available())
  {
    radio.read(&message, sizeof(t_message));
    Serial.print("Message = "); 
  }
  delay(1000);
}

dans l'émetteur pourquoi vous n'affectez pas les valeurs aux champs tt, hh et pp?? les 3 lignes ne servent absolument à rien telles qu'elles sont écrites.

Code:

1
2
3
4
 strlcpy(message.kod, kod.c_str(), sizeof message.kod); // on copie le code (au max 9 charactères)
  message.tt; 
  message.hh; 
  message.pp;

la fonction devrait être

Code:

1
2
3
4
5
6
7
8
9
10
11
void send_th(String kod)
{
 
  strlcpy(message.kod, kod.c_str(), sizeof message.kod); // on copie le code (au max 9 charactères)
  message.tt = tt + 200;
  message.hh = hh + 200;
  message.pp = pp + 200;
 
  if (!radio.write( &message, sizeof(t_message) )) Serial.println(F("erreur d'envoi"));
  else Serial.println(F("Message envoyé"));
}

vous dites

Citation:

j'ai changé aussi d'UC; Nano , Wemos et maintenant Uno

avez vous validé avec le petit code que je vous avais donné que le montage était fonctionnel?

si le montage avec le code de test est fonctionnel alors côté réception mettez ce code:

Code:

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
// RECEPTEUR
#include <RF24.h>
 
const byte CEPin = 8;
const byte CSNPin = 7;
RF24 radio(CEPin, CSNPin);
 
uint8_t adresse[] = {0xCC, 0xCE, 0xCC, 0xCE, 0xCC};
 
struct __attribute__ ((packed)) t_message {
  char kod[4];
  int16_t tt ;
  int16_t hh ;
  int16_t pp ;
} message;
 
void setup() {
  Serial.begin(115200);
 
  if (!radio.begin()) {
    Serial.println(F("erreur !!"));
    while (true) ;
  }
 
  radio.setPALevel(RF24_PA_LOW);
  radio.setPayloadSize(sizeof(t_message));
  radio.openReadingPipe(1, adresse);
  radio.startListening();
  Serial.println(F("PRET"));
}
 
void loop() {
  if (radio.available()) {
    radio.read( &message, sizeof(t_message));
    Serial.print("Message = Kod:");
    Serial.print(message.kod);
    Serial.print("\ttt:");
    Serial.print(message.tt);
    Serial.print("\thh:");
    Serial.print(message.hh);
    Serial.print("\tpp:");
    Serial.println(message.pp);
  }
}

05/02/2024, 11h51
cobra38

2 pièce(s) jointe(s)

Citation:

dans l'émetteur pourquoi vous n'affectez pas les valeurs aux champs tt, hh et pp?? les 3 lignes ne servent absolument à rien telles qu'elles sont écrites.

comme je l'ai expliqué en#29 , je ne pouvais pas cela car je ne pouvais pas compiler
il réclamait une déclaration pour les variables tt , hh et pp
j'ai donc du à chaque fois changer, comme m'a conseillé edgarjacobs ,
faire : message.tt = message.tt + 200;
en lieu et place de : message.tt = tt + 200;

d'autre part le fait de mettre : message.tt = message.tt + 200; incrémente les mesures de 200 dans une boucle x 30 fois
or il s'agit simplement d'incrémenter 1 fois de 200 , c'est pourquoi je l'ai dissocié de :
void send_th()

Citation:

si le montage avec le code de test est fonctionnel alors côté réception mettez ce code:

le problème reste identique , j'ai l'impression que l'emetteur n'envoie rien
05/02/2024, 12h34
Jay M
Citation:

comme je l'ai expliqué en#29 , je ne pouvais pas cela car je ne pouvais pas compiler
il réclamait une déclaration pour les variables tt , hh et pp

mais dans votre post d'origine vous aviez bien ces variables en global
Code:

1 2 3 4 5 //************************************************* int tt ; int hh ; int pp ; String kod="25UTH;"; // Outdoor Temp et Humidite
donc si ce code ancien compilait, tt, hh, et pp sont connues...

-----

est-ce que votre montage hardware est fonctionnel avec le petit bout de code de test que j'avais donné ? tant que ça ne fonctionne pas, ce n'est pas la peine de vous pencher sur votre code

2 pièce(s) jointe(s)

Bonjour à tous
je me retrouve dans une impasse
j'ai mis en cause le hardware et j'ai donc changé les nRF24L01
mais le problème persiste
j'utilise actuellement ce croquis de test :

Code:

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
 
// EMETTEUR
#include "SPI.h"
#include "nRF24L01.h"
#include "RF24.h"
 
 
const byte CEPin = 16;
const byte CSNPin = 2;
RF24 radio(4,15);
 
uint8_t adresse[] = {0xCC, 0xCE, 0xCC, 0xCE, 0xCC};
 
struct __attribute__ ((packed)) t_message {
  char payload[32];
} message;
 
void setup() {
  Serial.begin(9600);
 
  if (!radio.begin()) {
    Serial.println(F("erreur !!"));
    while (true) ; 
  }
 
  radio.setPALevel(RF24_PA_LOW);
  radio.setPayloadSize(sizeof(t_message));
  radio.openWritingPipe(adresse);
  strcpy(message.payload, "Hello, world");
  //radio.stopListening();
  Serial.println(F("PRET"));
}
 
void loop() {
  if (!radio.write( &message, sizeof(t_message) ))
    Serial.println(F("erreur d'envoi"));
  else
    Serial.println(message.payload);
 
  delay(1000);
}

avec Wemos + nRF24L01
le résultat est :

je suis preneur de vos conseils
merci encore ...................:oops:

07/02/2024, 16h11
Jay M
Citation:
Envoyé par cobra38

...

Code:

1 2 3 4 5 6 7 8 9 10 // EMETTEUR #include "SPI.h" #include "nRF24L01.h" #include "RF24.h" const byte CEPin = 16; const byte CSNPin = 2; RF24 radio(4,15); ...
dans votre montage vous utilisez

D2 ---> CE
D8 ---> CSN
D7 ---> MOSI
D6 ---> MISO
D5 ---> SCK

Dans le code Arduino avec votre wemos, utilisez la notation avec les D devant le N° de pin pour être sûr d'avoir la bonne
07/02/2024, 17h38
cobra38
Merci Jay M

Citation:

Dans le code Arduino avec votre wemos, utilisez la notation avec les D devant le N° de pin pour être sûr d'avoir la bonne

je l'ai fait pour essai ensuite
Code:

1 2 RF24 radio(D2,D8);
mais rien ne change ....j'ai pourtant tout changé
fils ,cablage en direct, cablage avec ou sans adaptateur, Nano => Wemos , NfR24L01 rachetés
07/02/2024, 19h01
Jay M

est-ce que vous savez si la pin 3.3V des wemos donne assez de courant ?

je n'ai jamais essayé ce genre de config (le wemos ayant le WiFi, j'utilise cela pour la communication sans fil)

Voir 40 message(s) de cette discussion en une page