SALUDOS.
Con ayuda de las libreria , RF24.h y EmonLib.h en podido crear el codigo siguiente , el problema que se me ha presentado es el siguiente tengo el transmisor donde capturo el voltage de la red con 2 sensores de voltage ZMT hasta ahy todo ok , cuando se transmite la informacion al llegar en el receptor las 2 variables float las recibe bien , las puedo ver en el monitor serial , mi problema es que las quiero separadas en 2 variables diferentes para poder usarlas individual .
// trasmisor TX
#include <SPI.h>
//#include <nRF24L01.h>
#include <RF24.h>
#include "EmonLib.h" // Include Emon Library
EnergyMonitor emon1;
EnergyMonitor emon2;
RF24 radio(8, 10); // CE, CSN
const byte address[6] = "00001"; //Byte of array representing the address. This is the address where we will send the data. This should be same on the receiving side.
int Led_tx = 2;
float dataSend[2] = {emon1.Vrms, emon2.Vrms};
void setup() {
Serial.begin(9600);
emon1.voltage(0, 150, 1.7);
emon2.voltage(1, 150, 1.7);
pinMode(Led_tx, OUTPUT);
radio.begin(); //Starting the Wireless communication
radio.openWritingPipe(address); //Setting the address where we will send the data
radio.setPALevel(RF24_PA_HIGH); //You can set it as minimum or maximum depending on the distance between the transmitter and receiver.
radio.stopListening(); //This sets the module as transmitter
}
void loop()
{
emon1.calcVI(20, 2000);
emon2.calcVI(20, 2000);
float dataSend[2] = {emon1.Vrms, emon2.Vrms};
radio.write(&dataSend, sizeof(dataSend)); //Reading the data
radio.write(&dataSend[0], sizeof(dataSend[0])); // voltage vrms 1
radio.write(&dataSend[1], sizeof(dataSend[1]));// volatge vrms 2
}
RX
//PLANTA BAJA
#include <SPI.h>
//#include <nRF24L01.h>
#include <RF24.h>
RF24 radio(8, 10); // CE, CSN
const byte address[6] = "00001";
int RadioRX_ON = 3;
//float dataSend[2] = {dataSend[0], dataSend[1]};
void setup() {
Serial.begin(9600);
radio.begin();
radio.openReadingPipe(0, address); //Setting the address at which we will receive the data
radio.setPALevel(RF24_PA_HIGH); //You can set this as minimum or maximum depending on the distance between the transmitter and receiver.
radio.startListening(); //This sets the module as receiver
}
void loop()
{
if (radio.available()) //Looking for the data.
{
digitalWrite(RadioRX_ON, HIGH);// RADIO ON
float dataSend[2] = {dataSend[0], dataSend[1]};
radio.read(&dataSend, sizeof(dataSend)); //Reading the data
Serial.println(dataSend[0]); //
// Serial.println(dataSend[1]);
}
}
el trasmisor envia los 2 float , y el receptor las recibe pero no separadas . como podria separar en variable diferente ??? al momento de recibirlas ..
ejemplo el receptor imprimo por el serial "Serial.println(dataSend[0]);" y me llegan las 2 variables float ,
alguna sugerencia..
//PLANTA BAJA
#include <SPI.h>
//#include <nRF24L01.h>
#include <RF24.h>
RF24 radio(8, 10); // CE, CSN
const byte address[6] = "00001";
int RadioRX_ON = 3;
//float dataSend[2] = {dataSend[0], dataSend[1]};
float vrms1 = 0; // Declaramos las variables donde vamos a guardar los valores recibidos
float vrms2 = 0;
void setup() {
Serial.begin(9600);
radio.begin();
radio.openReadingPipe(0, address); //Setting the address at which we will receive the data
radio.setPALevel(RF24_PA_HIGH); //You can set this as minimum or maximum depending on the distance between the transmitter and receiver.
radio.startListening(); //This sets the module as receiver
}
void loop()
{
if (radio.available()) //Looking for the data.
{
digitalWrite(RadioRX_ON, HIGH);// RADIO ON
float dataSend[2]; // No hace falta inicializar el array
radio.read(&dataSend, sizeof(dataSend)); //Reading the data
vrms1 = dataSend[0]; // Recuperamos el primer valor
vrms2 = dataSend[1]; // Recuperamos el segundo valor
Serial.println(dataSend[0]); //
// Serial.println(dataSend[1]);
}
}
He declarado las varables globales vrms1 y vrms2 en donde guardar los valores recibidos. Es en esas dos variables donde tendrás los dos valores por separado.
hola ingnorante absoluto gracias por tu tiempo hice los cambio sugerido pero igual me sigue llegando los datos juntos , el problema es si quiero usar un condicional por separado
if (Vrms1 > 100)
{
// action A
}
else
{
// action B
}
if (Vrms2 < 150)
{
// action A
}
else
{
// action B
}
el programa para poder detectar las variable individual no lo va a saber , por q llegan juntas al imprimirla por serial
Serial.println(dataSend[0]); o //Serial.println(Vrms1);
// download library https://github.com/nRF24/RF24
//PLANTA BAJA
#include <SPI.h>
//#include <nRF24L01.h>
#include <RF24.h>
RF24 radio(8, 10); // CE, CSN
const byte address[6] = "00001";
int RadioRX_ON = 3;
//float dataSend[2] = {dataSend[0], dataSend[1]};
float Vrms1 = 0;
float Vrms2 = 0;
void setup() {
Serial.begin(9600);
radio.begin();
radio.openReadingPipe(0, address); //Setting the address at which we will receive the data
radio.setPALevel(RF24_PA_HIGH); //You can set this as minimum or maximum depending on the distance between the transmitter and receiver.
radio.startListening(); //This sets the module as receiver
}
void loop()
{
if (radio.available()) //Looking for the data.
{
digitalWrite(RadioRX_ON, HIGH);// RADIO ON
//float dataSend[2] = {dataSend[0], dataSend[1]};
float dataSend[2];
radio.read(&dataSend, sizeof(dataSend)); //Reading the data
float Vrms1 = dataSend[0];
float Vrms2 = dataSend[1];
// Serial.println(dataSend[0]); // habilitado imprime los valores float vrms1,vrms2 juntos
//Serial.println(dataSend[1]); // habilitado imprime valores en 0.0
//Serial.println(Vrms1);// habilitado imprime los valores float vrms1,vrms2 juntos
// Serial.println(Vrms2); // habilitado imprime valores en 0.0
}
}
comentando // dataSend[1] en TX , en RX me llega Vrms1 solamente y viceversa
el detalle es hacerlo es RX , separar Vrms1 , Vrms2 , para poder usar un condicional..
Perdona @Tmorsi, pero es que no te entendí bien el problema que tenías. Olvida lo que te dije antes. Creo que el problema lo tienes en el transmisor. Estás transmitiendo más de lo que debes. Prueba a comentar los dos últimos radio.write(). Con el primero te basta. Se supone que ese transmite los dos valores a la vez. Y en el receptor ya se está tratando de leer los dos valores a la vez. El loop() debería de quedarte tal que así:
void loop()
{
emon1.calcVI(20, 2000);
emon2.calcVI(20, 2000);
float dataSend[2] = {emon1.Vrms, emon2.Vrms};
radio.write(&dataSend, sizeof(dataSend)); // Con esto se mandan los dos valores a la vez
// radio.write(&dataSend[0], sizeof(dataSend[0])); // voltage vrms 1 (esta línea no hace falta)
// radio.write(&dataSend[1], sizeof(dataSend[1]));// volatge vrms 2 (esta línea no hace falta)
}
void loop()
{
emon1.calcVI(20, 2000);
emon2.calcVI(20, 2000);
float dataSend[2] = {emon1.Vrms, emon2.Vrms};
radio.write(&dataSend, sizeof(dataSend)); // Con esto se mandan los dos valores a la vez
// radio.write(&dataSend[0], sizeof(dataSend[0])); // voltage vrms 1 (esta línea no hace falta)
// radio.write(&dataSend[1], sizeof(dataSend[1]));// volatge vrms 2 (esta línea no hace falta)
}
Me olvidé de un pequeño detalle. Hay que quitar el & en la línea radio.write(&dataSend, sizeof(dataSend));
Creo que todo el problema viene de ahí. Porque dataSend, sin más, es la dirección de memoria donde están los datos que quieres enviar (se trata de un puntero) y es lo correcto. Mientras que &dataSend es la dirección de memoria que apunta a donde se guarda la dirección de memoria que apunta a donde se guardan los datos (digamos que es el puntero al puntero). Sé que parece un trabalenguas, pero es lo que hay
La línea ha de quedar así: radio.write(dataSend, sizeof(dataSend)); // Con esto se mandan los dos valores a la vez
Me había dado cuenta antes, pero se me olvidó corregirlo al redactar la anterior respuesta.
Me da que ese detalle es el que te ha estado volviendo loco.
Acabo de caer que el mismo fallo está en el receptor. Creo que hay que quitar el & de la línea: radio.read(&dataSend, sizeof(dataSend)); //Reading the data
Lo correcto es: radio.read(dataSend, sizeof(dataSend)); //Reading the data
Si no lo corriges, se están escribiendo datos en una zona de memoria que no debiera. Pudiendo causar que el programa haga cosas raras.
Has de hacer la correción tanto en el emisor como en el receptor para que funcione correctamente.
igual ya le quite el & , ya me esta volviendo loko jejejeje hay algo no lo estoy viendo lo interesante de esto es que despues , que pueda corregir y poder separar los datos leiso y poder usarel condicional viene lo bueno
Aclaración: las funciones radio.write() y radio.read() como primer parámetro reciben un puntero con la primera dirección de memoria donde se alojan los datos. Si la variable que los almacena es un array, basta con poner la variable sin el & y sin los corchetes con el índice, lo mismo si se trata de un puntero. En el caso de ser una variable "normal" o una estructra (struct) sí que hay que poner el &, que es el operador para obtener la dirección donde se ubican los datos de esa variable o estructra.
le quite el & a los codigo , me llegan los datos al rx , pero igual no lo puedo separar
Vrms1
Vrms2
para poder usar el condicional por separado.. si no q llega junto me doy cuenta al imprimirlo por el serial comentando y descomentado
TX
// trasmisor TX
#include <SPI.h>
//#include <nRF24L01.h>
#include <RF24.h>
#include "EmonLib.h" // Include Emon Library
EnergyMonitor emon1;
EnergyMonitor emon2;
RF24 radio(8, 10); // CE, CSN
const byte address[6] = "00001"; //Byte of array representing the address. This is the address where we will send the data. This should be same on the receiving side.
int Led_tx = 2;
float dataSend[2] = {emon1.Vrms, emon2.Vrms};
void setup() {
Serial.begin(9600);
emon1.voltage(0, 150, 1.7);
emon2.voltage(1, 150, 1.7);
pinMode(Led_tx, OUTPUT);
radio.begin(); //Starting the Wireless communication
radio.openWritingPipe(address); //Setting the address where we will send the data
radio.setPALevel(RF24_PA_HIGH); //You can set it as minimum or maximum depending on the distance between the transmitter and receiver.
radio.stopListening(); //This sets the module as transmitter
}
void loop()
{
emon1.calcVI(20, 2000);
emon2.calcVI(20, 2000);
float dataSend[2] = {emon1.Vrms, emon2.Vrms};
radio.write(dataSend, sizeof(dataSend)); // aqui lo quite
radio.write(&dataSend[0], sizeof(dataSend[0])); // voltage vrms 1
radio.write(&dataSend[1], sizeof(dataSend[1]));// volatge vrms 2
}
RX
//PLANTA BAJA
#include <SPI.h>
//#include <nRF24L01.h>
#include <RF24.h>
RF24 radio(8, 10); // CE, CSN
const byte address[6] = "00001";
int RadioRX_ON = 3;
//float dataSend[2] = {dataSend[0], dataSend[1]};
void setup() {
Serial.begin(9600);
radio.begin();
radio.openReadingPipe(0, address); //Setting the address at which we will receive the data
radio.setPALevel(RF24_PA_HIGH); //You can set this as minimum or maximum depending on the distance between the transmitter and receiver.
radio.startListening(); //This sets the module as receiver
}
void loop()
{
if (radio.available()) //Looking for the data.
{
digitalWrite(RadioRX_ON, HIGH);// RADIO ON
float dataSend[2] = {dataSend[0], dataSend[1]};
radio.read(dataSend, sizeof(dataSend)); // aqui lo quite
Serial.println(dataSend[0]); //
// Serial.println(dataSend[1]);
}
}
cuando imprimo por serial en Rx descomento el primero y me llega los 2 float juntos deberia de llegar Vrms1 , descomento el segundo y comento el primero imprime 0.00 asi no puedo usar el condicional porque el programa no va a saber cual usar ..
Serial.println(dataSend[0]); // me llega los 2 float juntos
Has de quitar los & en los dos programas y comentar los dos últimos radio.write() en el emisor. Has de hacer todos los cambios a la vez. El código del emisor ha de quedar así:
{
emon1.calcVI(20, 2000);
emon2.calcVI(20, 2000);
float dataSend[2] = {emon1.Vrms, emon2.Vrms};
radio.write(dataSend, sizeof(dataSend)); // Con esto se mandan los dos valores a la vez
// radio.write(&dataSend[0], sizeof(dataSend[0])); // voltage vrms 1 (esta línea no hace falta)
// radio.write(&dataSend[1], sizeof(dataSend[1]));// volatge vrms 2 (esta línea no hace falta)
}
saludos , si comento las 2 ultima no envia los datos ,
emon1.calcVI(20, 2000);
emon2.calcVI(20, 2000);
float dataSend[2] = {emon1.Vrms, emon2.Vrms};
radio.write(dataSend, sizeof(dataSend)); // Con esto se mandan los dos valores a la vez
radio.write(&dataSend[0], sizeof(dataSend[0])); // voltage vrms 1 recibe en RX
// radio.write(&dataSend[1], sizeof(dataSend[1]));// volatge vrms 2 No recibe
emon1.calcVI(20, 2000);
emon2.calcVI(20, 2000);
float dataSend[2] = {emon1.Vrms, emon2.Vrms};
radio.write(dataSend, sizeof(dataSend)); // Con esto se mandan los dos valores a la vez
// radio.write(&dataSend[0], sizeof(dataSend[0])); // voltage vrms 1 No recibe
radio.write(&dataSend[1], sizeof(dataSend[1]));// volatge vrms 2 recibe RX
No sé si lo has probado comentando las dos líneas a la vez. No se trata de comentar una u otra, se trata de comentar las dos a la vez. Originalmente tenías tres radio.write() y sólo has de dejar el primero sin el & ya que este transmite el array completo, con los dos float. Los otros dos radio.write() sólo transmiten una u otra variable por separado, siendo que sobra y no es correcto porque en el receptor sólo lees el array completo, con los dos elementos.
//PLANTA BAJA
#include <SPI.h>
//#include <nRF24L01.h>
#include <RF24.h>
RF24 radio(8, 10); // CE, CSN
const byte address[6] = "00001";
int RadioRX_ON = 3;
//float dataSend[2] = {dataSend[0], dataSend[1]};
float Vrms1 = 0; // Declaramos las variables donde vamos a guardar los valores recibidos
float Vrms2 = 0;
void setup() {
Serial.begin(9600);
radio.begin();
radio.openReadingPipe(0, address); //Setting the address at which we will receive the data
radio.setPALevel(RF24_PA_HIGH); //You can set this as minimum or maximum depending on the distance between the transmitter and receiver.
radio.startListening(); //This sets the module as receiver
}
void loop()
{
if (radio.available()) //Looking for the data.
{
digitalWrite(RadioRX_ON, HIGH);// RADIO ON
float dataSend[2]; // No hace falta inicializar el array
radio.read(dataSend, sizeof(dataSend)); //Reading the data
Vrms1 = dataSend[0]; // Recuperamos el primer valor
Vrms2 = dataSend[1]; // Recuperamos el segundo valor
// Serial.println(dataSend[0]); //
// Serial.println(dataSend[1]);
if (Vrms1 > 100)
{
// action A
}
else
{
// action B
}
if (Vrms2 < 150)
{
// action A
}
else
{
// action B
}
}
}
Hi,
Para tu consideracion de un link que explica basicamente la comunicacion entre dos NRF24. En la tutoria explica como enviar mas de una variable y como recibirla. Si miran bien casi es como estas tratando de hacerlo pero por alguna razon no les trabaja. La explicacion es bien sencilla para entenderse. Echenlen un vistazo para ver si puden resolver tu problema. Suerte
