NRF24L01+ ne communiquent pas

Bonjour
2 NRF24L01+ l'un sur pro mini ( emetteur) l'autre sur esp32 (recepteur) pour capter température exérieure, puis par wifi alimenter la bdd par wifi.
Impossible de les faire communiquer
les NRF24L01 sont branchés sur un module adaptateur, j'ai soudé un condensateur de 10uF sur les bornes VCC et GND du nrf24l01
Chaque nrf24l01 a une alim autonome du pro mini ou esp32
Code de l'émetteur

/****************************************
croquis pour envoyer un message et et ecouter la réponse d'après

mettre sur pro mini qui recevra les données du thermometre et qui envoie sur esp32

*****************************/



#include <SPI.h>
#include <RF24.h>

#define PIN_CS 8
#define PIN_CE 7

RF24 radio (PIN_CE,PIN_CS);
const uint64_t pipeA = 0xF0F0F0F0E1LL;
const uint64_t pipeB = 0xF0F0F0F0E2LL;

void setup(){
    Serial.begin(9600);
    Serial.println(F("Go go go"));

    radio.begin();

    //activer l'accusé de reception
    radio.enableAckPayload();
    // l'accusé de reception est dynamique
    radio.enableDynamicPayloads();

    //réglage de l'amplificateur
    radio.setPALevel(RF24_PA_LOW);

    //réglage des canaux
    radio.openWritingPipe(pipeB);
    radio.openReadingPipe(1,pipeA);

    //en ecoute
    radio.startListening();

}

void loop()  {
    //arret ecoute
    radio.stopListening();
    Serial.println(F("Envoi ................"));

    //utilisation de micro comme message
    unsigned long message = micros();
    //envoi
    if (!radio.write(&message, sizeof(unsigned long) )){
        Serial.println(F("ERREUR  !"));
    }

    //mise en ecoute
    radio.startListening();

    //enregistrement du debut du delais
    unsigned long debut = micros();
    boolean timeout = false;

    //tant que rirn a lire
    while (!radio.available()){
        Serial.println("Ya a lire");
        //600ms on abandonne
        if (micros()-debut > 600000){
            timeout = true;
            break;
        }
    }

    //abandon pour cause de delai ecoulé ?
    if (timeout){
        Serial.println(F("Erreur....: ...TIMEOUT"));
    } else {
        //variable pour le message recu
        unsigned long reception;
        //lecture des donnéees reçues
        radio.read(&reception, sizeof(unsigned long));
        //enregistrement du moment de reception
        unsigned long fin = micros();

        //Affichage
        Serial.print(F("Message envoyé :"));
        Serial.print(message);
        Serial.print(F(", reponse reçue: "));
        Serial.print(reception);
        Serial.print(F(", temps complet: "));
        Serial.print(fin-message);
        Serial.println(F(" microsecondes"));
    }
    delay(1000);
}

Code du recepteur

/****************************
croquis pour la carte arduino chargée de recevoir un message répondre en renvoyant le même message d'après

Mettre sur esp32 qui ensuite enverra en wifi sur le serveur

***********************/


#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"

/*
#define PIN_CS 5
#define PIN_CE 21

RF24 radio(PIN_CE,PIN_CS);
*/

const byte cePin = 21;
const byte csnPin = 5;

const byte MOSI_PIN = 23;
const byte MISO_PIN = 19;
const byte CLK_PIN = 18 ;

RF24 radio(cePin, csnPin);

const uint64_t pipeA = 0xF0F0F0F0E1LL;
const uint64_t pipeB = 0xF0F0F0F0E2LL;

void setup(){
    Serial.begin(115200);
    Serial.println(F("Go go go"));

    radio.begin();

    //activer l'accusé de reception
    radio.enableAckPayload();
    // l'accusé de reception est dynamique
    radio.enableDynamicPayloads();

    //réglage de l'amplificateur
    radio.setPALevel(RF24_PA_LOW);

    //réglage des canaux
    radio.openWritingPipe(pipeA);
    radio.openReadingPipe(1,pipeB);

    //en ecoute
    radio.startListening();

}

void loop()  {
    unsigned long temps;

    //des données sont-elles disponibles ?
    if (!radio.available()){
        Serial.println("radio receptrice OK");
        while (radio.available()) {
          radio.read(&temps, sizeof(unsigned long));
        }
        //arret emission
        radio.stopListening();
        //envoi reponse
        radio.write(&temps, sizeof(unsigned long));

        //reprise de la reception
        radio.startListening();
        //affichage
        Serial.print(F("pong ! la valeur reçue est : "));
        Serial.println(temps);
    } else { Serial.println(" Y a t il une erreur");}

}


Sortie serie de l'envoyeur (pro mini)

Ya a lire

Message envoyé :862271504, reponse reçue: 0, temps complet: 27000 microsecondes

Envoi ................

Ya a lire

Message envoyé :863385128, reponse reçue: 0, temps complet: 528 microsecondes

Envoi ................

Ya a lire

Ya a lire

Ya a lire

Ya a lire

Ya a lire

Message envoyé :864438428, reponse reçue: 0, temps complet: 14512 microsecondes

Sortie série du récepteur (esp32)

pong ! la valeur reçue est : 0

radio receptrice OK

pong ! la valeur reçue est : 0

radio receptrice OK

pong ! la valeur reçue est : 0

radio receptrice OK

pong ! la valeur reçue est : 0

radio receptrice OK

pong ! la valeur reçue est : 0

radio receptrice OK

Avez vous essayé votre montage avec un des codes d'exemples qui sont connus pour être fonctionnels ?

Oh oui c'est le dernier sketch mis en place que j'ai envoyé.
même pb avec les précédents

Bonjour dmlk

Si je suis dans ton cas, j'utilise un programme de monitoring qui me permet de voir si mon module radio est bien "vu" de l'Arduino:

#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"

//------------------------------------- Hardware configuration: Set up nRF24L01 radio on SPI bus plus pins 7 & 8 
RF24 radio(9, 10); //Nano IO Shield     https://wiki.iteadstudio.com/Arduino_Nano_IO_shield
//RF24 radio(7,8);  // CE CS
//RF24 radio(9, 10);  // Nano
//RF24 radio(9, 8); //ESP32 Rev1 M5stack

//------------------------------------- Topology
const uint64_t pipes[2] = { 0xABCDABCD71LL, 0x544d52687CLL };              // Radio pipe addresses for the 2 nodes to communicate.

void setup()
{
  Serial.begin(115200);
  printf_begin();

  //----------------------------------- Setup and configure rf radio

  radio.begin();
  radio.setAutoAck(1);                    // Ensure autoACK is enabled
  radio.enableAckPayload();               // Allow optional ack payloads
  radio.setRetries(0,15);                 // Smallest time between retries, max no. of retries
  radio.setPayloadSize(1);                // Here we are sending 1-byte payloads to test the call-response speed
  radio.openWritingPipe(pipes[1]);        // Both radios listen on the same pipes by default, and switch when writing
  radio.openReadingPipe(1,pipes[0]);
  radio.startListening();                 // Start listening
}

void loop(void) 
{
  Serial.println();
  radio.printDetails();                   // Dump the configuration of the rf unit for debugging
  delay(2000);
}

Dans le moniteur à 115200, si le module n'est pas vu:

SPI Speedz	= 10 Mhz
STATUS		= 0x00 RX_DR=0 TX_DS=0 TX_DF=0 RX_PIPE=0 TX_FULL=0
RX_ADDR_P0-1	= 0x0000000000 0x0000000000
RX_ADDR_P2-5	= 0x00 0x00 0x00 0x00
TX_ADDR		= 0x0000000000
RX_PW_P0-6	= 0x00 0x00 0x00 0x00 0x00 0x00
EN_AA		= 0x00
EN_RXADDR	= 0x00
RF_CH		= 0x00
RF_SETUP	= 0x00
CONFIG		= 0x00
DYNPD/FEATURE	= 0x00 0x00
Data Rate	= 1 MBPS
Model		= nRF24L01+
CRC Length	= Disabled
PA Power	= PA_MIN
ARC		= 0

s'il est vu:

SPI Speedz	= 10 Mhz
STATUS		= 0x0e RX_DR=0 TX_DS=0 TX_DF=0 RX_PIPE=7 TX_FULL=0
RX_ADDR_P0-1	= 0x544d52687c 0xabcdabcd71
RX_ADDR_P2-5	= 0xc3 0xc4 0xc5 0xc6
TX_ADDR		= 0x544d52687c
RX_PW_P0-6	= 0x01 0x01 0x01 0x01 0x01 0x01
EN_AA		= 0x3f
EN_RXADDR	= 0x02
RF_CH		= 0x4c
RF_SETUP	= 0x07
CONFIG		= 0x0f
DYNPD/FEATURE	= 0x03 0x06
Data Rate	= 1 MBPS
Model		= nRF24L01+
CRC Length	= 16 bits
PA Power	= PA_MAX
ARC		= 0

Cordialement
jpbbricole

Voici la sortie de l'ESP32 c a d le recepteur

SPI Speedz	= 10 Mhz
STATUS		= 0x0e RX_DR=0 TX_DS=0 TX_DF=0 RX_PIPE=7 TX_FULL=0
RX_ADDR_P0-1	= 0x0000000000 0x00000e0000
RX_ADDR_P2-5	= 0xc3 0xc4 0xc5 0xff
TX_ADDR		= 0xe7e7e7e7e7
RX_PW_P0-6	= 0x20 0x20 0x20 0x20 0x20 0x1c
EN_AA		= 0x3f
EN_RXADDR	= 0x03
RF_CH		= 0x60
RF_SETUP	= 0x00
CONFIG		= 0x00
DYNPD/FEATURE	= 0x00 0x00
Data Rate	= 1 MBPS
Model		= nRF24L01
CRC Length	= Disabled
PA Power	= PA_HIGH
ARC		= 3

Il est donc bien vu !
Mais l'émetteur n'est pas vu :

Lr 0� I@@� lhc\J��ES``
	4 �`AĆ��� �J�#k�	T�!簨D��#��D�' �D$"�Yˆ<"��!�d �@"��(��d:E�' �D$"�e��<"�[�Rp���@D �怘�ff��fxfx�f��������fffff�f�����ff`f�f�ff`f�f�ff`xf�ffffff�ff`ff�������fff``���ff���������fff``���ffx�f�����`fff``��f�������fffff�ff��������f���fff�������f���f�f``��f�����f`�f����������f`�f�f``fff�������xf�~f�������`ff�f`��xf`fff�f`������`f~�f~ff�������f�f������`fx��������f`�����f怘�����f��~~�����`��f���fx怘�ff�~fxf��f�ff���怘����f�������怘�ff��fxfx�f��������fffff�f�����ff`f�f�ff`f�f�ff`xf�ffffff�ff`ff�������fff``���ff���������fff``���ffx�f�����`fff``��f�������fffff�ff��������f���fff�������f���f�f``��f�����f`�f����������f`�f�f``fff�������xf�~f�������`ff�f`��xf`fff�f`������`f~�f~ff�������f�f������`fx��������f`�����f怘�����f��~~�����`��f���fx怘�ff�~fxf��f�ff���怘����f�������怘�ff��fxfx�f��������fffff�f�����ff`f�f�ff`f�f�ff`xf�ffffff�ff`ff�������fff``���ff���������fff``���ffx�f�����`fff``��f�������fffff�ff��������f���fff�������f���f�f``��f�����f`�f����������f`�f�f``fff�������xf�~f�������`ff�f`��xf`fff�f`������`f~�f~ff�������f�f������`fx��������f`�����f怘�����f��~~�����`��f���fx怘�ff�~fxf��f�ff���怘����f�������怘�f��fxfx�f��������fffff�f�����ff`f�f�ff`f�f�ff`xf�fffff�ff`ff�������fff``������������fff``���fx�f�����`fff``��f�������ffff���������f���ff�������f���f�f``��f�����f`�f����������f`�f�f``fff�������xf�~f�������`ff�f`��xf`fff�f`������`f~�f~ff�������f�f������`fx��������f`�����f怘�����f��~~�����`��f���fx怘�ff�~fxf��f�ff���怘����f�������怘�f��fxfx�f��������fffff�f�����ff`f�f�ff`f�f�ff`xf�fffff�ff`ff�������fff``������������fff``���fx�f�����`fff``��f�������ffff���������f���ff�������f���f�f``��f�����f`�f����������f`�f�f``fff�������xf�~f�������`ff�f`��xf`fff�f`������`f~�f~ff�������f�f������`fx��������f`�����f怘�����f��~~�����`��f���fx怘�ff�~fxf��f�ff���怘����f�������
SPI Speedz	= 10 Mhz
STATUS		= 0x00 RX_DR=0 TX_DS=0 TX_DF=0 RX_PIPE=0 TX_FULL=0
RX_ADDR_P0-1	= 0x0000000000 0x0000000000
RX_ADDR_P2-5	= 0x00 0x00 0x00 0x00
TX_ADDR		= 0x0000000000
RX_PW_P0-6	= 0x00 0x00 0x00 0x00 0x00 0x00
EN_AA		= 0x00
EN_RXADDR	= 0x00
RF_CH		= 0x00
RF_SETUP	= 0x00
CONFIG		= 0x00
DYNPD/FEATURE	= 0x00 0x00
Data Rate	= 1 MBPS
Model		= nRF24L01+
CRC Length	= Disabled
PA Power	= PA_MIN
ARC		= 0

Merci
il me reste à verifier le cablage

Tu as tout compris :wink:

Bon maintenant que j'ai des modules bien branchés, j'ai choisi des sketchs plus simples trouvés ici :
https://electroniqueamateur.blogspot.com/2019/12/communication-nrf24l01-avec-cartes.html
l'emetteur afiiche bien

J'envoie maintenant 48
J'envoie maintenant 49
J'envoie maintenant 50
J'envoie maintenant 51
J'envoie maintenant 52
J'envoie maintenant 53

Mais le recepteur c'est n'importe quoi

Message recu : 
Message recu : 
Message recu : 
Message recu : 0��
Message recu : 8a8p�|
Message recu : 0�p
Message recu : 00��
Message recu : 0�
Message recu : 
Message recu : 
Message recu : 
Message recu : 
Message recu : 
Message recu : 0��
Message recu : 0��
Message recu : 0��
Message recu : 0�
Message recu : 0�p
Message recu : 0��
Message recu : 

Où est l'erreur ? Des perturbations radio ?
Meme pb si je mets radio.setPALevel(RF24_PA_LOW);
et au bout d'un moment plus rien ne défile

Remarque mes nrf24l01 ont une antenne

Quel type d’alim ?

Pour l'un mes batteries en direct , pour l'autre une alim usb sur le secteur puis fdti pour avoir la bonne connectique

Bonjour dmlk

En tout cas, pas une erreur de programme, j'ai essayé la paire (avec des Nano), pas de problème.

Cordialement
jpbbricole

Certains FTDI délivrent très peu de courant - surtout sur la pin 3.3V - ils ne sont pas fait pour ça

Merci,
Oui c'est ce que je pensais faire, supprimer cet intermédiaire

Je dis peut-être une bêtise, mais la dernière fois que j'ai fait joujou avec ces modules radio, j'ai suivi cet (excellent) article : Tuto NRF24L01 : code arduino, librairie, fonctionnement, …, qui indiquait (chapitre 2.1) que le module, je cite :

... est prévu pour fonctionner dans la plage de 2,4 GHz à 2,525 GHz, par « pas » de 1 MHz.
Chaque pas de 1 MHz est ce qu’on appelle ici un canal. Du coup, on dispose ici de 126 canaux, permettant de communiquer sur la fréquence de notre choix, entre 2,4 à 2,525 MHz.

Mais en parcourant rapidement le code du premier post et ceux fourni par @jpbbricole, je ne vois pas mention de la commande setChannel qui permet de définir la plage de fonctionnement - je me trompe peut-être, mais si vous ajoutez la ligne radio.setChannel(125); (soit 2525 MHz) à votre setup, ça donne quoi ?

Je cite encore l'article plus haut (toujours chapitre 2.1) :

Concernant le WiFi, il couvre usuellement les fréquences allant de 2,412 GHz à 2,484 GHz. Ceci nous laisse donc de la « place », entre 2,485 et 2,525 GHz pour communiquer sans risque d’interférences avec lui.

Concernant le Bluetooth, il en va de même. En effet, les fréquences comprises entre 2400 MHz et 2483,5 MHz peuvent être utilisées, nous laissant donc « le champ libre » entre 2484 MHz et 2525 MHz.

Mes excuses par avance si j'ai dit une ânnerie :woozy_face:,
Cordialement,
Pandaroux007


PS : votre second code post #1 est mal formaté, pourriez vous l'éditer (bouton :pencil: en bas à droit) comme le premier programme, s'il vous plaît ? Merci !

EDIT2 : Il manque un bout de commentaire au début du deuxième, mais merci :+1:

J’ai aussi deux vieux posts avec codes d’exemple

Bonjour,

Ces modules sont souvent un peu capricieux à mettre en route. Il faut faire des tests dans plusieurs configurations différentes soit:

  • modifier la distance entre les 2 modules
  • changer/tester différentes alimentations
  • inverser les modules entre les microcontrôleurs pour identifier si le problème suit le microcontrôleur ou le module.

Aussi lors de mes tests, j'avais aussi diminué le Data Rate (à vérifier si ce paramétrage est reconnu dans votre bibiothèque)
radio.setDataRate(RF24_250KBPS);

Bonne bidouilles.

A+

Merci pour vos conseils. Pour l'instant je ne trouve pas pourquoi l'un des module n'est pas reconnu. Même en les interchangeant... Mort ?
Mais peu de temps disponible,
A bientôt avec de bonnes nouvelles

Ben c'est pas gagné.
Dans les loop de chacun j'ai ajouté avant d'envoyer ou de lire la reception ces 2 lignes
pour l'émetteur :

Serial.print("Radio emetteur  connecté ? : ");
  Serial.println(radio.isChipConnected() ? "OUI" : "NON !!!");

et pour le recepteur :

Serial.print("Radio Recepteur connecté ? ");
   Serial.println(radio.isChipConnected() ? "OUI" : "NON !!!");

mais la sortie série me renvoie des résultats aléatoires :

J'envoie maintenant 10
Radio emetteur  connecté ? : NON !!!
J'envoie maintenant 11
Radio emetteur  connecté ? : NON !!!
J'envoie maintenant 12
Radio emetteur  connecté ? : OUI
J'envoie maintenant 13

et pour le récepteur :

Radio Recepteur connecté ? OUI
Radio Recepteur connecté ? OUI
Radio Recepteur connecté ? OUI
Radio Recepteur connecté ? OUI
Radio Recepteur connecté ? OUI
Radio Recepteur connecté ? OUI
Radio Recepteur connecté ? OUI
Radio Recepteur connecté ? OUI
Radio Recepteur connecté ? OUI
Radio Recepteur connecté ? NON !!!
Radio Recepteur connecté ? NON !!!
Radio Recepteur connecté ? NON !!!
Radio Recepteur connecté ? : NON !!!
Message recu : 
Radio Recepteur connecté ? : NON !!!
Message recu : 
Radio Recepteur connecté ? OUI
Radio Recepteur connecté ? OUI
Radio Recepteur connecté ? OUI

je ne sais pas où chercher

Souvent du côté de l’alim si ça ne fonctionne pas avec un sketch connu qui fonctionne.