nRF24L01 + PA + LNA no envía datos

Hola. espero alguien me pueda ayudar con este problema.
resulta que tengo dos módulos nRF24L01 conectados a dos placas arduino uno usando un módulo adaptador conectado al bus ICSP por cada transceptor , el programa funciona correctamente hasta que remplazo los módulos por nRF24L01 + PA + LNA en donde creo que el problema es en el envió de datos, ya que al cambiar el modulo nRF24L01 + PA + LNA del reseptor por un modulo nRF24L01 normal se reciben los datos, pero no se reenvían.
Adjunto los dos códigos. Gracias .

//Receptor 

/*  ----------------------------------------------------------------
    SETISAEDU
    Codigo de prueba de transmision a larga distancia con NRF2401+.
    Codigo del Receptor
  --------------------------------------------------------------------
*/
#include <SPI.h>      //Libreria para usar el modulo SPI 
#include "nRF24L01.h" //Librerias del modulos nRF24L01+
#include "RF24.h"

RF24 radio(9, 10);//Declaracion de los pines de control CE y CSN para el modulo, se define "radio"

// Definicion de las direcciones de comunicacion
const uint64_t direccion1 = 0x7878787878LL;
const uint64_t direccion2 = 0xB3B4B5B6F1LL;
//Declaracion de variables y pines a usar
const char enviando = 4; //Pin indicador de envio
const char recibiendo = 5; //Pin indicador de recepcion

unsigned int RX[128];
//unsigned char TX[128];

bool TX_state = 0;

void setup(void)
{
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);
  Serial.begin(9600);//Inicializacion del puerto serial en el caso de tener depuracion por PC

  radio.begin(); //Inicio del modulo nRF24L01+
  radio.setPALevel(RF24_PA_MIN);  // Configuracion en modo de baja potencia
  radio.setDataRate(RF24_250KBPS);
  radio.setChannel(10); // Configuracion del canal de comunicacion
  //Apertura de los canales de comunicacion
  radio.openWritingPipe(direccion2);
  radio.openReadingPipe(1, direccion1);

  radio.startListening(); //Iniciamos en modo de escucha

  //Configuracion de pines de salida de los indicadores
  pinMode(enviando, OUTPUT);
  pinMode(recibiendo, OUTPUT);
  digitalWrite(enviando, LOW);
  digitalWrite(recibiendo, LOW);
  //Mensaje inicial
  Serial.println("Sistema de verificacion de coherencia en");
  Serial.println("envio de datos con el modulo  nRF24L01+");
  for (int x = 0; x < 128; x++)
  {
    RX[x] = 0;
  }

}

int j = 0, error_cont = 0;
bool test = 0 ;


void loop(void)
{

  if (radio.available())      // Comprobacion de datos recibidos
  {
    //Empezando recepcion
    digitalWrite(recibiendo, HIGH);
    bool done = false;
    unsigned long inicio = millis();

    radio.read( &RX[j], sizeof(RX[j])); //Funcion de lectura de datos
    Serial.print("Dato ");
    Serial.print(j);
    Serial.print(" recibido: ");
    Serial.println(RX[j]);
    digitalWrite(recibiendo, LOW);

    //Empezando el envio
    digitalWrite(enviando, HIGH);
    radio.stopListening(); // Paramos el modo de escucha para poder escribir
    bool ok = radio.write(&RX[j], sizeof(RX[j])); //Envio de datos
    if (!ok)
    {
      Serial.print("fallo el envio en el dato ");
      Serial.println(j);
      //return;
    } else 
    {
      Serial.print("Dato ");
      Serial.print(j);
      Serial.print(" enviado: ");
      Serial.println(RX[j]);
    }
    radio.startListening(); //Volvemos a la escucha
    digitalWrite(enviando, LOW);
    // delay(100);
    j++;
    if (j >= 128)
    {
      Serial.println("Fin de la transmision");
      for (int x = 0; x < 128; x++)
      {
        RX[x] = 0;
      }
      j = 0;
    }
  }
}
//emisor
  
/*  ----------------------------------------------------------------
    SETISAEDU
    Codigo de prueba de transmision a larga distancia con NRF2401+.
    Codigo del Transmisor
  --------------------------------------------------------------------
*/
#include <SPI.h>      //Libreria para usar el modulo SPI 
#include "nRF24L01.h" //Librerias del modulos nRF24L01+
#include "RF24.h"

RF24 radio(9, 10);//Declaracion de los pines de control CE y CSN para el modulo, se define "radio"

// Definicion de las direcciones de comunicacion
const uint64_t direccion1 = 0x7878787878LL;
const uint64_t direccion2 = 0xB3B4B5B6F1LL;

const char enviando = 4; //Pin indicador de envio
const char recibiendo = 5; //Pin indicador de recepcion
//Declaracion de todas las variables
unsigned int RX[128];
unsigned int TX[128];
unsigned char mul = 1;
bool TX_state = false;

int  j = 0, error_cont = 0;
bool test = 0;

void setup(void)
{
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);
  Serial.begin(9600); //Inicializacion del puerto serial para la comunicacion con la PC

  radio.begin(); //Inicio del modulo nRF24L01+
  radio.setPALevel(RF24_PA_MIN);  // Configuracion en modo de maxima potencia
  radio.setDataRate(RF24_250KBPS); //Configuracion de la velocidad de transmision
  radio.setChannel(10); // Configuracion del canal de comunicacion
  //Apertura de los canales de comunicacion
  radio.openWritingPipe(direccion1);
  radio.openReadingPipe(1, direccion2);

  //Configuracion de pines de salida de los indicadores
  pinMode(enviando, OUTPUT);
  pinMode(recibiendo, OUTPUT);
  digitalWrite(enviando, LOW);
  digitalWrite(recibiendo, LOW);
  //Mensaje inicial
  Serial.println("Sistema de verificacion de coherencia en");
  Serial.println("envio de datos con el modulo nRF24L01+");
  for (int x = 0; x < 128; x++)
  {
    RX[x] = 0;
    TX[x] = 0;
  }

}


void loop(void)
{
  //Serial.println("espera");
  if (Serial.available())
  {
    if (TX_state == false)
    {
      unsigned char temp = Serial.read();
      if (temp == '*')
      {
        TX_state = true;
        return;
      } else
      {
        mul = temp - 48;
        Serial.print("Cambio de multiplicador por ");
        Serial.println(mul);
      }
    }
  }

  if (TX_state == true)
  {
    Serial.println("Iniciando envios");
    Serial.print("Multiplicador= ");
    Serial.println(mul);
    Serial.println("******************************************************************");
    for (unsigned char i = 0; i < 128; i++)
    {
      radio.stopListening(); // Paramos la escucha para poder escribir
      digitalWrite(enviando, HIGH);
      TX[i] = i * mul;
      bool ok = radio.write(&TX[i], sizeof(TX[i])); //Envio de datos
      if (!ok)
      {
        Serial.print("fallo el envio en el dato ");
        Serial.print(i);
        Serial.print(" : ");
        Serial.println(TX[i]);
        //TX_state = 0;
        //return;
      } else
      {
        Serial.print("Dato ");
        Serial.print(i);
        Serial.print(" enviado: ");
        Serial.println(TX[i]);
      }
      digitalWrite(enviando, LOW);
      //delay(50);
      radio.startListening(); //Volvemos a la escucha
      unsigned long inicio = millis();
      bool timeout = false;
      digitalWrite(recibiendo, HIGH);
      while ( ! radio.available() && ! timeout )
      {
        if (millis() - inicio > 300 )  // Esperamos 3000ms para darle tiempo a el receptor de respondernos
          timeout = true; // si se alcanzo el tiempo, se pone en true para
      }
      if ( timeout )
      {
        Serial.print("fallo la recepcion de el dato ");
        Serial.println(i);
        RX[i] = 0;
      } else
      {
        radio.read( &RX[i], sizeof(RX[i])); //Funcion de lectura de datos
        Serial.print("Dato ");
        Serial.print(i);
        Serial.print(" recibido: ");
        Serial.println(RX[i]);
      }
      digitalWrite(recibiendo, LOW);
      //delay(50);
    }
    Serial.println("Todos los datos fueron transmitidos");
    Serial.println("******************************************************************");
    radio.startListening(); //Volvemos a la escucha
    TX_state = 0;
    test = 1;
  }
  
  if (test == 1)
  {
    Serial.println("******************************************************************");
    Serial.println("Iniciando verificacion de caracteres");
    error_cont = 0;
    for (unsigned char i = 0; i < 128; i++)
    {
      if (TX[i] != RX[i])
      {
        Serial.print("Datos erroneos en la comparacion: ");
        Serial.println(i);
        error_cont++;
      } else
      {
        Serial.print("Datos ");
        Serial.print(i);
        Serial.println(" correctos");
      }
    }
    Serial.println("********************************************************************");
    Serial.println("Test finalizado...");
    Serial.print("Numero de datos errorenos recibidos: ");
    Serial.println(error_cont);
    test = 0;
    error_cont = 0;
    for (int x = 0; x < 128; x++)
    {
      RX[x] = 0;
      TX[x] = 0;
    }
  }
}

y como los alimentas?
Seguro los nRF24 simples los alimentas con los 3.3V del ardino y los que usan antena pretendes que sigan igual y resulta que consumen 150mA cosa que los 3.3V no pueden suministrar.

Debes usar un LDO AMS1117 de 5 a 3.3V mas sus capacitores correspondientes como dice la hoja de datos.

Hola. lamento responder tan tarde, pero el foro me ha dado algo de problemas. bien, volviendo al acaso ya cambie la alimentación por un adaptador que me entrega 800mA a 3,3V y ya trate de colocar un condenador entre + y -

Y como funcionan las cosas ahora?

NO, no hay resultados, nuevamente los módulos reciben señal, pero no emiten

Y arrancaste por tu programa o usaste los códigos ejemplos de TX y RX que disponen las librerías? Porque para mi la secuencia es siempre la misma. Parto de un demo de la librería y luego modifico porque se que eso funciona, que el hardware funciona y tengo una base desde donde comienzo a elaborar lo que quiero.

En tu caso veo que es un código propio.

Si usas Tmrh20 pues con probar el ejemplo básico que te permite cambiar simplemente presionando T o R para TX o RX listo.

Ya use los ejemplos que me recomendaste, sin embargo nuevamente el resultado es negativo, emplee los ejemplos de hola mundo y la única forma de obtener la información es con el modulo con antena en el arduino receptor y el sin antena en el emisor, si cambio el emisor por un modulo con antena no se reciben datos, lo que me lleva a la conclusión de que no se están emitiendo

Vaya eres el 2do que me dice eso.

Tienes puesto el capacitor entre 3.3V y GND del nRF24, dime de que valor es?

Tengo un capacitór eléctrico de 10uf y capasitor ceramico de 100nf en cada modulo

Aumenta ese valor a 100uF

¿el condensador debe ser restrictivamente de 100uf? ya que no tengo uno a la mano y monte uno de 330 uf sin resultados positivos

adicionalmente estuve probando con un multimetro y comprobe que los módulos tan solo están consumiendo 25-40 mA alcanzando el máximo cunado reciben datos, pero no envían nada ya que según las especificaciones deverian consumir alrededor de 115mA en el envió de datos, lo que me hace pensar en si existe alguna configuración adicional que permita activar el modo emisor.

Dices haber usado el código ejemplo que te indiqué sin resultados.

Ya use los ejemplos que me recomendaste, sin embargo nuevamente el resultado es negativo, emplee los ejemplos de hola mundo

Los que yo te digo no usan "hola mundo", esos no son de Tmrh20.
Los que yo te digo envian un timestamp o sea millis() los milisegundos desde que se activan los arduinos, uno envia y el otro recibe o los inviertes. Siempre uso eso y anda perfecto.

Puedes hacer los cambios que gustes.

El capacitor no tiene porque ser de 100, dije ese valor pero el de 330uF esta bien. Soldado entre 3.3V y GND del módulo.

Hola de nuevo surbyte, lamento haberte hecho perder el tiempo, resulta que el problema no era de los tranceptores era mio, conecte cables para poder hacer el prototipado y al parecer estos funcionaban como resistencia retardando la acción del condensador. La solución fue soldar directamente a los pines.

Bueno me alegro que lo solucionaras pero siempre nos referimos al módulo, a sus pines

Soldado entre 3.3V y GND del módulo.