Comment envoyer et recevoir en même temps avec un NRF24L01, librairie Mirf

Bonjours,

Je fabrique un robot, et j'ai besoin que la télécommande puisse envoyer et recevoir des information en même temps, de même du côté robot via le module NRF24L01 (acheté sur Banggood : 3pcs 1100 meter long distance nrf24l01+pa+lna wireless module with antenna Sale - Banggood.com ) en utilisant la librairie Mirf .

Les modules radios fonctionnent, puisque j'ai déjà réussis à les faire communiquer,
mais la télécommande ne faisait que envoyer et le robot ne faisait que recevoir. Voici les programmes :
(J'ai fait plusieurs post car sinon je dépassais la limite de caractères )

//programme téléversé sur arduino nano ( partie télécommande )

#include <SPI.h>      // Pour la communication via le port SPI
#include <Mirf.h>     // Pour la gestion de la communication
#include <nRF24L01.h> // Pour les définitions des registres du nRF24L01
#include <MirfHardwareSpiDriver.h> // Pour la communication SPI (ne cherchez pas à comprendre)

byte valeurs[9];//donnés à envoyer

char buzzer = 6;

const byte bouton1 = 4;
const byte bouton2 = 3;
const byte bouton3 = 2;

const byte joyx = A1;
int valx = 0;// valeur de joyx
const byte joyy = A2;
int valy = 0;// valeur de joyy
const byte potentiometre = A3;
int valp = 0;// valeur de ...
const byte joyx2 = A6;
int valx2;
const byte joyy2 = A7;
int valy2;
const byte boutonled = 5;
boolean  valled = 0;
boolean valled2 = 0;


////valeurs à envoyer//////////
boolean led2 = 0;
byte vitessem1 = 0;
byte vitessem2 = 0;
boolean moteur1 = 0;
boolean moteur2 = 0;
boolean onoffmoteur = 0;
byte servo1 = 0;
byte servo2 = 0;
byte servoled = 0;

void setup() {


  ///////configuration du module radio///////////////
  Mirf.cePin = 9; // Broche CE sur D9
  Mirf.csnPin = 10; // Broche CSN sur D10
  Mirf.spi = &MirfHardwareSpi; // On veut utiliser le port SPI hardware
  Mirf.init(); // Initialise la bibliothéque

  Mirf.channel = 1; // Choix du cannal de communication (128 canaux disponible, de 0 à 127)
  Mirf.payload = sizeof(byte) * 9; // Taille d'un message (maximum 32 octets)(9 signifit le nombre de valeurs à envoyer)1 byte = 1 octet
  Mirf.config(); // Sauvegarde la configuration dans le module radio

  Mirf.setTADDR((byte *) "nrf02"); // Adresse de transmission
  Mirf.setRADDR((byte *) "nrf01"); // Adresse de réception

  Serial.begin(9600);

  pinMode(joyx, INPUT);
  pinMode(joyy, INPUT);
  pinMode(potentiometre, INPUT);
  pinMode(joyx2, INPUT);
  pinMode(joyy2, INPUT);
  pinMode(boutonled, INPUT);

}

void loop() {

  /////////////////////////////////////////////////////////////////////////
  //  //  //  //  //  //corps du programme ///  //  //  //  //  //  //  //
  /////////////////////////////////////////////////////////////////////////

  valx = analogRead(joyx);
  valy = analogRead(joyy);
  valp = analogRead(potentiometre);
  valx2 = analogRead(joyx2);
  valy2 = analogRead(joyy2);
  valled = digitalRead(boutonled);

  //////////////////////////////////////////
  if (valled == 1) {
    if (valled2 == 1) {
      led2 = !led2;
      valled2 = 0;
    }
  }
  else {
    valled2 = 1;
  }

  //////////////////////////////////////////////////////////

  if ((valx2 > 500) && (valx2 < 540)) {
    servo1 = 90;
  }
  else if ((valx2 < 500) && (valx2 > 10))  {
    servo1 = map (valx2, 11, 499, 166, 91);
    //servo1 = 134;
  }
  else if ((valx2 > 540) && (valx2 < 1010)) {
    servo1 = map (valx2, 540, 1023, 89, 16);
    //servo1 = 46;
  }
  else if (valx2 > 1010) {
    servo1 = 15;
  }
  else if (valx2 < 10) {
    servo1 = 167;
  }

  //////////////////////////////////////////////////////

  if ((valy2 > 485) && (valy2 < 545)) {
    servo2 = 165;
    servoled = 85;
  }
  else if ((valy2 > 545) && (valy2 < 1013))  {
    servo2 = map (valy2, 545, 1013, 164 , 79);
    servoled = map (valy2, 545 , 1013, 86, 139);
    //servo2 = 120;
    //servoled = 125;
  }
  else if (valy2 > 1013) {
    servo2 = 78;
    servoled = 140;
  }

  if (led2 == 0) {
    servoled = 85;
  }

  ////////////////////////////////////////////////////////////
  //mode 1: avence
  if ((valx >= 751) && (valy <= 750) && (valy >= 251))
  {
    vitessem1 = map (valp, 0, 1023, 80, 255);
    vitessem2 = map (valp, 0, 1023, 80, 255);

    moteur1 = 1;
    moteur2 = 1;

    onoffmoteur = 1;
  }
  //mode 2:recule
  else if ((valx <= 250) && (valy <= 750) && (valy >= 251))
  {

    vitessem1 = map (valp, 0, 1023, 80, 255);
    vitessem2 = map (valp, 0, 1023, 80, 255);

    moteur1 = 0;
    moteur2 = 0;

    onoffmoteur = 1;
  }
  //mode 3:tourne à gauche
  else if ((valx <= 750) && (valx >= 251) && (valy <= 250))
  {

    vitessem1 = map (valp, 0, 1023, 80, 255);
    vitessem2 = map (valp, 0, 1023, 80, 255);
    moteur1 = 0;
    moteur2 = 1;

    onoffmoteur = 1;
  }
  //mode 4:tourne à droite
  else if ((valx <= 750) && (valx >= 251) && (valy >= 751))
  {

    vitessem1 = map (valp, 0, 1023, 80, 255);
    vitessem2 = map (valp, 0, 1023, 80, 255);
    moteur1 = 1;
    moteur2 = 0;

    onoffmoteur = 1;
  }
  //mode 5:avant gauche
  else if ((valx >= 751) && (valy <= 250))
  {

    vitessem1 = map (valp, 0, 1023, 80, 127);
    vitessem2 = map (valp, 0, 1023, 80, 255);
    moteur1 = 1;
    moteur2 = 1;

    onoffmoteur = 1;
  }
  //mode 6:avant droite
  else if ((valx >= 751) && (valy >= 751))
  {
    vitessem1 = map (valp, 0, 1023, 80, 255);
    vitessem2 = map (valp, 0, 1023, 80, 127);
    moteur1 = 1;
    moteur2 = 1;

    onoffmoteur = 1;
  }
  //mode 7:arrière gauche
  else if ((valx <= 250) && (valy <= 250))
  {
    vitessem1 = map (valp, 0, 1023, 80, 127);
    vitessem2 = map (valp, 0, 1023, 80, 255);

    moteur1 = 0;
    moteur2 = 0;

    onoffmoteur = 1;
  }
  //mode 8:arrière droite
  else if ((valx <= 250) && (valy >= 751))
  {
    vitessem1 = map (valp, 0, 1023, 80, 255);
    vitessem2 = map (valp, 0, 1023, 80, 127);

    moteur1 = 0;
    moteur2 = 0;

    onoffmoteur = 1;
  }
  else {
    moteur1 = 0;
    moteur2 = 0;

    onoffmoteur = 0;
  }

  /////////////////////////////////////////////////////////////////////////
  //  //  //  //  //  //partie envoie des donnés ///  //  //  //  //  //  /
  /////////////////////////////////////////////////////////////////////////

  valeurs[0] = led2;
  valeurs[1] = vitessem1;
  valeurs[2] = vitessem2;
  valeurs[3] = moteur1;
  valeurs[4] = moteur2;
  valeurs[5] = onoffmoteur;
  valeurs[6] = servo1;
  valeurs[7] = servo2;
  valeurs[8] = servoled;

  Mirf.send((byte *) &valeurs); // On envoi le message
  while (Mirf.isSending()); // On attend la fin de l'envoi

  Serial.print(valeurs[0]);
  Serial.print(" ");
  Serial.print(valeurs[1]);
  Serial.print(" ");
  Serial.print(valeurs[2]);
  Serial.print(" ");
  Serial.print(valeurs[3]);
  Serial.print(" ");
  Serial.print(valeurs[4]);
  Serial.print(" ");
  Serial.print(valeurs[5]);
  Serial.print(" ");
  Serial.print(valeurs[6]);
  Serial.print(" ");
  Serial.print(valeurs[7]);
  Serial.print(" ");
  Serial.print(valeurs[8]);
  Serial.print(" ");
  Serial.println();
}
//programme téléversé sur arduino mega ( partie robot )

#include <SPI.h>      // Pour la communication via le port SPI
#include <Mirf.h>     // Pour la gestion de la communication
#include <nRF24L01.h> // Pour les définitions des registres du nRF24L01
#include <MirfHardwareSpiDriver.h> // Pour la communication SPI

#include <Servo.h>
///////////////////////////////////////

const byte moteur1a = 44;
const byte moteur1b = 46;
const byte moteur2a = 47;
const byte moteur2b = 45;
const byte pwm1 = 3;
const byte pwm2 = 2;

const byte ledpin = 22;

Servo pinservo1;
Servo pinservo2;
Servo pinservoled;

//////////////////////////////////////
byte valeurs[9]; //donnés à recevoir

boolean moteur1 = 0;
boolean moteur2 = 0;
boolean onoffmoteur = 0;
byte Vitessem1 = 0;
byte Vitessem2 = 0;
boolean led = 0;
byte servo1 = 0;
byte servo2 = 0;
byte servoled = 0;
boolean onoffservo1 = 0;

void setup() {

 ////////////////////////////////////////////

 Serial.begin(9600);

///////configuration du module radio///////////////

 Mirf.cePin = 48; // Broche CE sur D48
 Mirf.csnPin = 53; // Broche CSN sur D53
 Mirf.spi = &MirfHardwareSpi; // On veut utiliser le port SPI hardware
 Mirf.init(); // Initialise la bibliothéque

 Mirf.channel = 1; // Choix du cannal de communication (128 canaux disponible, de 0 à 127)
 Mirf.payload = sizeof(byte) * 9; // Taille d'un message (maximum 32 octets)(9 signifit le nombre de valeurs à recevoir) 1 byte = 1 octet
 Mirf.config(); // Sauvegarde la configuration dans le module radio

 Mirf.setTADDR((byte *) "nrf01"); // Adresse de transmission
 Mirf.setRADDR((byte *) "nrf02"); // Adresse de réception

 ////////////////////////////////////////

 pinMode(moteur1a, OUTPUT);
 pinMode(moteur1b, OUTPUT);
 pinMode(pwm1, OUTPUT);
 pinMode(moteur2a, OUTPUT);
 pinMode(moteur2b, OUTPUT);
 pinMode(pwm2, OUTPUT);

 pinMode(ledpin, OUTPUT);

 analogWrite(pwm1, 0);
 digitalWrite(moteur1a, LOW);
 digitalWrite(moteur1b, LOW);

 analogWrite(pwm2, 0);
 digitalWrite(moteur2a, LOW);
 digitalWrite(moteur2b, LOW);

 pinservo1.attach(7);
 pinservo2.attach(6);
 pinservoled.attach(5);

 pinservo1.write(90);
 pinservo2.write(165);
 pinservoled.write(85);

}

void loop() {

 /////////////////////////////////////////////////////////////////////////
 //  //  //  //  //  //partie réception des donnés ///  //  //  //  //  //  /
 /////////////////////////////////////////////////////////////////////////

 if (Mirf.dataReady()) {
   Mirf.getData((byte *) &valeurs); // Réception du paquet

   led = valeurs[0];
   Vitessem1 = valeurs[1];
   Vitessem2 = valeurs[2] ;
   moteur1 = valeurs[3] ;
   moteur2 = valeurs[4] ;
   onoffmoteur = valeurs[5] ;
   servo1 = valeurs[6] ;
   servo2 = valeurs[7]  ;
   servoled = valeurs[8]  ;

 }

 Serial.print(valeurs[0]);
 Serial.print(" ");
 Serial.print(valeurs[1]);
 Serial.print(" ");
 Serial.print(valeurs[2]);
 Serial.print(" ");
 Serial.print(valeurs[3]);
 Serial.print(" ");
 Serial.print(valeurs[4]);
 Serial.print(" ");
 Serial.print(valeurs[5]);
 Serial.print(" ");
 Serial.print(valeurs[6]);
 Serial.print(" ");
 Serial.print(valeurs[7]);
 Serial.print(" ");
 Serial.print(valeurs[8]);
 Serial.print(" ");
 Serial.println();

/////////////////////////////////////////////////////////////////////////
 //  //  //  //  //  //corps du programme ///  //  //  //  //  //  //  //
 /////////////////////////////////////////////////////////////////////////

 if (led == 1) {
   digitalWrite(ledpin, HIGH);
 }
 else if (led == 0) {
   digitalWrite(ledpin, LOW);
 }

 ///////////////////////////////////////////////////
 pinservo1.write(servo1);
 pinservo2.write(servo2);
 pinservoled.write(servoled);

 ////////////////////////////////////////////////
 if (onoffmoteur == 1) {  //moteur

   if (moteur1 == 0) {
     digitalWrite(moteur1a, HIGH);
     digitalWrite(moteur1b, LOW);
   }
   else if (moteur1 == 1) {
     digitalWrite(moteur1a, LOW);
     digitalWrite(moteur1b, HIGH);
   }

   if (moteur2 == 0) {
     digitalWrite(moteur2a, HIGH);
     digitalWrite(moteur2b, LOW);
   }
   else if (moteur2 == 1) {
     digitalWrite(moteur2a, LOW);
     digitalWrite(moteur2b, HIGH);
   }

   analogWrite(pwm1, Vitessem1);
   analogWrite(pwm2, Vitessem2);

 }
 else if (onoffmoteur == 0) { //moteur
   analogWrite(pwm1, 0);
   digitalWrite(moteur1a, LOW);
   digitalWrite(moteur1b, LOW);

   analogWrite(pwm2, 0);
   digitalWrite(moteur2a, LOW); 
   digitalWrite(moteur2b, LOW);
 }

}

Désolé je dois attendre 5 minutes entre chaque post.

Ensuite, j'ai fait ces nouveaux programmes si dessous (différents des premiers, ajout : d'un écran oled, de boutons et d'un niveau de batterie pour le robot ). Pour cela j'ai besoin que chaque module radio envoie et reçoit des informations, mais cela ne fonction pas ! :frowning:

Merci d’avance pour votre aide !!! :wink: :smiley: :wink:

( Il reste encore minimum 2 post )

//programme téléversé sur arduino nano ( partie télécommande )

#include <SPI.h>      // Pour la communication via le port SPI
#include <Mirf.h>     // Pour la gestion de la communication
#include <nRF24L01.h> // Pour les définitions des registres du nRF24L01
#include <MirfHardwareSpiDriver.h> // Pour la communication SPI (ne cherchez pas à comprendre)
//pour l'écran///
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);

byte valeurs[13];//donnés à envoyer et recevoir

char buzzer = 6;

const byte bouton1 = 4;
const byte bouton2 = 3;
const byte bouton3 = 2;

const byte joyx = A1;
int valx = 0; // valeur de joyx
const byte joyy = A2;
int valy = 0; // valeur de joyy
const byte potentiometre = A3;
int valp = 0; // valeur de ...
const byte joyx2 = A6;
int valx2;
const byte joyy2 = A7;
int valy2;
const byte boutonled = 5;
boolean  valled = 0;
boolean valled2 = 0;


////valeurs à envoyer et recevoir//////////
boolean led2 = 0;
byte vitessem1 = 0;
byte vitessem2 = 0;
boolean moteur1 = 0;
boolean moteur2 = 0;
boolean onoffmoteur = 0;
byte servo1 = 0;
byte servo2 = 0;
byte servoled = 0;
boolean valbouton1 = 0;
boolean valbouton2 = 0;
boolean valbouton3 = 0;
byte valbatmin = 0;

boolean conn;
boolean a = 0;
boolean d = 0;

long temps;
byte sec;
byte mins;

//////////dessin pour l'écran///////////////////////////
static const unsigned char PROGMEM batterie0[] =
{ B11111111, B11111100,
 B10000000, B00000100,
 B10000000, B00000111,
 B10000000, B00000111,
 B10000000, B00000111,
 B10000000, B00000100,
 B11111111, B11111100
};

static const unsigned char PROGMEM batterie1[] =
{ B11111111, B11111100,
 B10000000, B00000100,
 B10110000, B00000111,
 B10110000, B00000111,
 B10110000, B00000111,
 B10000000, B00000100,
 B11111111, B11111100
};

static const unsigned char PROGMEM batterie2[] =
{ B11111111, B11111100,
 B10000000, B00000100,
 B10110111, B00000111,
 B10110111, B00000111,
 B10110111, B00000111,
 B10000000, B00000100,
 B11111111, B11111100
};

static const unsigned char PROGMEM batterie3[] =
{ B11111111, B11111100,
 B10000000, B00000100,
 B10110111, B01110111,
 B10110111, B01110111,
 B10110111, B01110111,
 B10000000, B00000100,
 B11111111, B11111100
};



static const unsigned char PROGMEM attention[] =
{ B00000001, B00000000,
 B00000010, B10000000,
 B00000010, B10000000,
 B00000101, B01000000,
 B00000101, B01000000,
 B00001000, B00100000,
 B00010001, B00010000,
 B00011111, B11110000

};

static const unsigned char PROGMEM ledlow[] =
{ B00000000, B00000000,
 B00000011, B11000000,
 B00000100, B00100000,
 B00001000, B00010000,
 B00001000, B00010000,
 B00001000, B00010000,
 B00001000, B00010000,
 B00001000, B00010000,
 B00011111, B11111000
};

static const unsigned char PROGMEM ledhigh[] =
{ B01000100, B00010010,
 B00100011, B11000100,
 B00010100, B00101000,
 B00001000, B00010000,
 B11101000, B00010111,
 B00001000, B00010000,
 B11101000, B00010111,
 B00001000, B00010000,
 B00011111, B11111000
};

static const unsigned char PROGMEM connectionoui[] =
{ B11111111, B10000000,
 B10001000, B10000000,
 B01001001, B00000000,
 B00101010, B10000000,
 B00011100, B10100000,
 B00001000, B10101000,
 B00001000, B10101010,
 B00001000, B10101010,
 B00000000, B10101010
};

static const unsigned char PROGMEM connectionnon[] =
{ B11111111, B10000000,
 B10001000, B10000000,
 B01001001, B00000000,
 B00101010, B01000010,
 B00011100, B00100100,
 B00001000, B00011000,
 B00001000, B00011000,
 B00001000, B00100100,
 B00000000, B01000010
};
void setup() {

 ///////configuration du module radio///////////////
 Mirf.cePin = 9; // Broche CE sur D9
 Mirf.csnPin = 10; // Broche CSN sur D10
 Mirf.spi = &MirfHardwareSpi; // On veut utiliser le port SPI hardware
 Mirf.init(); // Initialise la bibliothéque

 Mirf.channel = 1; // Choix du cannal de communication (128 canaux disponible, de 0 à 127)
 Mirf.payload = sizeof(byte) * 13; // Taille d'un message (maximum 32 octets) (13 signifit le nombre de valeur à envoyer ou envoyer)1 byte = 1 octet
 Mirf.config(); // Sauvegarde la configuration dans le module radio

 Mirf.setTADDR((byte *) "nrf02"); // Adresse de transmission
 Mirf.setRADDR((byte *) "nrf01"); // Adresse de réception

 Serial.begin(9600);

 pinMode(joyx, INPUT);
 pinMode(joyy, INPUT);
 pinMode(potentiometre, INPUT);
 pinMode(joyx2, INPUT);
 pinMode(joyy2, INPUT);
 pinMode(boutonled, INPUT);
 pinMode(bouton1, INPUT);
 pinMode(bouton2, INPUT);
 pinMode(bouton3, INPUT);

 display.begin(SSD1306_SWITCHCAPVCC, 0x3C);

 display.clearDisplay();
 display.display();

 temps = millis();
}

void loop() {

 /////////////////////////////////////////////////////////////////////////
 //  //  //  //  //  //corps du programme ///  //  //  //  //  //  //  //
 /////////////////////////////////////////////////////////////////////////

 valx = analogRead(joyx);
 valy = analogRead(joyy);
 valp = analogRead(potentiometre);
 valx2 = analogRead(joyx2);
 valy2 = analogRead(joyy2);
 valled = digitalRead(boutonled);
 valbouton1 = digitalRead(bouton1);
 valbouton2 = digitalRead(bouton2);
 valbouton3 = digitalRead(bouton3);

 /////////////////////////////////////////////////////////////
 if ((millis() - temps) >= 1000) {
   sec++;
   temps = millis();
 }

 if (sec == 60) {
   mins++;
   sec = 0;
 }


 //////////////////////////////////////////////////////////

 display.clearDisplay();

 display.setTextSize(1);
 display.setTextColor(WHITE);
 display.setCursor(20, 0);
 display.println(valbatmin);
 display.setCursor(23, 2);
 display.println(",");

 display.setTextSize(2);
 display.setTextColor(WHITE);
 display.setCursor(5, 15);
 display.println(sec);
 display.setCursor(27, 15);
 display.println(":");
 display.setCursor(35, 15);
 display.println(mins);

 //valbatmin = map(valp, 0, 1023, 0, 42);  //pour tester avec un potentiomètre

 if (valbatmin > 40) {
   display.drawBitmap(0, 0, batterie3, 16, 7, 1);
 }

 if ((valbatmin == 40) || (valbatmin == 39)) {
   display.drawBitmap(0, 0, batterie2, 16, 7, 1);
 }


 if ((valbatmin == 38) || (valbatmin == 37)) {
   display.drawBitmap(0, 0, batterie1, 16, 7, 1);
 }

 if (valbatmin <= 36) {
   display.drawBitmap(0, 0, batterie0, 16, 7, 1);
   display.drawBitmap(35, 0, attention, 16, 8, 1);
 }

 if (led2 == 1) {
   display.drawBitmap(112, 0, ledhigh, 16, 9, 1);
 }
 else {
   display.drawBitmap(112, 0, ledlow, 16, 9, 1);
 }

 if (conn == 1) {
   display.drawBitmap(80, 0, connectionoui, 16, 9, 1);
 }
 else {
   display.drawBitmap(80, 0, connectionnon, 16, 9, 1);
 }

 display.display();
 /////////////////////////////////////////////
 if ((valbatmin == 38) && ( d == 0)) {
   tone(buzzer, 1500, 200);
   d = 1;
 }

 if ((valbatmin > 39) && ( d == 1)) {
   d = 0;
 }

 /////////////////

 if ((valbatmin <= 36) && ( a == 0)) {
   tone(buzzer, 2000, 500);
   a = 1;
 }

 if ((valbatmin > 39) && ( a == 1)) {
   a = 0;
 }
 //////////////////////////////////////////
 if (valled == 1) {
   if (valled2 == 1) {
     led2 = !led2;
     valled2 = 0;
   }
 }
 else {
   valled2 = 1;
 }

La suite du programme après.

perso j'utiliser la librarie RF24 avec mes NRF24L01 - j'avais écrit un petit tuto de communication bi-directionnelle si ça peut vous intéresser

 if ((valx2 > 500) && (valx2 < 540)) {
   servo1 = 90;


 }
 else if ((valx2 < 500) && (valx2 > 10))  {
   servo1 = map (valx2, 11, 499, 166, 91);  
 }
 else if ((valx2 > 540) && (valx2 < 1010)) {
   servo1 = map (valx2, 540, 1023, 89, 16);
 }
 else if (valx2 > 1010) {
   servo1 = 15;
 }
 else if (valx2 < 10) {
   servo1 = 167;
 }
 //////////////////////////////////////////////////////
 if ((valy2 > 485) && (valy2 < 545)) {
   servo2 = 165;
   servoled = 85;
 }
 else if ((valy2 > 545) && (valy2 < 1013))  {
   servo2 = map (valy2, 545, 1013, 164 , 79);
   servoled = map (valy2, 545 , 1013, 86, 139);
 }
 else if (valy2 > 1013) {
   servo2 = 78;
   servoled = 140;
 }

 if (led2 == 0) {
   servoled = 85;
 }
 ////////////////////////////////////////////////////////////
 //mode 1: avence


 if ((valx >= 751) && (valy <= 750) && (valy >= 251))
 {
   vitessem1 = map (valp, 0, 1023, 80, 255);
   vitessem2 = map (valp, 0, 1023, 80, 255);
   moteur1 = 1;
   moteur2 = 1;
   onoffmoteur = 1;
 }
 //mode 2:recule
 else if ((valx <= 250) && (valy <= 750) && (valy >= 251))
 {
   vitessem1 = map (valp, 0, 1023, 80, 255);
   vitessem2 = map (valp, 0, 1023, 80, 255);
   moteur1 = 0;
   moteur2 = 0;
   onoffmoteur = 1;
 }
 //mode 3:tourne à gauche
 else if ((valx <= 750) && (valx >= 251) && (valy <= 250))
 {
   vitessem1 = map (valp, 0, 1023, 80, 255);
   vitessem2 = map (valp, 0, 1023, 80, 255);
   moteur1 = 0;
   moteur2 = 1;
   onoffmoteur = 1;


 }
 //mode 4:tourne à droite
 
else if ((valx <= 750) && (valx >= 251) && (valy >= 751))
{


  vitessem1 = map (valp, 0, 1023, 80, 255);
   vitessem2 = map (valp, 0, 1023, 80, 255);
   moteur1 = 1;
   moteur2 = 0;
   onoffmoteur = 1;


 }
 //mode 5:avant gauche


 else if ((valx >= 751) && (valy <= 250))


 {
   vitessem1 = map (valp, 0, 1023, 80, 127);
   vitessem2 = map (valp, 0, 1023, 80, 255);
   moteur1 = 1;
   moteur2 = 1;

   onoffmoteur = 1;


 }
//mode 6:avant droite
 else if ((valx >= 751) && (valy >= 751))
{


   vitessem1 = map (valp, 0, 1023, 80, 255);
   vitessem2 = map (valp, 0, 1023, 80, 127);
   moteur1 = 1;
   moteur2 = 1;

   onoffmoteur = 1;


 }
 //mode 7:arrière gauche


 else if ((valx <= 250) && (valy <= 250))


 {
 vitessem1 = map (valp, 0, 1023, 80, 127);
   vitessem2 = map (valp, 0, 1023, 80, 255);
   moteur1 = 0;
   moteur2 = 0;

   onoffmoteur = 1;


 }
 //mode 8:arrière droite

 else if ((valx <= 250) && (valy >= 751))


 {
   vitessem1 = map (valp, 0, 1023, 80, 255);
   vitessem2 = map (valp, 0, 1023, 80, 127);
   moteur1 = 0;
   moteur2 = 0;

   onoffmoteur = 1;


 }

 else {


   moteur1 = 0;
   moteur2 = 0;
   onoffmoteur = 0;


 }
 /////////////////////////////////////////////////////////////////////////
 //  //  //  //partie envoie et réception des donnés  ///  //  //  //  //
 /////////////////////////////////////////////////////////////////////////
 if (Mirf.dataReady()) {
   conn = 1;
   Mirf.getData((byte *) &valeurs); // Réception du paquet


   valbatmin = valeurs[12];


 }
 else {
   conn = 0;
 }
 ///////////////////////////////////////
 valeurs[0] = led2;
 valeurs[1] = vitessem1;
 valeurs[2] = vitessem2;
 valeurs[3] = moteur1;
 valeurs[4] = moteur2;
 valeurs[5] = onoffmoteur;
 valeurs[6] = servo1;
 valeurs[7] = servo2;
 valeurs[8] = servoled;
 valeurs[9] = valbouton1;
 valeurs[10] = valbouton2;
 valeurs[11] = valbouton3;  


 ///////////////////////////////////////////////////
 Mirf.powerDown(); //mise en veille et arret de la réception et de l'envoie
 Mirf.powerUpTx(); //activation de l'envoie


 Mirf.send((byte *) &valeurs); // On envoi le message
 while (Mirf.isSending()); // On attend la fin de l'envoi


 Mirf.powerDown(); //mise en veille et arret de la réception et de l'envoie
 Mirf.powerUpRx(); //activation de la réception


 //////////////////////////////////////////////


 Serial.print(valeurs[0]);
 Serial.print(" ");
 Serial.print(valeurs[1]);
 Serial.print(" ");
 Serial.print(valeurs[2]);
 Serial.print(" ");
 Serial.print(valeurs[3]);
 Serial.print(" ");
 Serial.print(valeurs[4]);
 Serial.print(" ");
 Serial.print(valeurs[5]);
 Serial.print(" ");
 Serial.print(valeurs[6]);
 Serial.print(" ");
 Serial.print(valeurs[7]);
 Serial.print(" ");
 Serial.print(valeurs[8]);
 Serial.print(" ");
 Serial.print(valeurs[9]);
 Serial.print(" ");
 Serial.print(valeurs[10]);
 Serial.print(" ");
 Serial.print(valeurs[11]);
 Serial.print(" ");
 Serial.print(valeurs[12]);
 Serial.print(" ");
 Serial.println();


}

ok merci beaucoup je vais regarder ça et essayer ! ça va surement résoudre mon problème !

MIRF n'a pas été mis à jour depuis 6 ans.. un éternité dans ce bas monde :slight_smile:

sinon testez le code de ping pong de ce tuto avec MIRF

Oui c'est long 6 ans, j'avais déjà essayé le code ping pong mais ça ne marché pas (pas pour moi en tout cas )

si ping pong ne fonctionne pas c'est que soit vous avez un soucis de branchement (puissance fournie aux modules par exemple - ils sont capricieux) soit la librairie n'est plus bonne (je ne l'utilise pas donc peux pas vous dire)

--> en tout cas pas la peine d'aller plus loin tant que ping-pong ne fonctionne pas

Si mes modules radio fonctionnent,c'est juste que je n'arrivé pas à envoyer et recevoir en même temps. J'ai regardé votre tuto (le code ) mais je ne comprend pas tout :astonished: pourriez-vous m'envoyez la partie permettant l'envoie et la réception :smiley: Merci d'avance !

tout le code est posté dans le premier post - faut prendre le temps de lire le tuto...

la fonction qui envoie un message est

void envoyerMessage(uint8_t nombre)
{
  radio.stopListening();   // On arrête d'écouter pour qu'on puisse émettre

  if (!radio.write( &nombre, sizeof(nombre) )) {
    Serial.println(F("erreur d'envoi"));
  }
  radio.startListening(); // On se remet en mode écoute
}

et la fonction qui écoute

uint8_t ecouterRadio()
{
  uint8_t message = 0; // 0 = pas de commande

  if ( radio.available()) {
    while (radio.available()) {
      radio.read( &message, sizeof(message) );  // on lit l'octet reçu (si plusieurs messages on ne conserve que le dernier)
    }
    Serial.print(F("J'ai recu ")); Serial.println(message);
  }
  return message;
}

Pour envoyer par exemple 210 je dis "nombre = 210 ;" ?

Pour la réception on peut lire que le dernier octet et pas tout le buffer ?

Le message reçut ce stock dans "message" ? (je pense que oui )

A quoi sert "return message;" ?

Merci beaucoup !

oui tel que c'est codé je n'échange qu'un octet

  return message; c'est dans ma fonction, il retourne à l'appelant la valeur lue ou 0 si'l n'y avait rien à lire

Merci beaucoup de me répondre aussi rapidement !!!

D'accord pour le return message j'ai compris.

Mais du coup pour envoyer ou recevoir plusieurs octets comment on peut faire ?

faut modifier un tantinet le code :slight_smile:

par exemple si au lieu d'avoir un uint8_t nombre à envoyer j'avais un structure toto avec mes octets dedans, et bien on passe la structure par référence à envoyerMessage() et le code fonctionnera

 radio.write( &toto, sizeof(toto)

de méme côté réception si vous avez une structure au lieu de uint8_t message

radio.read( &message, sizeof(message) );  va bien lire tous les octets de la structure

Mais peut on faire un tableau d'octet avec toto ( "toto[8]" ) pour envoyer plusieurs valeurs ? qu'est ce que toto (int , byte , long ...)
Peut on faire :

//pour émetteur

byte toto[3];
toto[1] = 23;
toto[2] = 156;
toto[3] = 203;

radio.write( &toto, sizeof(toto));

//pour récepteur
byte message[3];

byte valeurs1;
byte valeurs2;
byte valeurs3;

radio.read( &message, sizeof(message) );
 valeurs1 = message[1];
 valeurs2 = message[2];
 valeurs3 = message[3];

oui un tableau fonctionne aussi si toutes les données sont du même type. il suffit d'avoir le même tableau en réception

Merci beaucoup ! Maintenant je vais essayé sur mon robot, je vous dit si tout marche comme sur des roulettes !

Il faut le reste du setup() of course - pour définir les pipes