Xbee API mesh entre deux arduino

bonjour a tous
je suis en galère depuis plusieurs jours et je recherche de l'aide

je cherche a échanger des valeur entre un xbee coordinateur et un routeur en mode API 1 chaque-un brancher sur une mega

les configuration sur XCTU son bonne et fonctionne normalement .
en revanche , une fois sur mon code arduino , seul l'adresse de broadcast fonctionne .

#include <XBee.h>

XBee xbee = XBee();
XBeeResponse response = XBeeResponse();
ZBRxResponse rxResponse = ZBRxResponse();
ZBTxRequest txRequest;

XBeeAddress64 addr64ced = XBeeAddress64(0x0013a200, 0x41f2684c);

void setup() {
  Serial.begin(9600); // Moniteur série pour debug
  Serial1.begin(9600); // Communication avec le XBee
  xbee.setSerial(Serial1);
  Serial.println("Routeur prêt à recevoir et répondre !");
}

void loop() {
  xbee.readPacket();

  if (xbee.getResponse().isAvailable()) {
    if (xbee.getResponse().getApiId() == ZB_RX_RESPONSE) {
      // Traiter la trame reçue
      xbee.getResponse().getZBRxResponse(rxResponse);

      // Récupérer l'adresse de l'émetteur
      XBeeAddress64 remoteAddress = rxResponse.getRemoteAddress64();

      // Imprimer l'adresse de l'émetteur
      Serial.print("Trame reçue de : ");
 uint16_t testhaut = (remoteAddress.getMsb(), HEX);
 uint16_t testbas = (remoteAddress.getLsb(), HEX); 
 
      Serial.print(remoteAddress.getMsb(), HEX); // Partie haute de l'adresse
      Serial.print(remoteAddress.getLsb(), HEX); // Partie basse de l'adresse


       Serial.println();
      Serial.write(testhaut); // Partie haute de l'adresse
      Serial.write(testbas); // Partie basse de l'adresse

      Serial.println();
       Serial.print("suite : ");





      // Afficher le contenu de la trame
      Serial.print("Données : ");
      for (int i = 0; i < rxResponse.getDataLength(); i++) {
        Serial.write(rxResponse.getData()[i]);
      }
      Serial.println();

      // Préparer une réponse
      uint8_t responsePayload[] = "OK, reponce ";

   delay(5000); 

      XBeeAddress64 addr64Cible = XBeeAddress64(0x0013A200, 0x41F268DA);
      XBeeAddress64 addr64Cible2 = XBeeAddress64(0x0013A200, 0x41F2684C);

      //XBeeAddress16 addr16 = XBeeAddress16(remoteAddress16);
      uint16_t addr16 = rxResponse.getRemoteAddress16();
       //addr16(RemoteAddress16());

     // txRequest = ZBTxRequest("0x00",testhaut,testbas, responsePayload, sizeof(responsePayload));
 
      //txRequest = ZBTxRequest(addr16, responsePayload, sizeof(responsePayload));
     txRequest = ZBTxRequest(0x000000000000FFFF, responsePayload, sizeof(responsePayload));// reponce a l'envoyeur
      //txRequest = ZBTxRequest(addr64Cible, responsePayload, sizeof(responsePayload));

  
      // Envoyer la réponse
      xbee.send(txRequest);
  Serial.print("Données renvoye: ");



      delay(2000);


    }
  }

  delay(100); // Pause pour éviter de saturer le port série
}

a la fin du code , il y a plusieurs tentative de définition de txRequest....
quelqu'un est il capable de me dire ou je merde ??
merci

ne postez pas de questions techniques dans la catégorie "le bar" donc je déplace vers le forum principal

➜ lisez les recommandations listées dans "Les bonnes pratiques du Forum Francophone”

merci dsl

Si vous simplifiez un peu ? (tapé ici, non testé)

void loop() {
  xbee.readPacket();

  if (xbee.getResponse().isAvailable()) {
    if (xbee.getResponse().getApiId() == ZB_RX_RESPONSE) {
      xbee.getResponse().getZBRxResponse(rxResponse);

      // Récupérer l'adresse 64 bits de l'expéditeur
      XBeeAddress64 remoteAddress = rxResponse.getRemoteAddress64();

      // Afficher l'adresse de l'expéditeur
      Serial.print("Trame reçue de : ");
      Serial.print(remoteAddress.getMsb(), HEX);
      Serial.print(remoteAddress.getLsb(), HEX);
      Serial.println();

      // Afficher le contenu de la trame
      Serial.print("Données : ");
      Serial.write(rxResponse.getData(), rxResponse.getDataLength());
      Serial.println();

      // Préparer une réponse
      uint8_t responsePayload[] = "OK, réponse reçue";
      ZBTxRequest txRequest(remoteAddress, responsePayload, sizeof responsePayload);
      xbee.send(txRequest);
      Serial.println("Données renvoyées !");
    }
  }

  delay(100);
}

merci j-m-l pour ta réponse

ca me cree une ereur de compil :confused:
C:\Users\33660\AppData\Local\Temp\ccjCHqcN.ltrans0.ltrans.o: In function main': C:\Users\33660\Desktop\arduino-nightly\hardware\arduino\avr\cores\arduino/main.cpp:43: undefined reference to setup'
collect2.exe: error: ld returned 1 exit status
Plusieurs bibliothèque trouvées pour "XBee.h"
Utilisé : C:\Users\33660\Documents\Arduino\libraries\XBee-Arduino_library
Non utilisé : C:\Users\33660\Desktop\arduino-nightly\libraries\xbee-arduino-master
Non utilisé : C:\Users\33660\Documents\Arduino\libraries\xbee-arduino-master
exit status 1
Erreur de compilation pour la carte Arduino Mega or Mega 2560

par contre j'ai copié une trame faite sous XCTU
en Data1[] ... et cette transmission fonctionne

#include <XBee.h>

XBee xbee = XBee();
XBeeResponse response = XBeeResponse();
ZBRxResponse rxResponse = ZBRxResponse();
ZBTxRequest txRequest;

XBeeAddress64 addr64ced = XBeeAddress64(0x0013a200, 0x41f2684c);

void setup() {
  Serial.begin(9600); // Moniteur série pour debug
  Serial1.begin(9600); // Communication avec le XBee
  xbee.setSerial(Serial1);
  Serial.println("Routeur prêt à recevoir et répondre !");
}

void loop() {
  xbee.readPacket();

  if (xbee.getResponse().isAvailable()) {
    if (xbee.getResponse().getApiId() == ZB_RX_RESPONSE) {
      // Traiter la trame reçue
      xbee.getResponse().getZBRxResponse(rxResponse);

      // Récupérer l'adresse de l'émetteur
      XBeeAddress64 remoteAddress = rxResponse.getRemoteAddress64();

      // Imprimer l'adresse de l'émetteur
      Serial.print("Trame reçue de : ");
 uint16_t testhaut = (remoteAddress.getMsb(), HEX);
 uint16_t testbas = (remoteAddress.getLsb(), HEX); 
 
      Serial.print(remoteAddress.getMsb(), HEX); // Partie haute de l'adresse
      Serial.print(remoteAddress.getLsb(), HEX); // Partie basse de l'adresse


       Serial.println();
      Serial.write(testhaut); // Partie haute de l'adresse
      Serial.write(testbas); // Partie basse de l'adresse

      Serial.println();
       Serial.print("suite : ");





      // Afficher le contenu de la trame
      Serial.print("Données : ");
      for (int i = 0; i < rxResponse.getDataLength(); i++) {
        Serial.write(rxResponse.getData()[i]);
      }
      Serial.println();

      // Préparer une réponse
      uint8_t responsePayload[] = "OK, reponce ";

   delay(5000); 

      XBeeAddress64 addr64Cible = XBeeAddress64(0x0013A200, 0x41F268DA);
      XBeeAddress64 addr64Cible2 = XBeeAddress64(0x0013A200, 0x41F2684C);

      //XBeeAddress16 addr16 = XBeeAddress16(remoteAddress16);
      uint16_t addr16 = rxResponse.getRemoteAddress16();
       //addr16(RemoteAddress16());

     // txRequest = ZBTxRequest("0x00",testhaut,testbas, responsePayload, sizeof(responsePayload));
 
      //txRequest = ZBTxRequest(addr64ced, responsePayload, sizeof(responsePayload));
     txRequest = ZBTxRequest(0x000000000000FFFF, responsePayload, sizeof(responsePayload));// reponce a l'envoyeur
      //txRequest = ZBTxRequest(addr64Cible, responsePayload, sizeof(responsePayload));

  
      // Envoyer la réponse
      byte data1[] = {0x7E, 0x00 ,0x17 ,0x10 ,0x01 ,0x00 ,0x13 ,0xA2 ,0x00 ,0x41 ,0xF2 ,0x68 ,0x4C ,0xFF ,0xFE ,0x00 ,0x00 ,0x74 ,0x65 ,0x73 ,0x74 ,0x20 ,0x65 ,0x76 ,0x6F ,0x69 ,0xC2};
      byte data[] =  {0x7E, 0x00, 0x19 ,0x90 ,0x00 ,0x13 ,0xA2 ,0x00 ,0x41 ,0xF2 ,0x68 ,0xE9 ,0x00 ,0x00 ,0x02 ,0x4F,0x4B ,0x2C ,0x20 ,0x72 ,0x65 ,0x70 ,0x6F ,0x6E ,0x63 ,0x65 ,0x20 ,0x00 ,0x42};
      //7E 00 19 90 00 13 A2 00 41 F2 68 E9 00 00 02 4F 4B 2C 20 72 65 70 6F 6E 63 65 20 00 42
 //{0x7E, 0x00 ,0x17 ,0x10 ,0x01 ,0x00 ,0x13 ,0xA2 ,0x00 ,0x41 ,0xF2 ,0x68 ,0x4C ,0xFF ,0xFE ,0x00 ,0x00 ,0x74 ,0x65 ,0x73 ,0x74 ,0x20 ,0x65 ,0x76 ,0x6F ,0x69 ,0xC2};
       
      xbee.send(txRequest);
     Serial.print("Données renvoye: ");
      Serial1.write(data1,sizeof(data1));


      delay(2000);


    }
  }

  delay(100); // Pause pour éviter de saturer le port série
}

du coup c'est bien dans l'attribution de l'adress qu'il y a un pb ? non ?!

oui il faut garder le reste de votre code, juste remplacer la loop :slight_smile:

oups effectivement j'avais oubli le setup!
alors ca compile mais je ne recois rien de l'autre coté
en revanche en faisant un copi/coller d'une trame generé dans XCTU

j'ai l'impression d'avoir fais la meme chose mais bon .....
seul le data2[] et data3[] fonctionne , je recois bien de l'autre coté

      Serial.println();

      // Préparer une réponse
      uint8_t responsePayload[] = "OK, reponce ";

   delay(5000); 

      XBeeAddress64 addr64Cible = XBeeAddress64(0x0013A200, 0x41F268DA);
      XBeeAddress64 addr64Cible2 = XBeeAddress64(0x0013A200, 0x41F2684C);

      //XBeeAddress16 addr16 = XBeeAddress16(remoteAddress16);
      uint16_t addr16 = rxResponse.getRemoteAddress16();
       //addr16(RemoteAddress16());

     // txRequest = ZBTxRequest("0x00",testhaut,testbas, responsePayload, sizeof(responsePayload));
 
     //txRequest = ZBTxRequest(addr64ced, responsePayload, sizeof(responsePayload));
     //txRequest = ZBTxRequest(0x000000000000FFFF, responsePayload, sizeof(responsePayload));// reponce a l'envoyeur
      //txRequest = ZBTxRequest(addr64Cible, responsePayload, sizeof(responsePayload));

  
      // Envoyer la réponse
       byte data3[] = {0x7E,0x00 ,0x12 ,0x10 ,0x01 ,0x00 ,0x13 ,0xA2 ,0x00 ,0x41 ,0xF2 ,0x68 ,0x4C ,0xFF ,0xFE ,0x00 ,0x00 ,0x54 ,0x45 ,0x53 ,0x54 ,0x15};
      //                 ,0x7E ,0x00 ,0x1A ,0x10 ,0x01 ,0x00 ,0x13 ,0xA2,0x00  ,0x41 ,0xF2 ,0x68 ,0x4C ,0xFF,0xFE,0x00,0x00,0x72,0x65,0x74,0x6F,0x75,0x72,0x20,0x63,0x6F,0x6F ,0x72 ,0x64 ,0x7D
      byte data2[] = {0x7E ,0x00 ,0x1A ,0x10 ,0x01 ,0x00 ,0x13 ,0xA2,0x00  ,0x41 ,0xF2 ,0x68 ,0x4C ,0xFF,0xFE,0x00,0x00,0x72,0x65,0x74,0x6F,0x75,0x72,0x20,0x63,0x6F,0x6F ,0x72};
      byte data1[] = {0x7E, 0x00 ,0x17 ,0x10 ,0x01 ,0x00 ,0x13 ,0xA2 ,0x00 ,0x41 ,0xF2 ,0x68 ,0x4C ,0xFF ,0xFE ,0x00 ,0x00 ,0x74 ,0x65 ,0x73 ,0x74 ,0x20 ,0x65 ,0x76 ,0x6F ,0x69 ,0xC2};
      byte data[] =  {0x7E, 0x00, 0x19 ,0x90 ,0x00 ,0x13 ,0xA2 ,0x00 ,0x41 ,0xF2 ,0x68 ,0xE9 ,0x00 ,0x00 ,0x02 ,0x4F,0x4B ,0x2C ,0x20 ,0x72 ,0x65 ,0x70 ,0x6F ,0x6E ,0x63 ,0x65 ,0x20 ,0x00 ,0x42};

      xbee.send(txRequest);
     Serial.print("Données renvoye: ");
      Serial1.write(data3,sizeof(data3));


      delay(2000);


    }
  }

  delay(100); // Pause pour éviter de saturer le port série
}

bon alors clairement sous cette forme

" byte data3[] = {0x7E,0x00 ,0x12 ,0x10 ....."
" Serial1.write(data,sizeof(data));"

mais pas sous la forme
" XBeeAddress64 addr64ced = XBeeAddress64(0x0013A200, 0x41F2684C);"
" txRequest = ZBTxRequest(addr64ced, responsePayload, sizeof(responsePayload));"
"xbee.send(txRequest);"

pourtant la bibliotheque esi bien faite pour ca ? !

ah en lisant votre code:

ceci n'est pas bon

le , HEX c'est un paramètre pour print(), pour lui dire d'afficher la valeur en hexadécimal...

il faut écrire

 uint16_t testhaut = remoteAddress.getMsb();
 uint16_t testbas = remoteAddress.getLsb(); 

c'est représenté toujours en binaire en mémoire. la base d'affichage, c'est pour les humains :slight_smile:

attention aussi au Serial.write et Serial.print qui ne font pas la même chose...

effectivement cela ne fonctionne pas

 uint16_t testhaut = (remoteAddress.getMsb());
 uint16_t testbas = (remoteAddress.getLsb()); 
 
      Serial.print(remoteAddress.getMsb(), HEX); // Partie haute de l'adresse
      Serial.print(remoteAddress.getLsb(), HEX); // Partie basse de l'adresse


       Serial.println();
       Serial.print("haut: ");
      Serial.write(testhaut); // Partie haute de l'adresse
      Serial.print("Bas: ");
      Serial.write(testbas); // Partie basse de l'adresse

      Serial.println();
       Serial.print("suite : ");

mais comme ca , cela ne fonctione pas non plus , je me demande pourquoi les ".write" fonctionne (sauf le premier :confused: )
et si ce n'est pas lié ?
car j'ai clairement un probleme pour definir l'adresse du router :roll_eyes:

et je comprend pas quand il faut utiliser l'adresse 64bits et la 16bits ?

En mode API 1, il est recommandé d'utiliser des adresses 64 bits pour la communication entre les modules car elles sont uniques et permettent une identification globale sur le réseau Zigbee.

Les adresses 16 bits peuvent également être utilisées, mais elles sont généralement limitées à des réseaux locaux où le coordinateur attribue des adresses spécifiques.

quand vous faites write() vous envoyez le binaire sur la ligne de sortie

si vous voulez voir les valeurs

      Serial.print("haut: 0x ");
      Serial.print(testhaut, HEX); // Partie haute de l'adresse
      Serial.print(", Bas: 0x");
      Serial.println(testbas, HEX); // Partie basse de l'adresse

merci beaucoup les prints fonctionnent

je n'ai pas renseigner l'adress DH et DL dans mon coordinateur ni mes routeur , cella est un probleme ?
je ne comprent pas pourquoi il n'y a aucun pb sur xctu .
j'ai mis un moment a comprendre que le RX et le TX sur les cartes adaptatrice xbee etai inversé :woozy_face: :woozy_face:
bon mais maintenant j'ai une com entre xctu et une mega .
mais je n'arrive a envoyer de la mega a xctu que sous forme de tableau . je ne comprend pas trop a quoi sert la bibliotheque du coup :roll_eyes:
une fois sur deux ou je tape de data[] ( a la main ) je merde et ca ne marche pas bien

#include <XBee.h>

XBee xbee = XBee();
XBeeResponse response = XBeeResponse();
ZBRxResponse rxResponse = ZBRxResponse();
ZBTxRequest txRequest;

XBeeAddress64 addr64ced = XBeeAddress64(0x0013a200, 0x41f2684c);

void setup() {
  Serial.begin(9600); // Pour afficher sur le moniteur série
  Serial1.begin(9600); // Pour communiquer avec le XBee
  xbee.setSerial(Serial1); // Associe Serial1 au module XBee
  Serial.println("Lecture des trames API...");
}

void loop() {
  xbee.readPacket();

  if (xbee.getResponse().isAvailable()) {
    if (xbee.getResponse().getApiId() == ZB_RX_RESPONSE) {
      xbee.getResponse().getZBRxResponse(rxResponse);

      // Récupérer l'adresse 64 bits de l'expéditeur
      XBeeAddress64 remoteAddress = rxResponse.getRemoteAddress64();

      // Afficher l'adresse de l'expéditeur
      Serial.print("Trame reçue de : ");
      Serial.print(remoteAddress.getMsb(), HEX);
      Serial.print(remoteAddress.getLsb(), HEX);
      Serial.println();

      // Afficher le contenu de la trame
      Serial.print("Données : ");
      Serial.write(rxResponse.getData(), rxResponse.getDataLength());
      Serial.println();

      // Préparer une réponse
      uint8_t responsePayload[] = "OK, réponse reçue";
      ZBTxRequest txRequest(remoteAddress, responsePayload, sizeof responsePayload);
      xbee.send(txRequest);
      Serial.println("Données renvoyées !");

   xbee.send(txRequest);
   
           //data2 merde
      byte data2[] = {0x7E ,0x00 ,0x1A ,0x10 ,0x01 ,0x00 ,0x13 ,0xA2 ,0x00 ,0x41 ,0xF2 ,0x68 ,0x4C ,0xFF ,0xFE ,0x00 ,0x00 ,0x72 ,0x65 ,0x74 ,0x6F ,0x75 ,0x72 ,0x20 ,0x63 ,0x6F ,0x6F ,0x72};
      byte data3[] = {0x7E,0x00 ,0x12 ,0x10 ,0x01 ,0x00 ,0x13 ,0xA2 ,0x00 ,0x41 ,0xF2 ,0x68 ,0x4C ,0xFF ,0xFE ,0x00 ,0x00 ,0x54 ,0x45 ,0x53 ,0x54 ,0x15};
      //                 ,0x7E ,0x00 ,0x1A ,0x10 ,0x01 ,0x00 ,0x13 ,0xA2,0x00  ,0x41 ,0xF2 ,0x68 ,0x4C ,0xFF,0xFE,0x00,0x00,0x72,0x65,0x74,0x6F,0x75,0x72,0x20,0x63,0x6F,0x6F ,0x72 ,0x64 ,0x7D
      byte data1[] = {0x7E ,0x00 ,0x14 ,0x10 ,0x01 ,0x00 ,0x13 ,0xA2 ,0x00 ,0x41 ,0xF2 ,0x68 ,0x4C ,0xFF ,0xFE ,0x00 ,0x00 ,0x54 ,0x45 ,0x53 ,0x54 ,0x20 ,0x32 ,0xC3};  
      
      //byte data1[] = {0x7E, 0x00 ,0x17 ,0x10 ,0x01 ,0x00 ,0x13 ,0xA2 ,0x00 ,0x41 ,0xF2 ,0x68 ,0x4C ,0xFF ,0xFE ,0x00 ,0x00 ,0x74 ,0x65 ,0x73 ,0x74 ,0x20 ,0x65 ,0x76 ,0x6F ,0x69 ,0xC2};
      byte data[] =  {0x7E ,0x00 ,0x14 ,0x10 ,0x01 ,0x00 ,0x13 ,0xA2 ,0x00 ,0x41 ,0xF2 ,0x68 ,0xE9 ,0x00 ,0x00 ,0x02 ,0x4F,0x4B ,0x2C ,0x20 ,0x72 ,0x65 ,0x70 ,0x6F ,0x6E ,0x63 ,0x65 ,0x20 ,0x00 ,0x42};

     
     Serial1.flush(); 
     Serial.println("Données 1 renvoye: ");
     Serial1.write(data1,sizeof(data1));
     delay(2000);
     Serial1.flush(); 
     Serial.println("Données 3 renvoye: ");
     Serial1.write(data3,sizeof(data3));
     Serial1.flush(); 
      delay(2000);
    }


  }

  delay(100);
}

je precise que le "xbee.send(txRequest" ne fonctione pas

je me suis gouré de version .. jai enlevé ce qui etait relatif a l'adress 16 bit apres avoir compris mon erreur

je n'ai jamais utilisé de bibliothéque avec mes xbee (ça fait longtemps que je ne les utilise plus)

vous êtes sur un réseau local donc je pense qu'il n'y a pas de souci

tu urais un exemple de comment tu gere tes trames ??
bonne annee

Les modules XBee utilisent une adresse 64 bits unique pour identifier chaque module sur le réseau. Cette adresse du destinataire est à ranger dans la frame entre frame[5] et frame[12].

Les XBee permettent d'utiliser aussi une adresse 16 bits en plus de l'adresse 64 bits. On met cela dans frame[13] et frame[14]. De mémoire, si on utilise 0xFFFE, alors c'est une adresse spéciale qui signifie "utiliser uniquement l'adresse 64 bits" pour identifier le destinataire".

je n'ai plus ce code sous la main (sur une autre ordi qui n'est pas avec moi pour le moment) mais vous pouvez construire la trame à la main, un truc comme cela:

 uint8_t payload[] = "Bonjour Routeur"; // Données à envoyer
  uint8_t frame[100];
  uint8_t payloadLength = sizeof payload;
  uint8_t frameLength = 14 + payloadLength;

  frame[0] = 0x7E;               // Délimiteur de début
  frame[1] = 0x00;               // Longueur MSB
  frame[2] = 12 + payloadLength; // Longueur LSB
  frame[3] = 0x10;               // API Frame Type (Transmit Request)
  frame[4] = 0x01;               // Frame ID

  // Adresse 64 bits MSB (remplacer ces valeurs par l'adresse réelle de votre module XBee routeur)
  frame[5] = 0x00; 
  frame[6] = 0x13; 
  frame[7] = 0xA2; 
  frame[8] = 0x00; 
  frame[9] = 0x12; 
  frame[10] = 0x34; 
  frame[11] = 0x56; 
  frame[12] = 0x78; 
  // Adresse 64 bits LSB
  
  frame[13] = 0xFF;                // Pas d'adresse 16 bits
  frame[14] = 0xFE;                // Pas d'adresse 16 bits
  frame[15] = 0x00;                // Rayon de diffusion par défaut
  frame[16] = 0x00;                // Options

  // Ajout des données
  for (uint8_t i = 0; i < payloadLength; i++) {
    frame[17 + i] = payload[i]; 
  }

  // Calcul du checksum
  uint8_t checksum = 0;
  for (uint8_t i = 3; i < 17 + payloadLength; i++) {
    checksum += frame[i];
  }
  
  // Ajout du Checksum
  frame[17 + payloadLength] = 0xFF - checksum; 

ensuite la trame est envoyée simplement par un write()

  // Envoi de la trame
  for (uint8_t i = 0; i < frameLength; i++) {
    Serial.write(frame[i]);
  }

ou juste

Serial.write(frame, frameLength);

(à tester - j'ai tapé ça ici)

côté récepteur je lisais ce qui arrivait sur le port série aussi et je décodais la trame