NRF24L01 : Pas de message reçu

pouvez vous reposter les 2 codes ?

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

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

le "trou" correspond au retour à la ligne qui est au début du

Code:

Serial.print("\nMessage:");

1 pièce(s) jointe(s)

Citation:

le "trou" correspond au retour à la ligne qui est au début du

je l'ai enlevé mais en quoi cela joue un rôle sur l'émission ou la réception ?

Par contre les erreurs de température et d'humidité semblent résolues
il s'agissait du capteur AM2301A qui était en lieu et place du DHT22
j'ai donc fait le remplacement peut-être une incompatibilité de librairies

mais certains "trous" restent

qu'appelez vous trou exactement ?

1 pièce(s) jointe(s)

Code:

qu'appelez vous trou exactement ?

la période d'envoi est actuellement de 30s
Logiquement le récepteur devrait afficher les datas donc toutes les 30s
mais je constate des "trous" càd des périodes plus longues comme sur l'image ci-dessous
où par ex :
réception envoi à 14:47.54
puis
réception envoi à 14:54.10 (? soit beaucoup plus que 30s)

alors que l'envoi se fait bien de façon cyclique toutes les 30s
l'ennui est que çà ne semble pas régulier mais je n'en connais pas la cause
par contre les mesures elles sont cohérentes

OK je comprends mieux, je n'avais pas regardé les timings, je croyais que vous parliez de trou dans l'affichage

il se peut que la transmission ait été corrompue et donc que le récepteur n'ait pas validé le paquet reçu - la fréquence utilisée est embouteillée et donc parfois vous pouvez perdre des données

le module sait gérer un ACK (avis de réception), regardez l'exemple

https://github.com/nRF24/RF24/blob/m...ntPayloads.ino

Citation:

le module sait gérer un ACK (avis de réception), regardez l'exemple

Est-ce ceci ?
=>> radio.enableAckPayload();

Dois-je l'appliquer sur le récepteur et sur l'émetteur ?
ou puis-je me contenter de le mettre que sur le récepteur

J'utilise aussi
===> radio.setChannel(115);
le choix de ce canal peut-il être aussi la cause de pertes de signaux ?

dans l'exemple que j'ai pointé ils disent
Code:

1 2 3 4 // Acknowledgement packets have no payloads by default. We need to enable // this feature for all nodes (TX & RX) to use ACK payloads. radio.enableAckPayload();
donc oui des 2 côtés

Pour le canal 115, non la doc dit qu'on passe un canal de 0 à 127, il se peut cependant qu'un canal soit plus occupé qu'un autre chez vous