Discussion :

[Jay M]

parce qu'actuellement j'ai mon ancien boitier qui émet des valeurs identiques sous la forme => 25UHT;200;200;200 ( voir pb évoqué ci-dessus)
et je pensais initialement "récupérer" cette chaîne de caractères en lisant la valeur de "data" et ainsi ne pas refaire le boitier , c'est purement pratique

data est une structure binaire, vous avez la représentation des 3 floats (12 octets), vous n'avez pas une représentation textuelle mais vous pouvez la créer

si vous voulez des valeurs entières:

Code :

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

1
2
char messageTexte [50]; // assurez vous que la taille soit assez grande
snprintf(messageTexte, sizeof messageTexte, "25UHT;%d;%d;%d", (int) data.temperature, (int) data. humidity, (int) data.bat);

si vous voulez les valeurs en nombre à virgules, sur Uno sprintf ne sait pas le gérer, il faut utiliser d'autres fonctions mais sur ESP ça fonctionne

[cobra38]

j'ai tenté de faire ceci :

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
 
void checkForWirelessData()
{
  if ( radio.available())
  {
    while (radio.available())
    {
       radio.read( &data, sizeof(data) );
       char message [50]; // assurez vous que la taille soit assez grande
       sprintf(message, sizeof(message), "25UHT;%d;%d;%d", (int) data.temperature, (int) data. humidity, (int) data.bat);
    }
    Serial.print("\nPackage:");
    Serial.print("\n");
    Serial.println(data.temperature);
    Serial.println(data.humidity);
    Serial.println(data.bat);
  }
}

mais la reponse a été très rapide ....
mais je n'ai du comprendre l'astuce

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
....\RECEPTEUR_V2.ino: In function 'void checkForWirelessData()':
RECEPTEUR_V2:67:25: error: invalid conversion from 'unsigned int' to 'const char*' [-fpermissive]
   67 |        sprintf(message, sizeof(message), "25UHT;%d;%d;%d", (int) data.temperature, (int) data. humidity, (int) data.bat);
      |                         ^~~~~~~~~~~~~~~
      |                         |
      |                         unsigned int
In file included from C:\Users\Utilisateur\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\3.1.2\cores\esp8266/Arduino.h:32,
                 from sketch\RECEPTEUR_V2.ino.cpp:1:
c:\users\utilisateur\appdata\local\arduino15\packages\esp8266\tools\xtensa-lx106-elf-gcc\3.1.0-gcc10.3-e5f9fec\xtensa-lx106-elf\include\stdio.h:244:32: note:   initializing argument 2 of 'int sprintf(char*, const char*, ...)'
  244 | int sprintf (char *__restrict, const char *__restrict, ...)
      |                                ^~~~~~~~~~~~
exit status 1
invalid conversion from 'unsigned int' to 'const char*' [-fpermissive]

[Jay M]

le Wemos n'est plus utilisé ?

[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

[Jay M]

ça a l'air de fonctionner non ?

[cobra38]

ça a l'air de fonctionner non ?

Oui effectivement
il ne reste plus qu'à utiliser les datas sous la forme :
unpackage.temperature = int temp_v
par ex

il me restera à tester :
- le mode sommeil du Pro Mini ( Emetteur) , sa consommation en base (hors émission) est de 8mA actuellement beaucoup donc trop élevée
( des conseils me seraient utiles sur ce point )
- la synchronisation entre le Récepteur et l'Emetteur à savoir comment gérer l'affichage du récepteur sachant l'émetteur envoie ses données toutes les 1/2 heures

en tout cas encore merci pour votre patience ...

[cobra38]

Bonjour à tous

j'ai complété mon montage de l’Émetteur en y associant pour des raisons de consommation
un TPL5110 qui est une minuterie déclenchée par l'entrée A1 de l'Arduino Pro mini
celle-ci est réglée pour un périodicité de 30s env (en phase de test )

j'ai pu constater que le Récepteur lui indique les "datas" reçus de façon aléatoire ou reste muet ( il est placé à 2 m)
malgré que je constate bien le fonctionnement de l'Emetteur

ma question est la suivante :
faut-il un laps de temps minimal pour permettre l'envoi correct des datas ?

Pour mémoire je remets la dernière version de l'Emetteur 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
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
 
#include <nRF24L01.h>
#include <RF24.h>
#include <RF24_config.h>
#include <DHT.h>
#include <Wire.h>
#include <SPI.h>
#include <Adafruit_Sensor.h>
#include "LowPower.h"
 
// DHT22
#define DHTPIN 3     // DHT22 PIN
#define DHTTYPE DHT22   // DHT 22
DHT dht(DHTPIN, DHTTYPE); // Initialize DHT sensor for 16mhz
 
//DHT22 Variables
int chk;
float dht22_hum;  //Stores humidity value
float dht22_temp; //Stores temperature value
 
//TP5110
#define DONEPIN A1
 
//VBat
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 = 1;  // 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é
const byte BROCHE_CAPTEUR_VIN = A0;
const float COEFF_PONT_DIVISEUR_VIN = 4.0;
float bat_value;
 
//NRF24L01
const int pinCE = 8;
const int pinCSN = 7;
RF24 radio(pinCE, pinCSN);
byte addresses[][6] = {"0"};
const uint64_t pipe = 0xE8E8F0F0E1LL;
struct package
{
  float temperature ;
  float humidity;
  float bat;
};
typedef struct package Package;
Package data;
 
/// SETUP ////////////////////////////////////
void setup()
{
  pinMode(DONEPIN, OUTPUT);
  digitalWrite(DONEPIN, LOW);
  Serial.begin(115200);
  radio.begin();
  radio.setChannel(115);
  radio.setPALevel(RF24_PA_MAX);
  radio.setDataRate( RF24_250KBPS ) ;
  radio.openWritingPipe( addresses[0]);
  delay(1000);
  dht.begin();
 
}
 
/// LOOP /////////////////////////////////////
void loop()
{
  do_vcc();
  dht22_hum = dht.readHumidity();
  dht22_temp = dht.readTemperature();
  /*
  Serial.print("--- Veranda ---\n");
  Serial.print("Temperature = ");
  Serial.print(dht22_temp);
  Serial.println(" ºC");
  Serial.print("Humidity = ");
  Serial.print(dht22_hum);
  Serial.println(" %");
  Serial.print("Bat = ");
  Serial.print(bat_value);
  Serial.println(" %");
  Serial.print("--------------------------------\n\n");
  delay(1000);
  */
  readSensor();
  radio.write(&data, sizeof(data));
  done();
 
}
 
void done()
{
  // bascule FAIT pour que TPL sache qu'il faut couper l'électricité !
  while (1) {
   digitalWrite(DONEPIN, HIGH);
   delay(1);
   digitalWrite(DONEPIN, LOW);
   delay(1);
  }
}
 
/** Lecture DHT22 *********************/ 
void readSensor()
{
  data.humidity = round(dht.readHumidity())+200;
  data.temperature = round(dht.readTemperature())+200;
  data.bat = round(bat_value)+200;
}
 
//***********************************************************
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 ;
    if (p>100){  // max
      p = 100;
    } else if ( p<0) {
      p = 0;  
    }
    bat_value = p;
    //bat_value = 50.00; // valeur de test
    delay(1000);
}
 
 /** 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);
}

Encore merci

[Jay M]

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

photo du montage?

[cobra38]

Voici Jay M:
(merci encore)

Emetteur :

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

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

[Jay M]

si vous enlevez le TPL5110 est-ce que la communication est stable ?

[cobra38]

si vous enlevez le TPL5110 est-ce que la communication est stable ?

Oui , je n'ai pas de problème particulier

mais avec le TPL5110 , il y a une durée de mise sous tension, je suppose , et donc un temps minimal avant d'envoyer les datas ?

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

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

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

donc quand vous faites

Code :

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

    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 :

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

char message[50];

[cobra38]

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 :

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

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.

[Jay M]

oui peut-être attendre que tout soit bien alimenté

[cobra38]

Bonjour Jay M


pour éviter les défauts de connexion , j'ai fait un "PCB" sur une carte proto pour l'émetteur
la périodicité d'envoi des datas est de :
1 envoi toutes les minutes avec une durée d'env 5s

le récepteur m'indique quelques "trous" et une perte d'infos température et humidité que je ne m'explique pas
comme le montre l'image ci-dessous mais globalement çà s'améliore...

[Jay M]

essayez avec ces code

EMETTEUR

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

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

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

pouvez vous reposter les 2 codes ?

[cobra38]

RECEPTEUR :

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
 
#include <nRF24L01.h>
#include <RF24.h>
#include <RF24_config.h>
#include <SPI.h>
 
/*
// trans package
struct package
{
  float temperature;
  float humidity;
  float bat;
};
*/
 
// radio
RF24 radio(4, 15);
byte addresses[][6] = {"0"};
 
struct __attribute__((packed)) package // Package et le nom du type
{
  float temperature;
  float humidity;
  float bat;
};
 
package unpackage; // ici on crée une instance de la structure
 
/*** SETUP ***********************/
void setup(void) {
  // serial
  Serial.begin(115200);
  // radio
  startWirelessCommunication();
}
 
/*** LOOP **************************/
void loop(void) {
  checkForWirelessData();
}
 
/***********************************/
void startWirelessCommunication()
{
  radio.begin();
  radio.setChannel(115);
  radio.setPALevel(RF24_PA_LOW); // <=== initialement à PA_MAX pour essais 
  radio.setDataRate( RF24_250KBPS ) ;
  radio.openReadingPipe(1, addresses[0]);
  radio.startListening();
  delay(100);
}
 
/**********************************/
void checkForWirelessData()
{
  if ( radio.available())
  {
    while (radio.available())
    {
      radio.read(&unpackage, sizeof( unpackage) );
    }
    char message [50]; // assurez vous que la taille soit assez grande
    snprintf( message , sizeof(message), "25UHT;%d;%d;%d", (int)  unpackage.temperature, (int)  unpackage. humidity, (int) unpackage.bat);
 
    Serial.print("\nMessage:");
    Serial.print(message);
    Serial.print("\nPackage:");
    Serial.print("\n");
    /*
    Serial.println(data.temperature);
    Serial.println(data.humidity);
    Serial.println(data.bat);
    */
    Serial.println( unpackage.temperature);
    Serial.println( unpackage.humidity);
    Serial.println( unpackage.bat);
  }
}

EMETTEUR

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
 
#include <nRF24L01.h>
#include <RF24.h>
#include <RF24_config.h>
#include <DHT.h>
#include <Wire.h>
#include <SPI.h>
#include <Adafruit_Sensor.h>
#include "LowPower.h"
 
// DHT22
#define DHTPIN 3     // DHT22 PIN
#define DHTTYPE DHT22   // DHT 22
DHT dht(DHTPIN, DHTTYPE); // Initialize DHT sensor for 16mhz
 
//DHT22 Variables
int chk;
float dht22_hum;  //Stores humidity value
float dht22_temp; //Stores temperature value
 
//TP5110
#define DONEPIN A1
 
//VBat
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 = 1;  // 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é
const byte BROCHE_CAPTEUR_VIN = A0;
const float COEFF_PONT_DIVISEUR_VIN = 4.0;
float bat_value;
 
//NRF24L01
const int pinCE = 8;
const int pinCSN = 7;
RF24 radio(pinCE, pinCSN);
byte addresses[][6] = {"0"};
const uint64_t pipe = 0xE8E8F0F0E1LL;
struct package
{
  float temperature ;
  float humidity;
  float bat;
};
typedef struct package Package;
Package data;
 
/// SETUP ////////////////////////////////////
void setup()
{
  pinMode(DONEPIN, OUTPUT);
  digitalWrite(DONEPIN, LOW);
  Serial.begin(115200);
  radio.begin();
  radio.setChannel(115);
  radio.setPALevel(RF24_PA_MAX);
  radio.setDataRate( RF24_250KBPS ) ;
  radio.openWritingPipe( addresses[0]);
  delay(1000);
  dht.begin();
 
  do_vcc();
  dht22_hum = dht.readHumidity();
  dht22_temp = dht.readTemperature();
  readSensor();
  radio.write(&data, sizeof(data));
  done();
 
}
 
/// LOOP /////////////////////////////////////
void loop()
{
 
}
 
void done()
{
  // bascule FAIT pour que TPL sache qu'il faut couper l'électricité !
  while (1) {
   digitalWrite(DONEPIN, HIGH);
   delay(1);
   digitalWrite(DONEPIN, LOW);
   delay(1);
  }
}
 
/** Lecture DHT22 *********************/ 
void readSensor()
{
  data.humidity = round(dht.readHumidity())+200;
  data.temperature = round(dht.readTemperature())+200;
  data.bat = round(bat_value)+200;
}
 
//***********************************************************
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 ;
    if (p>100){  // max
      p = 100;
    } else if ( p<0) {
      p = 0;  
    }
    bat_value = p;
    //bat_value = 50.00; // valeur de test
    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);
}

Pour information , les 2 éléments sont dans la même pièce à env 3m de distance

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