Prender y apagar leds con Nrf24l01 + RTC

Buenas a todos

basicamente mi problema es que no puedo lograr prender varios leds con varios botones.

Ejemplo

Los botones estan conectados en el emisor y los leds al receptor

Btn al presionarse encendera el led1
Btn2 al presionarse encendera el led2
Btn3 al presionarse encendera el led3
etc etc etc

Con este codigo que abajo dejare pude prender y apagar un solo led, pero cuando quiero ingresar mas botones y mas leds estos no responden.

Como puedo adaptar el codigos de aquí debajo para que el boton de los pines (por ejemplo) 6 y 7 de la placa emisora prendan los leds de los pines 6 y 7 de la placa receptora?

aun no entiendo muy bien el lenguaje de programacion en arduino y un poco me marea el tema de matrices y creo que el problema es ese, al prender o apagar un led lo que hago es mandarle una informacion (1 o 0) dependiendo el estado anterior del boton y con esa informacion el led prende(1) o apaga(0) cuando quise adaptarlo lo que puse fue mas tamano en la matriz ([3]) y usando el 2 y el 3 para prender y apagar el segundo led del arduino receptor pero esto no me funciono correctamente.

Quiza lo que acabo de decir sea una estupidez absoluta (seguramente) y la solucion sea mucho mas facil.

EMISOR

 // Incluimos las librerías necesarias
  #include <SPI.h> // Librería para la comunicación SPI
  // Librerías para el funcionamiento del módulo NRF24L01
  #include <nRF24L01.h>
  #include <RF24.h>
 
  // Declaramos los pines de control del módulo NRF24L01
  #define CE 9
  #define CSN 10
 
  // Se crea el objeto tipo RF24
  RF24 radio(CE, CSN);
 
  // Se declara el canal (64 bits en hexadecimal) para transmisión RF
  const uint64_t canal = 0xE8E8F0F0E1LL;
 
  // Variable que enviamos mediante RF (de tipo string siempre)
  unsigned int estado_pulsador[1];
 
  int pulsador = 7; // Pin digital 7 para el pulsador
 
  // Inicializamos las variables internas para el pulsador
    int encender = 0;
    int anterior = 0;
    int estado = 0;
   
  void setup()
  {
    pinMode(pulsador, INPUT); // Pin digital del pulsador como entrada 
    radio.begin();  // Inicialización de la comunicación RF  
    radio.openWritingPipe(canal); // Se abre el canal para escritura   
  }
 
  void loop()
  {
    estado = digitalRead(pulsador); // Guardamos el estado actual del pulsador
     
    if(estado && anterior == 0) // Comparamos el estado actual y el anterior del pulsador
    {
      encender = 1 - encender;
      delay(300); // Evita los posibles rebotes del pulsador.
    }
   
    anterior = estado; // Actualizamos el estado del pulsador.
   
    if(encender) // Si el estado interno del pulsador pasa de "LOW" a "HIGH".
    {
      estado_pulsador[0] = 1; // La variable vale 1
    }
   
    else // Si el estado interno del pulsador pasa de "HIGH" a "LOW".
    {
      estado_pulsador[0] = 0; // La variable vale 0
    }  
         
    // Se envía el valor de la variable estado_pulsador[0] a través de RF
    radio.write(estado_pulsador, sizeof(estado_pulsador));
  }

RECEPTOR

 // Incluimos las librerías necesarias
  #include <SPI.h> // Librería para la comunicación SPI
  // Librerías para el funcionamiento del módulo NRF24L01
  #include <nRF24L01.h>
  #include <RF24.h>
 
  // Declaramos los pines de control del módulo NRF24L01
  #define CE 9
  #define CSN 10
 
  // Se crea el objeto tipo RF24
  RF24 radio(CE, CSN);
 
  // Se declara el canal (64 bits en hexadecimal) para transmisión RF
  const uint64_t canal = 0xE8E8F0F0E1LL;
 
  // Variable que enviamos mediante RF (de tipo string siempre)
  unsigned int estado_pulsador[1];
 
  int LED = 7; // Pin digital 7 para el LED
 
  void setup()
  {
    radio.begin();  // Inicialización de la comunicación RF
    radio.openReadingPipe(1, canal); // Se abre el canal para lectura
    radio.startListening(); // Comienza a escuchar por el canal abierto para lectura
    pinMode(LED, OUTPUT); // Pin digital 7 como salida
    digitalWrite(LED, LOW); // Inicialmente el LED se apaga
  }
 
  void loop()
  {
    // Siempre que haya información disponible vía RF... 
    while(radio.available())
    {
      // Se recibe el valor de la variable estado_pulsador[0] a través de RF
      radio.read(estado_pulsador, sizeof(estado_pulsador));
    }
   
    // Si el valor de la variable estado_pulsador[0] es igual a "1" se enciende el LED
    if (estado_pulsador[0] == 1)
    {
      digitalWrite(LED, HIGH);
    }
   
    // Si el valor de la variable estado_pulsador[0] es igual a "0" se apaga el LED
    if (estado_pulsador[0] == 0)
    {
      digitalWrite(LED, LOW);
    }    
  }

Muchas gracias de antemano y espero puedan resolver mi problema. Saludos!

Veamos si esto funciona.

EMISOR

// Incluimos las librerías necesarias
#include <SPI.h> // Librería para la comunicación SPI

// Librerías para el funcionamiento del módulo NRF24L01
#include <nRF24L01.h>
#include <RF24.h>

// Declaramos los pines de control del módulo NRF24L01
#define CE  9
#define CSN 10

// Se crea el objeto tipo RF24
RF24 radio(CE, CSN);

// Se declara el canal (64 bits en hexadecimal) para transmisión RF
const uint64_t canal = 0xE8E8F0F0E1LL;

#define CANT_PULSADORES  2
// Variable que enviamos mediante RF (de tipo string siempre)
unsigned int estado_pulsador[CANT_PULSADORES];

const byte pulsador[CANT_PULSADORES] = {6, 7}; // Pin digital 6,7, etc para el LED2

// Inicializamos las variables internas para el pulsador
bool estado[CANT_PULSADORES]    = {LOW,LOW};
bool anterior[CANT_PULSADORES]  = {LOW,LOW};
byte encender[CANT_PULSADORES]  = {0,0};
 
void setup()
{
  for (int i=0; i<sizeof(estado_pulsador); i++) {
        pinMode(pulsador[i], INPUT); // Pin digital del pulsador como entrada 
  }
  radio.begin();  // Inicialización de la comunicación RF  
  radio.openWritingPipe(canal); // Se abre el canal para escritura   
}

void loop()
{
  for (byte i=0; i<sizeof(estado_pulsador); i++) {
        estado[i] = digitalRead(pulsador[i]);   // Guardamos el estado actual del pulsador
        if (estado[i] && !anterior[i]) {    // Comparamos el estado actual y el anterior del pulsador
            encender[i] = !encender[i];
            delay(50);                    // Evita los posibles rebotes del pulsador.
        }
        anterior[i] = estado[i];                // Actualizamos el estado del pulsador.
        estado_pulsador[i] = encender[i];
  }
       
  // Se envía el valor de la variable estado_pulsador[0] a través de RF
  radio.write(estado_pulsador, sizeof(estado_pulsador));
}

Receptor

// Incluimos las librerías necesarias
#include <SPI.h> // Librería para la comunicación SPI
// Librerías para el funcionamiento del módulo NRF24L01
#include <nRF24L01.h>
#include <RF24.h>

// Declaramos los pines de control del módulo NRF24L01
#define CE  9
#define CSN 10

// Se crea el objeto tipo RF24
RF24 radio(CE, CSN);

// Se declara el canal (64 bits en hexadecimal) para transmisión RF
const uint64_t canal = 0xE8E8F0F0E1LL;

#define CANT_LEDS    2
// Variable que enviamos mediante RF (de tipo string siempre)
byte estado_pulsador[CANT_LEDS];

const byte LED[CANT_LEDS] = {6, 7}; // Pin digital 6,7, etc para el LED2

void setup()
{
  radio.begin();  // Inicialización de la comunicación RF
  radio.openReadingPipe(1, canal); // Se abre el canal para lectura
  radio.startListening(); // Comienza a escuchar por el canal abierto para lectura
  for (int i=0; i<sizeof(LED); i++) {
        pinMode(LED[i], OUTPUT); // Pin digital 7 como salida
        digitalWrite(LED[i], LOW);
  }
}
 
void loop()
{
  // Siempre que haya información disponible vía RF... 
  while (radio.available()) {
        // Se recibe el valor de la variable estado_pulsador[0] a través de RF
        radio.read(estado_pulsador, sizeof(estado_pulsador));
  }
 
  // Si el valor de la variable estado_pulsador[0] es igual a "1" se enciende el LED1
  for (byte i=0; i<sizeof(estado_pulsador); i++) {
      digitalWrite(LED[i], estado_pulsador[i]);  

  }
}

Mira a ver si funciona. Dos LEDS en 6 y 7, dos pulsadores en 6 y 7 lado receptor y lado emisor respectivamente.

Algunos cambios pero los charlamos.

Este es un cambio muy menor porque tu versión también funciona
encender = !encender*;*
Pero como yo uso bool y no int para definir una variable que solo sera LOW o HIGH no malgasto 30 bits como en tu caso. Exagerado… en este programa no, pero a futuro puede ser.
Es bueno aprender desde el vamos.
Entonces si una variable es boolean y vale LOW la cambias con el negador !
supongamos encender[0] = HIGH
como lo cambias, simple solamente con el negador y su valor !encender[0]
Lo mismo cuando comparas el valor actual con el anterior.
Valor actual es la variable y el anterior NEGADO es con el !nombre_variable en lugar de poner nombre_variable == 0 o igual a LOW.
Espero se entienda.
Los vectores empiezan por el indice 0 y asi sucesivamente.

surbyte:
Veamos si esto funciona.

Buenos dias surbyte gracias por aportar a la causa jajaja.

Mira, el emisor no tiene problemas (valga la redundancia) en emitir, pero el receptor por su parte recibe 1010101 constantemente. Al conectarlo este prende inmediatamente el led del pin 6 mientras que el led del pin 7 no hace absolutamente nada. Otra cosa que note que por mas que el emisor este apagado el recepetor sigue "recibiendo" señal en forma de 10101010101 como la imagen lo muestra.

Puerto serie del emisor.

Chequeando los botones del emisor estoy viendo que al no presionar nada el serial port devuelve
323232323232323232...
Si presiono el boton del pin 6 devuelve
333333333333333333...
Si presiono boton del pin 7 devuelve
121212121212121212...
Y si presiono los dos botones al mismo tiempo devuelve
111111111111111111...

Todo estos valores son continuos y devuelven lo antes mencionado presionandolos o no presionandolos (dependiendo el caso). dejo un print tambien para que se entienda un poco mejor

Estoy casi seguro que el problema lo tiene el for pero el analisis se lo dejo al experto.

Nuevamente muchas gracias por ayudar a la causa surbyte!

Vaya evidentemente lo que estoy enviando no es lo correcto
Lo reviso y te digo.

Prueba con este en el receptor

// Incluimos las librerías necesarias
#include <SPI.h> // Librería para la comunicación SPI

// Librerías para el funcionamiento del módulo NRF24L01
#include <nRF24L01.h>
#include <RF24.h>

// Declaramos los pines de control del módulo NRF24L01
#define CE  9
#define CSN 10

// Se crea el objeto tipo RF24
RF24 radio(CE, CSN);

// Se declara el canal (64 bits en hexadecimal) para transmisión RF
const uint64_t canal = 0xE8E8F0F0E1LL;

#define CANT_PULSADORES  2
// Variable que enviamos mediante RF (de tipo string siempre)
unsigned int estado_pulsador[CANT_PULSADORES];

const byte pulsador[CANT_PULSADORES] = {6, 7}; // Pin digital 6,7, etc para el LED2

// Inicializamos las variables internas para el pulsador
bool estado[CANT_PULSADORES]    = {LOW,LOW};
bool anterior[CANT_PULSADORES]  = {LOW,LOW};
unsigned int encender[CANT_PULSADORES]  = {0,0};
 
void setup()
{
  for (int i=0; i<sizeof(estado_pulsador); i++) {
        pinMode(pulsador[i], INPUT); // Pin digital del pulsador como entrada 
  }
  radio.begin();  // Inicialización de la comunicación RF  
  radio.openWritingPipe(canal); // Se abre el canal para escritura   
}

void loop()
{
  for (byte i=0; i<sizeof(estado_pulsador); i++) {
        estado[i] = digitalRead(pulsador[i]);   // Guardamos el estado actual del pulsador
        if (estado[i] && !anterior[i]) {    // Comparamos el estado actual y el anterior del pulsador
            encender[i] = 1- encender[i];
            delay(50);                    // Evita los posibles rebotes del pulsador.
        }
        anterior[i] = estado[i];                // Actualizamos el estado del pulsador.
        estado_pulsador[i] = encender[i];
  }
       
  // Se envía el valor de la variable estado_pulsador[0] a través de RF
  radio.write(estado_pulsador, sizeof(estado_pulsador));
}

y cambia esta linea en el emisor

unsigned int estado_pulsador[CANT_LEDS];

decia byte y ahora unsigned int

Muy buenas Surbyte, puse los codigos y el led del pin 7 prende y apaga con su correspondiente boton perfecto pero el led del pin 6 no lo hace.

De todas formas aqui hay un problema yo estoy necesitando que los leds permanezcan prendidos hasta que el boton vuelva a presionarse.

de prender el led presionando y apagando el led soltando lo acabo de lograr hace unos minutos con los siguientes códigos por si a alguien le sirve

EMISOR

#include  <SPI.h>          
#include  "RF24.h"               
byte data[1];                     
const uint64_t pipe = 0xF0F0F0F0A1LL; 
RF24 radio(9,10);                    

void setup(){
  Serial.begin(9600);
 pinMode(6, INPUT);           
 pinMode(7, INPUT);         
 radio.begin();                       
 radio.openWritingPipe(pipe);        
}

void loop(){
 if(digitalRead(6)==LOW && digitalRead(7)==LOW){
  data[0]=10;
  Serial.println("caso 1");
 }
 if(digitalRead(6)==LOW && digitalRead(7)==HIGH){
  data[0]=15;
  Serial.println("caso 2");
 }
 if(digitalRead(6)==HIGH && digitalRead(7)==LOW){
  data[0]=30;
  Serial.println("caso 3");
 }
 if(digitalRead(6)==HIGH && digitalRead(7)==HIGH){
  data[0]=60;
  Serial.println("caso 4");
 }

 radio.write(data, 1);    
}

RECEPTOR

#include <SPI.h>                      
#include "RF24.h"                      
byte data[1];                       
boolean var;                        
const uint64_t pipe = 0xF0F0F0F0A1LL;
RF24 radio(9,10);                   

void setup(){
  Serial.begin(9600);
 pinMode(6, OUTPUT);                    
 pinMode(7, OUTPUT);                  
 radio.begin();                        
 radio.openReadingPipe(1,pipe);        
 radio.startListening();                
}

void loop(){
 if(radio.available()){
     radio.read(data, 1);   
      if(data[0] == 10){
      digitalWrite(6, LOW);
      digitalWrite(7, LOW);
      Serial.println("caso 1");
      }
      if(data[0] == 15){
      digitalWrite(6, LOW);
      digitalWrite(7, HIGH);
      Serial.println("caso 2");
      }
      if(data[0] == 30){
      digitalWrite(6, HIGH);
      digitalWrite(7, LOW);
      Serial.println("caso 3");
      }
      if(data[0] == 60){
      digitalWrite(6, HIGH);
      digitalWrite(7, HIGH);
      Serial.println("caso 4");
      }
   }
  }

vaya dolor de cabeza se me torno esto jajaja

Veamos mejore un poco los codigos

EMISOR

#include  <SPI.h>          
#include  "RF24.h"               
byte data[1];                     
const uint64_t pipe = 0xF0F0F0F0A1LL; 
RF24 radio(9,10);                    
int estadoV = 0;
int encenderV = 0;
int anteriorV = 0;

int estadoR = 0;
int encenderR = 0;
int anteriorR = 0;

int BOTONROJO = 7;
int BOTONVERDE = 6;

void setup(){
  Serial.begin(9600);
 pinMode(BOTONVERDE, INPUT);           
 pinMode(BOTONROJO, INPUT);         
 radio.begin();                       
 radio.openWritingPipe(pipe);        
}

void loop(){

  estadoV = digitalRead(BOTONVERDE);
  estadoR = digitalRead(BOTONROJO);
  if(estadoV && anteriorV == 0){
    encenderV = 1 - encenderV;
    delay(300);
  }
  if(estadoR && anteriorR == 0){
    encenderR = 1 - encenderR;
    delay(300);
   }
  anteriorV = estadoV;
  
  anteriorR = estadoR;
  

 if(encenderR && anteriorV){ //+ | +
  data[0]=60;
   Serial.println("caso 1");
 }
 if(!encenderR && anteriorV){ // - | +
  data[0]=30;
     Serial.println("caso 2");
 }
 if(encenderR && !anteriorV){ // + | -
  data[0]=15;
  Serial.println("caso 3");
 }
if(!encenderR && !anteriorV){ // - | -
  data[0]=10;
       Serial.println("caso 4");
 }

 radio.write(data, 1);    
}

RECEPTOR

#include <SPI.h>                      
#include "RF24.h"                      
byte data[1];                       
boolean var; 
int ROJO = 7;
int VERDE = 6;                       
const uint64_t pipe = 0xF0F0F0F0A1LL;
RF24 radio(9,10);                   
void setup(){
  Serial.begin(9600);
 pinMode(VERDE, OUTPUT);                    
 pinMode(ROJO, OUTPUT);                  
 radio.begin();                        
 radio.openReadingPipe(1,pipe);        
 radio.startListening();                
}
void loop(){
 if(radio.available()){
     radio.read(data, 1);   
      if(data[0] == 10){
      digitalWrite(VERDE, LOW);
      digitalWrite(ROJO, LOW);

      Serial.println("caso 4");
      delay(300);
      }
      if(data[0] == 15){
      digitalWrite(VERDE, LOW);
      digitalWrite(ROJO, HIGH);
      
      Serial.println("caso 3");
      delay(300);
      }
      if(data[0] == 30){
      digitalWrite(VERDE, HIGH);
      digitalWrite(ROJO, LOW);
      
      Serial.println("caso 2");
      delay(300);
      }
      if(data[0] == 60){
      digitalWrite(VERDE, HIGH);
      digitalWrite(ROJO, HIGH);
      
      Serial.println("caso 1");
      delay(300);
      }
   }
  }

El rojo prende cuando presiono, y se apaga cuando vuelvo a precionar, pero cuando intento hacer esto mismo con el verde el led se prende por el tiempo que yo mantenga el boton pulsado, una vez lo suelto este se apaga. ¿En que le estoy errando?

Luego de 3 largos dias para un novato en la materia logre que dos modulos de Arduino Uno R3 se comuniquen inalambricamente mediante botones donde su función es saber a que hora estos leds permanecían prendidos pero con la trampa que el led debe volver a presionarse para ser apagado.

Muchas gracias al moderador Surbyte que me fue de mucha ayuda en esta incógnita que afrontaba

Modulo EMISOR

#include  <SPI.h>          
#include  "RF24.h"               
byte data[1];                     
const uint64_t pipe = 0xF0F0F0F0A1LL; 
RF24 radio(9,10);                    
int estadoV = 0;
int encenderV = 0;
int anteriorV = 0;

int estadoR = 0;
int encenderR = 0;
int anteriorR = 0;

int BOTONROJO = 6;
int BOTONVERDE = 7;

void setup(){
 Serial.begin(9600);
 pinMode(BOTONVERDE, INPUT);           
 pinMode(BOTONROJO, INPUT);         
 radio.begin();                       
 radio.openWritingPipe(pipe);        
}

void loop(){

  estadoV = digitalRead(BOTONVERDE);
  estadoR = digitalRead(BOTONROJO);
  if(estadoV && anteriorV == 0){
    encenderV = 1 - encenderV;
    delay(300);
  }
  if(estadoR && anteriorR == 0){
    encenderR = 1 - encenderR;
    delay(300);
   }
  anteriorV = estadoV;
  
  anteriorR = estadoR;
  

 if(encenderV && encenderR){ //+ | +
  data[0]=60;
   Serial.println("caso 1");
 }
 if(!encenderV && encenderR){ // - | +
  data[0]=30;
     Serial.println("caso 2");
 }
 if(encenderV && !encenderR){ // + | -
  data[0]=15;
  Serial.println("caso 3");
 }
if(!encenderV && !encenderR){ // - | -
  data[0]=10;
       Serial.println("caso 4");
 }

 radio.write(data, 1);    
}

MODULO RECEPTOR

#include <SPI.h>                      
#include "RF24.h" 
#include <Wire.h>
#include <TimeLib.h>
#include <RTClib.h>   
RTC_DS3231 rtc;                  
byte data[1];                       
boolean var; 
int ROJO = 7;
int VERDE = 6;                       
const uint64_t pipe = 0xF0F0F0F0A1LL;
RF24 radio(9,10); 


String daysOfTheWeek[7] = { "Domingo", "Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado" };
String monthsNames[12] = { "Enero", "Febrero", "Marzo", "Abril", "Mayo",  "Junio", "Julio","Agosto","Septiembre","Octubre","Noviembre","Diciembre" };



void setup(){
  Serial.begin(9600);
 pinMode(VERDE, OUTPUT);                    
 pinMode(ROJO, OUTPUT);                  
 radio.begin();                        
 radio.openReadingPipe(1,pipe);        
 radio.startListening();     

if (!rtc.begin()) {

    
    Serial.println(F("Couldn't find RTC"));
    while (1);
  }

  // Si se ha perdido la corriente, fijar fecha y hora
  if (rtc.lostPower()) {
    // Fijar a fecha y hora de compilacion
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
    
    // Fijar a fecha y hora específica. En el ejemplo, 21 de Enero de 2016 a las 03:00:00
    // rtc.adjust(DateTime(2016, 1, 21, 3, 0, 0));
  }
}


void printDate(DateTime date)
{
  Serial.print(date.year(), DEC);
  Serial.print('/');
  Serial.print(date.month(), DEC);
  Serial.print('/');
  Serial.print(date.day(), DEC);
  Serial.print(" (");
  Serial.print(daysOfTheWeek[date.dayOfTheWeek()]);
  Serial.print(") ");
  Serial.print(date.hour(), DEC);
  Serial.print(':');
  Serial.print(date.minute(), DEC);
  Serial.print(':');
  Serial.print(date.second(), DEC);

Serial.println();
}


void loop(){
 if(radio.available()){
     radio.read(data, 1);   
      if(data[0] == 10){
      digitalWrite(VERDE, LOW);
      digitalWrite(ROJO, LOW);

      Serial.println("caso 4");
      DateTime now = rtc.now();
          printDate(now);
      delay(300);
      }
      if(data[0] == 15){
      digitalWrite(VERDE, LOW);
      digitalWrite(ROJO, HIGH);
      
      Serial.println("caso 3");
      DateTime now = rtc.now();
          printDate(now);
      delay(300);
      }
      if(data[0] == 30){
      digitalWrite(VERDE, HIGH);
      digitalWrite(ROJO, LOW);
      
      Serial.println("caso 2");
      DateTime now = rtc.now();
          printDate(now);
      delay(300);
      }
      if(data[0] == 60){
      digitalWrite(VERDE, HIGH);
      digitalWrite(ROJO, HIGH);
      
      Serial.println("caso 1");
      DateTime now = rtc.now();
          printDate(now);
      delay(300);
      }
   }
  }

Saludos y hasta la proxima!