nRF24L01 responder mensaje recibido

Hola a todos, a ver si me podeis echar una mano, que despues de mucho mirar y leer, no encuentro la solucion, seguramente porque algo estoy haciendo mal.
Decir que aunque uno es un arduino Uno y el otro un Mega, si intercambio los codigos entre uno y otro el primer mensaje “hola mundo” lo envia sin problema independientemente del arduino donde este compilado pero hay se queda.
Aqui los codigos, algo sencillo para probar

Maestro

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

//const int pinCE = 9;//mega
//const int pinCSN = 10;//mega
const int pinCE = 4;//uno
const int pinCSN = 5;//uno
RF24 radio(pinCE, pinCSN);
 
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };

char data[16]="Hola mundo" ;
char dataR[16];
char dataS[16]="perfecto";

byte envio=0;
byte recibido=0;
 
void setup(void)
{
  radio.begin(); //Inicio del modulo nRF24L01+
  radio.setRetries(15, 15);// Cinfiguracion del numero maximo de reintentos
  //Apertura de los canales de comunicacion
    radio.openWritingPipe(pipes[0]);
    radio.openReadingPipe(1,pipes[1]);
}
 
void loop(void)
{
if (envio==0)
   {
   radio.stopListening(); // Paramos la escucha para poder escribir

   radio.write(data, sizeof(data));
    delay(1000);
    

   envio=1;
   }
if (envio==1)
   {
   radio.startListening(); // Activando el modulo en modo de escucha 
   if (radio.available())
   {
    radio.read(dataR, sizeof(dataR)); 
      Serial.println(dataR);
      delay(20);
      envio=2;
    }
   }
if (envio==2)
   {
   radio.stopListening(); // Paramos la escucha para poder escribir

   radio.write(dataS, sizeof(dataS));
    delay (1000);
    //radio.startListening(); // Activando el modulo en modo de escucha

   envio=0;
   }
}

Esclavo

#include <nRF24L01.h>
#include <RF24.h>
#include <RF24_config.h>
#include <SPI.h>
#include <printf.h>
 
//const int pinCE = 4;//uno
//const int pinCSN = 5;//uno

const int pinCE = 9;//mega
const int pinCSN = 10;//mega
RF24 radio(pinCE, pinCSN);
 
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };

char data[16];
char dataR[16]="recibido" ;
char dataS[16];

byte envio=0;
byte recibido=0; 
 
void setup(void)
{
   Serial.begin(9600);
  radio.begin(); //Inicio del modulo nRF24L01+
  radio.setRetries(15, 15); //Configuracion del numero de intentos
  //Apertura de los canales de comunicacion
    radio.openWritingPipe(pipes[1]);
    radio.openReadingPipe(1,pipes[0]);
  radio.startListening(); // Activando el modulo en modo de escucha

}
 
void loop(void)
{
  if (recibido==0)
  {
   if (radio.available())
   {
      //int done = radio.read(data, sizeof(data)); 
      radio.read(data, sizeof(data)); 
      Serial.println(data);
      delay(1000);
      recibido=1;
   }
  }

 if (recibido==1)
    {
      radio.stopListening(); // Paramos la escucha para poder escribir
     radio.write(dataR, sizeof(dataR));
     delay(20);
     recibido=2; 
    }
  if (recibido==2)
  {
   if (radio.available())
   {
      radio.startListening(); // Activando el modulo en modo de escucha 
      radio.read(dataS, sizeof(dataS)); 
      Serial.println(dataS);
      delay(1000);
      //radio.stopListening(); // Paramos la escucha para poder escribir
      recibido=0;
   }
  }    
 }

Bueno tu código tiene una lógica equivocada. Porque tienes tantos

if (radio.available())

Se pone uno solo que controla todo el flujo de msgs recibidos y luego se maneja el control de los paquetes.

Tu propia lógica esta conspirando con la recepción de los mismos.

Luego no se ponen delay() que detengan el código, olvida los delays y mas si hay comunicaciones.

Los tres data son iguales en tamaño, 16 bytes así que con uno solo basta.

Surbyte siempre estas al quite, siempre veo que intentas ayudar. No se que he hecho pero ahora funciona, creo que ha sido quitar un "if (radio.available())" Lo de los 3 datas iguales es porque si funcionaban seran diferentes y los delay para no complicarme mucho y darle algo de tiempo al programa. De todas formas, muchas gracias.

Es que debes hacerlo desde uno solo y desde ahi controlar el flujo de datos recibidos.