Communications bidirectionnelles (module NRF24L01)

Bonjour,

Dans mon projet, j'ai une carte Arduino UNO qui communique avec une carte Arduino MEGA 2560. En gros, la carte UNO est une télécommande et la MEGA est un robot.

J'ai 4 modes de fonctionnement : 0 -> arrêt 1 -> manuel 2 -> automatique 3 -> erreur J'ai commencé à écrire les 2 premiers modes en premiers car ce sont les plus faciles. Pour ces modes( 1 et 0), je n'ai besoin que d'une communication unidirectionnelle. Pour cela, j'avais écrit 3 fonctions me permettant ces communications (voir en bas du post).

boolean RF_send ( boolean debug );
boolean RF_receive ( boolean debug );

Cependant, maintenant, que je dois m'attaquer au mode automatique, je ne sais pas du tout comment m'y prendre... Car maintenant les communications sont bi-directionnelles pour que les deux modules "discutent" entre eux... J'ai écrit la fonction suivante, mais je ne crois pas qu'elle aille bien car ça ne marche pas (la communication, pas la compilation)...

boolean RF_waitMsg ( boolean transmitMsg, boolean debug );

Auriez-vous une idée sur comment réaliser cette "discussion" bi-directionnelle ? Merci d'avance

RF.h

//-----------------------------------------
//  Préfixe pour le module RF : "RF_"
//-----------------------------------------


#define RF_MEGA_CE    48
#define RF_MEGA_CSN   49

#define RF_UNO_CE     8
#define RF_UNO_CSN    7

#define RF_PAYLOAD    32
#define RF_CHANNEL    1

  // Séparateur pour les messages
#define RF_SEP        ":"

  // Adresse de la carte MEGA
#define RF_MEGA    (byte *)"ICAREproject_MEGA"
  // Adresse de la carte UNO
#define RF_UNO     (byte *)"ICAREproject_UNO"

/*
 * RF_msgT : Message qui sera envoyé par RF
 * RF_msgR : Message qui sera reçu par RF
 */
char RF_msgT[RF_PAYLOAD] = "";
char RF_msgR[RF_PAYLOAD] = "";

/*
 * RF_bArray : tableau d'octet pour la transmission
 */
byte RF_bArray[RF_PAYLOAD];

RF.ino

/**
 * Fonction permettant d'envoyer une chaîne de caractère
 * @param msg    Message à envoyer
 */
void RF_send ( boolean debug ) {
  // On converti la chaîne à envoyer en octets
  strcpy( (char *)RF_bArray, RF_msgT );
  
  if (debug)
    Serial.println("\nMessage en cours de transmission :\n\t" + String(RF_msgT));
  
  // On envoie
  Mirf.send( RF_bArray );
  while (Mirf.isSending());
  
  if (debug)
    Serial.println("\t!!Envoi termine!!");
}


/**
 * Fonction permettant de recevoir une chaîne de caractère
 * @return Message reçu
 */
boolean RF_receive ( boolean debug ) {
  if(!Mirf.isSending() && Mirf.dataReady()) {
    Mirf.getData(RF_bArray);
    
      // On copie les octets reçus dans la chaîne de caractère (vide aussi la chaîne)
    strcpy( RF_msgR, (char *)RF_bArray );
    
    if (debug)
      Serial.println("\nMessage recu :\n\t" + String(RF_msgR));
    
    return true;
  }
  else
    return false;
}


/**
 * Fonction permettant d'attendre la réception d'une chaîne de caractère
 * @return VRAI s'il y a eu une erreur
 */
boolean RF_waitMsg ( boolean transmitMsg, boolean debug ) {
    // Si on demande de transmettre un message
  if ( transmitMsg ) {
    do {
        // On envoie le message
      RF_send( debug );
      
        // On initialise le time out
      unsigned long time = millis();
      boolean timeOut = false;
       
      while ( !Mirf.dataReady() && !timeOut ) {
          // Timeout de 1s avant de renvoyer
        if ( ( millis() - time ) > 1000 )
          timeOut = true;
      }
    } while ( !Mirf.dataReady() );
    
    return !RF_receive( debug );
  }
    // Si on demande juste d'attendre la réception
  else {
    unsigned long time = millis();
    
    while ( !Mirf.dataReady() ) {
        // Timeout de 10s
      if ( ( millis() - time ) > 10000 )
        return true;
    }
  
    return !RF_receive( debug );
  }
}



/**
 * Fonction de renseignement du message
 * @param message   Message à intégrer au message
 */
void RF_msg_setStr ( const char* message ) {
  strcpy(RF_msgT, message);
  strcat(RF_msgT, RF_SEP);
}

/**
 * Fonction d'ajout d'une chaîne de caractère au message
 * @param message   Message à intégrer au message
 */
void RF_msg_addStr ( const char* message ) {
  strcat(RF_msgT, message);
  strcat(RF_msgT, RF_SEP);
}

/**
 * Fonction d'ajout d'un nombre au message
 * @param nombre   Nombre à intégrer au message
 */
void RF_msg_addInt ( int nombre ) {
  char work[sizeof(int)];
  itoa(nombre, work, 10);
  strcat(RF_msgT, work);
  strcat(RF_msgT, RF_SEP);
}