Nrf24l01 no me comunica

[luis_aguilar2000]

Buenas Tardes foro quisiera que me apoyaran con un código necesito enviar unos datos de un Arduino maestro a un esclavo en el maestro se maneja unas tiras led y recibe datos de un bluetooth y el esclavo solo recibe los datos y lo imprimí, el problema es que no me envía los datos del maestro al esclavo ya probé con una programación básica y si funcionan los módulos.

Estos son los codigos

TRANSMISOR
// Comunicación con la memoria
#define USE_SD_H 0
#if USE_SD_H
#include <SD.h>
#else  // USE_SD_H
#include "SdFat.h"
SdFat SD;
#endif  // USE_SD_H
File ArchivoMemo;

 

// Comunicación con la cuerda led
#include <FastLED.h>
#define NUM_LEDS 80
#define DATA_PIN 5 // Cambia el número del pin si es necesario
#define BRIGHTNESS 255
#define VELOCIDAD_ANIMACION 300 // Velocidad de desplazamiento en milisegundos
CRGB leds[NUM_LEDS];
int direccion = 1; // 1 para mover hacia abajo, -1 para mover hacia arriba
int posicion = 0;

 

// Comunicación Bluetooth
#include <SoftwareSerial.h>
SoftwareSerial bluetoothSerial(2, 3); // Rx, Tx para el módulo Bluetooth HC-05

 

// Comunicación NRF24L01
#include <RF24.h>
RF24 radio(9, 10); // Pines CE y CSN del módulo NRF24L01
byte address[6] = "00001"; // Dirección del canal de comunicación NRF24L01

 

// DECLARAR COLORES
CRGB colorRojo = CRGB(255, 0, 0);
CRGB colorVerde = CRGB(0, 255, 0);
CRGB colorAzul = CRGB(0, 0, 255);
CRGB colorBlanco = CRGB(255, 255, 255);
CRGB colorAmarillo = CRGB(255, 255, 0);

 

//************************************************************************************************
// Función de inicio
void setup() {
  FastLED.addLeds<WS2811, DATA_PIN, GRB>(leds, NUM_LEDS);
  FastLED.setBrightness(BRIGHTNESS);
  Serial.begin(9600); // Inicia la comunicación serial para depuración
  bluetoothSerial.begin(9600); // Inicia la comunicación serial con el módulo Bluetooth

 

  // Configurar LEDs con color azul sólido al inicio
  Serial.print("i n i c i o");
  int inicio = 1;
  while (inicio < 5) {
    fill_solid(leds, NUM_LEDS, CRGB::Blue);
    FastLED.show();
    delay(100);
    fill_solid(leds, NUM_LEDS, CRGB::Black);
    FastLED.show();
    delay(100);
    Serial.print(" .");
    inicio++;
  }
  Serial.println();

 

  // Inicializa el módulo NRF24L01
  radio.begin();
  radio.openWritingPipe(address);
  radio.setPALevel(RF24_PA_HIGH);
  radio.stopListening();
}

 

//************************************************************************************************
// Función principal
void loop() {
  Serial.println("- - -  A N I M A C I O N E S  - - -");
  char comando = LeerMemoSD(); // Leer la memoria para saber cuál es el último comando

 

  if (comando == 'E') { // Animar la bandera de El Salvador
    comando = BanderaAnimation("E", colorAzul, colorBlanco, colorAzul);
    Serial.println("ENVIANDO: " + String(comando));
    Transmitir(comando); // Transmitir el comando a través del NRF24L01
  } // Fin de la bandera de El Salvador

 

  if (comando == 'M') { // Animar la bandera de Mexico
    comando = BanderaAnimation("M", colorVerde, colorBlanco, colorRojo);
    Serial.println("ENVIANDO: " + String(comando));
    Transmitir(comando); // Transmitir el comando a través del NRF24L01
  } // Fin de la bandera de Mexico

 

  if (comando == 'C') { // Animar la bandera de Colombia
    comando = BanderaAnimation("C", colorAmarillo, colorAzul, colorRojo);
    Serial.println("ENVIANDO: " + String(comando));
    Transmitir(comando); // Transmitir el comando a través del NRF24L01
  } // Fin de la bandera de Colombia

 

  // Agrega condiciones para otras banderas aquí

 

  if (comando == 'X') { // Si la comunicación falla
    fill_solid(leds, NUM_LEDS, CRGB::Blue);
    FastLED.show();
    // Cuerda led se pone azul por defecto
  }
}

 

//************************************************************************************************
// Inicia animación de la bandera rgb
char BanderaAnimation(char Pais, CRGB Color1, CRGB Color2, CRGB Color3) {
  Serial.print("INICIA ANIMACION");

 

  unsigned long inicioAnimacion = millis();
  char STAR_Animation = Pais;
  char END_Animation = Pais;

 

  while (STAR_Animation == END_Animation) { // Duración infinita
    Serial.println(".");

 

    if (direccion == 1) { // Movimiento de arriba abajo
      posicion += 1; // Incrementamos la posición
      if (posicion >= NUM_LEDS - 45) { // Si llegamos al final, cambiamos de dirección
        direccion = -1;
      }
    } else {
      posicion -= 1; // Decrementamos la posición
      if (posicion <= 0) { // Si llegamos arriba, cambiamos de dirección
        direccion = 1;
      }
    }

 

    fill_solid(leds, NUM_LEDS, CRGB::Black); // Apagamos todos los LEDs

 

    for (int j = 0; j < 15; j++) { // Encendemos la parte del primer color
      leds[posicion + j] = Color1;
    }
    for (int j = 15; j < 30; j++) { // Encendemos la parte blanca
      leds[posicion + j] = Color2;
    }
    for (int j = 30; j < 45; j++) { // Encendemos la parte azul
      leds[posicion + j] = Color3;
    }

 

    //_________________________________________________________________________
    char comando = LeerBluet(); // Lee un carácter
    if (comando == 'E' || comando == 'M' || comando == 'C' || comando == 'A') {
      Serial.println("cambio de animacion");
      END_Animation = comando;
    }
    //_________________________________________________________________________
    FastLED.show();
    delay(VELOCIDAD_ANIMACION);
  }

 

  EscribirMemoSD(END_Animation); // Escribe en la memoria la última configuración
  return END_Animation;
} // Fin animación

 

//****************************************************************//
// Función para leer el bluetooth
char LeerBluet() {
  if (bluetoothSerial.available() > 0) {
    char comando1 = bluetoothSerial.read(); // Lee un carácter
    return comando1;
  } else {
    char comando1 = Serial.read();
    return comando1;
  }
} // Fin de lectura de bluetooth

 

//****************************************************************************************************************************
// Función para leer la memoria
char LeerMemoSD() {
  if (!SD.begin(4)) { // El pin 4 se utiliza para seleccionar la tarjeta SD
    Serial.println("No se pudo inicializar la tarjeta microSD");
    return 'X';
  }
  ArchivoMemo = SD.open("Configuracion.txt"); // Abrir el archivo de texto en modo lectura
  if (ArchivoMemo) {
    char ultimaLinea = 'X'; // Variable para almacenar la última línea
    while (ArchivoMemo.available()) { // Leer y almacenar cada línea del archivo
      String linea = ArchivoMemo.readStringUntil('\n');
      if (linea.length() > 0) {
        char ultimoCaracter = linea[linea.length() - 1]; // Obtener el último carácter
        ultimaLinea = ultimoCaracter;
      }
    }
    ArchivoMemo.close();
    Serial.print("Última configuración cargada: "); // Mostrar la última línea en el Monitor Serie
    Serial.println(ultimaLinea);
    return ultimaLinea;
  } else {
    return 'X';
    Serial.println("Error al abrir el archivo.");
  }
}

 

//*******************************************************************************************************************************
// Función para escribir en la memoria
void EscribirMemoSD(char Configuracion1) {
  if (!SD.begin(4)) { // El pin 4 se utiliza para seleccionar la tarjeta SD
    Serial.println("No se pudo inicializar la tarjeta microSD");
    return;
  }
  ArchivoMemo = SD.open("Configuracion.txt", FILE_WRITE); // Crear o abrir el archivo de texto en modo escritura
  Serial.print("Nueva bandera a configurar: ");
  Serial.println(Configuracion1);
  if (ArchivoMemo) {
    char linea = Configuracion1;
    ArchivoMemo.println();
    ArchivoMemo.print(linea); // Escribe la línea en el archivo
    ArchivoMemo.close(); // Cierra el archivo
    Serial.println("Línea escrita en el archivo.");
  } else {
    Serial.println("Error al abrir el archivo.");
  }
} // Fin de la escritura en memoria

 

//*******************************************************************************************************************************
// Función para transmitir
void Transmitir(char comando) {
  Serial.println("ENVIANDO: " + String(comando));
  radio.write(&comando, sizeof(comando)); // Transmitir el comando a través del NRF24L01
}

Receptor
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>

 

RF24 radio(9, 10); // Pines CE, CSN

 

void setup() {
  radio.begin();
  radio.openReadingPipe(1, 0xF0F0F0E1LL); // Define la dirección de origen del transmisor
  radio.setPALevel(RF24_PA_LOW);          // Establece la potencia de entrada (LOW para corto alcance)
  radio.startListening();
  Serial.begin(9600);
}

 

void loop() {
  if (radio.available()) {
    char datoRecibido;
    radio.read(&datoRecibido, sizeof(datoRecibido));
    Serial.print("Dato Recibido: ");
    Serial.println(datoRecibido);
  }
}

me ayudan no me comunican nada

[gilshultz]

It is apparent you need to spend some time and read the forum guidelines and post your code using code tags as explained by the guidelines.

Es evidente que necesita pasar algún tiempo y leer las pautas del foro y publicar su código usando etiquetas de código como se explica en las pautas.

[pert]

He trasladado su tema de una categoría de idioma inglés del foro a la categoría International > Español @luis_aguilar2000.

En adelante por favor usar la categoría apropiada a la lengua en que queráis publicar. Esto es importante para el uso responsable del foro, y esta explicado aquí la guía "How to get the best out of this forum".
Este guía contiene mucha información útil. Por favor leer.

De antemano, muchas gracias por cooperar.

[Surbyte]

Bueno si la programación básica funciona, evidentemente introduces algo que la hace fallar.

El delay(VELOCIDAD_ANIMACION) de 300 mseg en cada animación, es necesario?
Evita siempre los delays y en su lugar usa millis() para que el código de refrezcar la tira led se se ejecute cada 300 mseg pero que casi instantáneamente si has presionado algo en el BT, teclado o el dispositivo de entrada que uses.
La organización del código no me gusta pero no descarto que funcione con algún detalle que motiva esta consulta, claro está.

El criterio de las direcciones en TX y RX no me gusta, es como que tomaste códigos de dos lados distintos. Uno

address = "00001";  // en TX
 radio.openReadingPipe(1, 0xF0F0F0E1LL);   // en RX

Siempre usa criterio común. Tomas un código base y lo modificas paso a paso para que haga lo que quieres.
Otro detalle menor

//Por alguna razón pusiste el Tx en 
radio.setPALevel(RF24_PA_HIGH); 
//y el RX en
radio.setPALevel(RF24_PA_LOW);

Unifica potencias de TX y RX.
Sigo buscando no veo el problema de fondo aún.