Discussion :

[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 :

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

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 ?

[Jay M]

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)

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 :

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

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é

[cobra38]

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 :

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
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 :

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

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 :

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

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

je peux laisser çà ?

[Jay M]

et pour l'adresse

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

Code :

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

  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

[cobra38]

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%

[Jay M]

L’envoi de la structure vous évitera le parsing de la chaîne

[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 :

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

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à !

[Jay M]

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

Code :

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

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 :

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

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 :

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

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é 
 
  }

[cobra38]

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

Code :

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

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 :

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
 
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 ?

[cobra38]

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 :

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
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"

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

[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 :

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

1
2
message.tt = message.tt + 20;
strcpy(message.kod, "Hello");

[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.

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 :

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

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

[cobra38]

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

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
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 :

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
 
// 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);
}

[Jay M]

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 :

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

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 :

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

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

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 :

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
// 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);
  }
}

[cobra38]

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()

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

[Jay M]

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 :

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

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

[cobra38]

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 :

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
 
// 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 ...................

[Jay M]

...

Code :

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

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

[cobra38]

Merci Jay M

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 :

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

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

[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)