domingo, 14 de diciembre de 2014

Enviando datos a través de modulo RF 433Mhz


Ya hicimos una práctica enviando mensajes a través de un modulo de RadioFrecuencia y dos Arduinos. Pero en ese caso simplemente estábamos enviando un mensaje de tipo char mediante la librería VirtualWire.h.
Lo que vamos a hacer ahora es totalmente distinto ya que vamos a enviar datos de tipo Int empleando la librería RCSwitch.h.
<RCSwitch.h> Es una librería de Arduino que nos permite el envío y recepción de datos vía RF con módulos de 315/433MHz.
Podemos descargarla en el siguiente link:

Una vez descargada  y copiada en la carpeta libraries donde tengamos instalado nuestro Arduino IDE nos ponemos manos a la obra.

¿En que consiste la práctica?

Usaremos un Arduino NANO(el que tenia mas cerca)+el EMISOR, para hacer un conteo de datos tipo int cada vez que pase por el bucle Loop. El segundo conteo de datos lo realizará cada vez que excitemos el pin digital 11 en estado alto(simplemente puenteando 5V o con un sensor que nos envíe un pulso).  Estos contadores los guardaremos en las variables valor1 y valor2.

Primero conteo lo almacenamos en la variable----->> valor1
Segundo conteo lo almacenamos en la variable----->> valor2
Aquí vemos la parte del código que se encarga de ello.

void loop()
{
  valor1++; // Cada vez que pasa por el bucle Suma 1 a la variable valor1
  Serial.print(valor1);
  
  zona1 = digitalRead(digitalInput1); // Si detecta un estado alto en el pin digital de entrada 11 Suma 1 a la variable valor2
  if (zona1 ==1)
    {
    valor2++;
    zona1 =0;
    Serial.print(valor2);
    }

¿Por que hacemos esto? Bien, me explico. Estamos guardando en dos variables unos datos diferentes y ahora queremos enviarlo usando el mismo dispositivo. Para mandar los datos usaremos la función .send  de esta librería y asociaremos cada variable con un tamaño.

  myRF.send(valor1, 10); // envía el dato de la variable valor1 asignando un tamaño de 10 bits
  myRF.send(valor2, 12); // envía el dato de la variable valor1 asignando un tamaño de 12 bits

Aquí vemos al NANO enviando datos...
Se puede apreciar que solo necesitamos 3 hilos Vcc, Gnd y el pin 10 para el envío.



Por otra parte nuestro Receptor  se va a encargar de separar estos datos recibidos en función de su tamaño para poder trabajar con ellos o simplemente visualizarlos. Emplearemos un Arduino UNO, tal y como vemos en la imagen asignando el pin DATA con el Pin 2 digital(corresponde a la interrupción 0 del Arduino UNO).



Veamos como separar los datos en nuestro Sketch de recepción. Crearemos una condición de que si hay datos RF almacenaremos en la variable datob el tamaño del paquete, posteriormente con dos condicionantes if separaremos si son paquetes de 10 o 12 bits, guardando en valor1 o valor2 según corresponda.

 if (myRF.available())  // ¿hay datos?
  {
  datob = myRF.getReceivedBitlength();  /* mediante esta función leemos el tamaño del paquete que estamos recibiendo y lo almacenamos en la variable datob, de esta forma hacemos una criba de los paquetes recibidos en función de su tamaño 10 o 12 Bits. */
      if(datob==10)    // si datob=10b
    {
      valor1=myRF.getReceivedValue();  // almacenamos en la variable valor1 el dato recibido
      Serial.println(valor1);
    }
          if(datob==12)  // si datob=12b
    {
      valor2=myRF.getReceivedValue();  // almacenamos en la variable valor2 el dato recibido
      Serial.println(valor2);
      delay(1000);
    }
    myRF.resetAvailable();  // para terminar hacemos un reset
    delay(100);
  }


Y con esto ya lo tenemos funcionando. Es importante establecer el tamaño de bits correspondiente a cada variable, es decir si asignamos a una variable 10 bits sabemos que es igual a 1024, por tanto no podremos trabajar con valores mayores.



Sketch del emisor:


#include <RCSwitch.h> 
RCSwitch myRF = RCSwitch();  /* Asignamos el nombre a la libreria para el uso de las funciones que esta nos permite, yo la he llamado myRF */

int zona1=0,valor1=0,valor2=0;
int digitalInput1 = 11; // Asociales el pin11 como entrada digital

void setup()
{  
  Serial.begin(9600);
  myRF.enableTransmit(10); /* Habilitamos y Establecemos el pin digital para el envío de datos en este caso el 10 */
}
  
void loop()
{
  valor1++; // Cada vez que pasa por el bucle Suma 1 a la variable valor1
  Serial.print(valor1);
  
  zona1 = digitalRead(digitalInput1); // Si detecta un estado alto en el pin digital de entrada 11 Suma 1 a la variable valor2
  if (zona1 ==1)
    {
    valor2++;
    zona1 =0;
    Serial.print(valor2);
    }
  myRF.send(valor1, 10); // envía el dato de la variable valor1 asignando un tamaño de 10 bits
  myRF.send(valor2, 12); // envía el dato de la variable valor1 asignando un tamaño de 12 bits
  }


Sketch del receptor:  

#include <RCSwitch.h>
RCSwitch myRF = RCSwitch();  
int datob,valor1,valor2;  // definimos las variables

void setup()
{
    Serial.begin(9600);
    myRF.enableReceive(0);  /* Habilitamos el receptor en la interrupción 0 => Pin 2 Digital(Para Arduino UNO) */
}

void loop()
{
  if (myRF.available()) 
  {
  datob = myRF.getReceivedBitlength();  /* mediante esta función leemos el tamaño del paquete que estamos recibiendo y lo almacenamos en la variable datob, de esta forma hacemos una criba de los paquetes recibidos en función de su tamaño 10 o 12 Bits. */
      if(datob==10)  
    {
      valor1=myRF.getReceivedValue();  // almacenamos en la variable valor1 el dato recibido
      Serial.println(valor1);
    }
          if(datob==12)
    {
      valor2=myRF.getReceivedValue();  // almacenamos en la variable valor2 el dato recibido
      Serial.println(valor2);
      delay(1000);
    }
    myRF.resetAvailable();  // para terminar hacemos un reset
    delay(100);
  }  
}

No hay comentarios:

Publicar un comentario