nrf24l01 et nombre 4

Bonjour,
voila un truc de fou!
J'ai un module maître avec un nrf24 qui communique avec des modules "esclaves" dont le nombre peut changer et dont voici le code

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

//NRF24L01
RF24 radio(8, SS);                // Micro nRF24L01 (CE,CSN)
char dataToSend = 'm'; //Message envoyé pour collecte datas à chaque capteur
char ackData[32]; //Réponse avec datas des capteurs
uint8_t nbrCapteurs = 0;

const uint8_t numSlaves = 13;
const uint8_t slaveAddress[numSlaves][5] = {
  {'R', 'x', 'A', 'A', 'A'},
  {'R', 'x', 'A', 'A', 'B'},
  {'R', 'x', 'A', 'A', 'C'},
  {'R', 'x', 'A', 'A', 'D'},
  {'R', 'x', 'A', 'A', 'E'},
  {'R', 'x', 'A', 'A', 'F'},
  {'R', 'x', 'A', 'A', 'G'},
  {'R', 'x', 'A', 'A', 'H'},
  {'R', 'x', 'A', 'A', 'I'},
  {'R', 'x', 'A', 'A', 'J'},
  {'R', 'x', 'A', 'A', 'K'},
  {'R', 'x', 'A', 'A', 'L'},
  {'R', 'x', 'A', 'A', 'M'}
};



void setup() {
  Serial.begin(115200);
  SPI.begin(); //Communication RF
  delay(50);
  radio.begin();
  radio.setChannel(120);
  radio.setDataRate(RF24_2MBPS);
  radio.setPALevel(RF24_PA_MAX);
  radio.enableAckPayload();
  radio.setRetries(5, 3); // delay, count
  Serial.println("Choisir le nombre de capteurs");
  while (nbrCapteurs == 0) {
    if (Serial.available()) {
      nbrCapteurs = Serial.read() - '0';
    }
  }
}

void loop() {
  for (uint8_t n = 0; n < nbrCapteurs; n++) {
    radio.openWritingPipe(slaveAddress[n]);
    if (radio.write(&dataToSend, sizeof(dataToSend))) {
      if (radio.isAckPayloadAvailable()) {
        radio.read(&ackData, sizeof(ackData));
        Serial.println(ackData);        
      }
    }
  }
}

Le code des "esclaves" à qui il demande des infos

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

#define CE_PIN   10
#define CSN_PIN SS

const uint8_t address[5] = {'R', 'x', 'A', 'A', 'A'};

RF24 radio(CE_PIN, CSN_PIN);

char dataReceived[10]; // this must match dataToSend in the TX
char ackData[32]; // the two values to be sent to the master
bool newData = false;

int test;

void setup() {
  radio.begin();
  radio.setChannel(120);
  radio.setDataRate(RF24_2MBPS);
  radio.setPALevel(RF24_PA_MAX);
  radio.openReadingPipe(1, address);
  radio.enableAckPayload();

  radio.startListening();

  radio.writeAckPayload(1, &ackData, sizeof(ackData)); // pre-load data
}

void loop() {
  getData();
  showData();
}

void getData() {
  if ( radio.available() ) {
    radio.read( &dataReceived, sizeof(dataReceived) );
    updateReplyData();
    newData = true;
  }
}

//================

void showData() {
  if (newData == true) {
    Serial.print("Data received ");
    Serial.println(dataReceived);
    Serial.print(" ackPayload sent ");
    Serial.println(ackData);
    newData = false;
  }
}

//================

void updateReplyData() {
  test++;
  if (test > 100){
    test = 0;
  }
  sprintf(ackData, "i0/%i/%s/%s/%s", test, "01", "01", "01");
  radio.writeAckPayload(1, &ackData, sizeof(ackData)); // load the payload for the next time
}

Et bien cela fonctionne avec 3 , 5, 6 , etc capteurs, mais pas avec 4! :o
Cela fait une semaine que je cherche desesperemment une solution.
Toute aide ou suggestion est la bienvenue.
Merci

De mémoire, les adresses sont sur 40bits (5 octets) mais représentés par des uint64 (8 octets)

Comme Vous n’en allouez que 5 et que vous passez une adresse de tableau, je ne suis pas sûr de ce que l’écoute va choisir

Essayez côté Maitre

 const uint64_t slaveAddress[] = {
0xF0F0F0F0E1LL, 
0xF0F0F0F0E2LL, 
0xF0F0F0F0E3LL,
0xF0F0F0F0E4LL,
0xF0F0F0F0E5LL,
0xF0F0F0F0E6LL,
0xF0F0F0F0E7LL,
0xF0F0F0F0E8LL,
0xF0F0F0F0E9LL,
0xF0F0F0F0EALL,
0xF0F0F0F0EBLL,
0xF0F0F0F0ECLL,
0xF0F0F0F0EDLL
};
const uint8_t numSlaves = sizeof(slaveAddress)/sizeof(slaveAddress[0]);

Et côté esclaveconst uint64_t address = 0xF0F0F0F0E1LL;

Merci de ta réponse mais cela ne change rien.
De plus, l'adresse d'un nrf est me semble t-il sur 5 bytes?
Sur 40bytes, c'est plutot l'adresse du pipe.

zjbjbjbz:
De plus, l'adresse d'un nrf est me semble t-il sur 5 bytes?
Sur 40bytes, c'est plutôt l'adresse du pipe.

40 bits pas bytes (octets) ==> 1 octet c'est 8 bits, donc 40 bits c'est bien 5 octets et comme on est sur une architecture little endian, les octets de poids faible sont stockés en premier en mémoire et donc ça revient au même.

je suppose que vous avez bien vérifié que votre esclave N° 4 a la bonne adresse et qu'il est fonctionnelle (ie si vous échangez le code sur le 3 et 4 c'est bien toujours le 4 qui pose problème)

je viens de regarder dans la doc et ils disent que l'approche avec les uint64_t est dépréciée en faveur de l'approche avec le tableau de 5 octets comme vous le faites par contre ils utilisent le premier octet pour différencier les pipes.

si je me souviens bien c'est important pour certains pipes quand on en écoute plusieurs à la fois mais ce n'est pas votre cas apparement...

Essayez quand même avec

const uint8_t slaveAddress[numSlaves][] = {
  "ARxAA", "BRxAA", "CRxAA", "DRxAA", "ERxAA", "FRxAA", "GRxAA", "HRxAA",  "IRxAA", "JRxAA", "KRxAA", "LRxAA", "MRxAA"};

PS= ce sont bien des nrf24l01**+** vos modules, pas juste des nrf24l01 (ça ne devrait pas gêner vu que vous êtes en RF24_2MBPS mais certains sont de moindre qualité)

Pas mieux.
Si je branche le module1 et que je sélectionne 3 capteurs, le module1 donne

Data received m
 ackPayload sent i0/2/01/01/01
Data received m
 ackPayload sent i0/3/01/01/01
Data received m
 ackPayload sent i0/4/01/01/01
Data received m
 ackPayload sent i0/5/01/01/01
Data received m
 ackPayload sent i0/6/01/01/01
Data received m
 ackPayload sent i0/7/01/01/01
Data received m
 ackPayload sent i0/8/01/01/01
etc

et si je sélectionne 4 capteurs

Data received m
 ackPayload sent i0/2/01/01/01

une fois et puis plus rien.
Du côté maître, je reçois à priori des chaines vides
Ça me rend dingue ce truc...

Pour info, je me suis fait mes propres cartes avec 32u4(8MHz), nrf24L01+, et rfx2401c pour l'ampli

que dit le maître pendant ce temps là ?

Ben le maitre, il affiche des lignes vides, quand j'ouvre le port série de l'ide arduino, la barre de défilement part vers le bas mais rien ne s'affiche.
En gros, il fait comme si il recevait alors que le nrf de l'esclave (quelqu'il soit) semble "freezé"

et quand vous n'êtes pas à 4 tout fonctionne ?

si le maître n'affiche rien c'est qu'il plante à 4 et donc que les esclaves ne reçoivent rien...

vous avez essayé avec un petit délai dans les envois ?

void loop() {
  for (uint8_t n = 0; n < nbrCapteurs; n++) {
    radio.openWritingPipe(slaveAddress[n]);
    if (radio.write(&dataToSend, sizeof(dataToSend))) {
      delay(100);
      if (radio.isAckPayloadAvailable()) {
        radio.read(&ackData, sizeof(ackData));
        Serial.println(ackData);        
      }
    }
    delay(100);
  }
}

Tout d'abord, je voulais te remercier du temps que tu consacres à m'aider J-M-L.
Le delay n'y change rien, au contraire, plus rien ne fonctionne.
Je me suis dis que comme j'ai fait mes propres cartes, peut être qu'il s'agissait d'un problème de hardware. J'ai donc pris des modules pro micro(3.3V 8MHZ) avec des modules nrf24L01 pa lna, et j'ai exactement le même problème.
Pourrait-il s'agir d'un bug de la librairie? Elle n'aimerait pas le nombre 4? :o

Le delay n'y change rien, au contraire, plus rien ne fonctionne.

ça c'est inquiétant. il ne devrait y avoir aucune dépendance au timing.

je n'ai pas regardé en détail comment vous gérez les ACK. avez vous essayé sans ACK pour commencer ?

En allant traîner du côté networking du forum, on m'a orienté ainsi

You have to make your tx packet non-constant.

There is an internal mechanism to detect duplicate packets
that uses a two bit sequence counter (pid) and the CRC,
so the second packet with the same pid and CRC in a row
makes the receiver believe it got a duplicate.

It will ack the packet, but will not signal a reception.

Add a counter to the packet that gets incremented after each successful write and your done. :wink:
A byte will do, the goal is to change the CRC between two packets hitting one receiver,
because it is very hard to keep track of the pid (packet id) in a multitarget application.

Two packets directly adjacent to the same target should work also the pid should increment after the
ack issued by the duplicate detection.

J'ai donc fait en sorte que le message envoyé par le maître ne soit pas toujours le même avec un petit compteur

byte dataToSend = 0; //Message envoyé pour collecte datas à chaque capteur
void loop() {
  for (uint8_t n = 0; n < nbrCapteurs; n++) {
    radio.openWritingPipe(slaveAddress[n]);
    dataToSend++;
  if (dataToSend > 9) {
    dataToSend = 0;
  }
    if (radio.write(&dataToSend, sizeof(dataToSend))) {
      if (radio.isAckPayloadAvailable()) {       
        radio.read(&ackData, sizeof(ackData));
        Serial.println(ackData);       
      }
    }
  }
}

et maintenant cela semble fonctionner.
J'attends de faire quelques tests avant de mettre en résolu.
Encore une fois merci mille fois J-M-L de aide et de ton écoute

Super je ne connaissais pas ce point !
J’ai appris quelque chose !

Bonjour à tous les deux, bonjour à tous,

Coincidence, je cherche à récupérer la valeur de plusieurs capteurs de température de la même manière et j'étais en train de m’intéresser au Tuto de Robin2 : Simple nRF24L01+ 2.4GHz transceiver demo - Exhibition / Gallery - Arduino Forum
qui traite de ce cas de transmission en utilisant ACK.

Pour l'instant, le test de ses sketchs ne fonctionne pas pour moi (je teste avec deux slaves et un master composé de UNO+NRF24L01).

J'ai donc suivi avec attention cette discussion et reproduit les programmes de zjbjbjbz.

Pour l'instant, ça ne fonctionne pas non plus : le master ne reçoit rien et sur les deux slaves Data received reste à 0 :

ackPayload sent i0/1/01/01/01
Data received 
 ackPayload sent i0/2/01/01/01
Data received 
 ackPayload sent i0/3/01/01/01
Data received 
 ackPayload sent i0/4/01/01/01
Data received 
 ackPayload sent i0/5/01/01/01
Data received 
 ackPayload sent i0/6/01/01/01

zjbjbjbz, pourras-tu, une fois tes test terminés, poster les codes pour que je puisse les adapter à mon projet?

Merci.

PS : même si je débranche le Master, les slaves continuent à recevoir et tournent en boucle. J'ai une autre installation à base de NRF24L01+ qui fonctionne mais pas sur le même canal (radio.setChannel(0x14); //canal 20). Cela peut il interférer ?