Apertura de garaje con mando a distancia

	2 x  Arduino UNO o equivalente.
	2 x Protoboard .
	Algunos cables de protoboard,
	1 x LED rojo
	Un H bridge integrado L293D
	Un pulsador
	una pareja de módulos RF 433 MHz
	fuente de alimentación externa para el motor

Estos módulos, de muy bajo costo, son utilizados para radio control. Trabajan con una frecuencia de radio de 433 MHz, pertenecientes a la banda UHF de 70 cm, la cual comparte segmentos con otros servicios y aplicaciones, como los mandos de garaje, transmisores para conferencias, dispositivos inalámbricos de TV, etc.

En la imagen superior, se pueden ver el módulo transmisor (izquierda) y el módulo receptor (derecha). La transmisión de datos es en modo simplex (unidireccional) y a una velocidad no superior a 10 Kbps.

No traen antenas, las cuales hay que añadir soldándolas en los respectivos puntos marcados como «ANT». Estas antenas se pueden comprar o hacerla uno mismo.

Las antenas para estos módulos suelen ser de 1/4 de la longitud de onda, que en 433 MHz corresponde a unos 17 cm (También se suele ver como 16.5 cm).

Nosotros usaremos 30 cm para el transmisor, de tipo látigo y para el receptor la tipo helicoidal.

Para el transmisor, cogeremos 30 cm de cable rígido y pelando un poco uno de sus extremos, procedemos a soldarlo en la zona indicada como «ANT». El cable debería quedar perpendicular al suelo

Para el receptor, cogemos los 30 cm restantes, los arrollamos alrededor de un bolígrafo o similar, dejando un pequeño extremo en una punta para soldar y en la otra punta 1 cm aproximadamente. Luego la estiraremos un poco.

Se puede probar con otras medidas en la antena emisora y receptora, pero las diferencias parecen ser poco significativas. Se pueden hacer ensayos con otras medidas en base a los 17 cm. El alcance conseguido con las medidas expuestas en el montaje fué de 10 metros en interior. No se ha comprobado mayor distancia por limitación de espacio.

Es importante no acercar cables de alimentación o fuentes de ruido (motores) a las antenas. Deben estar alejadas de cables o similares pues pueden afectar a la transmisión.

Se puede montar los módulos sobre un soporte para elevarlos del plano de tierra, y así alejarlos de cableado y demás, y mejorar la emisión y recepción de la señal:

El transmisor admite voltajes entre 3.5V y 12V, en cambio el receptor sólo admite 4.5V y 5.5V. El consumo es mínimo, teniendo el transmisor una potencia de 25mW a 12V y el receptor un consumo de unos 5.5mA.

Se recomienda alimentar el transmisor con 3.3V para evitar la influencia del ruido, aunque se puede probar con otros voltajes para mayor potencia y alcance, no superando los 12V. El receptor lo alimentaremos con 5V.

Las conexiones son muy simples: Vcc, GND y datos, con lo que sólo necesitamos un pin para cada Arduino.

Resistencia entre Vcc y pata izquierda del pulsador.

Pin 7 a la pata izquierda del pulsador.

Pata derecha del pulsador a GND.

Nota: La resistencia que aparece en el esquema es de 1K. Se obtuvo mejor resultado con una de 330 Ohm

Las conexiones del módulo receptor son algo más laboriosas:

Y para el control del motor

No olvidar unir la GND de Arduino a la GND de la fuente externa.

El receptor trae dos pines DATA. Es indiferente a cual conectarlo. La batería representa la fuente externa para el motor, la cual puede ser otra equivalente.

Para este proyecto he usado un Arduino Mega en el receptor. Si se va a utilizar un Arduino Uno o Nano, se debe cambiar los pines 7 y 8 por otros PWM, como el 3, 5, 6, 9 y 10, ya que necesitamos que sean PWM para poder controlar la velocidad el motor.

Necesitamos incluir la librería VirtualWire.h la cual nos facilita el manejo de estos módulos.

EL programa del emisor quedaría parecido a esto mas o menos:

/* 
Modulo RF 433 MHz. Simulacion apertura de garaje
Sketch del transmisor

Envía la orden de ACTIVAR al pulsar un boton. El receptor la recibe y acciona el motor. */

#include <VirtualWire.h>  //  libreria para los modulos RF
int pinBoton = 7;         // para la lectura del boton
int boton = 0;            // estado del boton
 
void setup()
   { 
      vw_setup(2000);     //  iniciamos la comunicacion por radio
      pinMode(pinBoton, INPUT);  // definimos como entrada
   }

void loop()
   {  boton = digitalRead(pinBoton);    // leemos la entrada
      if(boton == LOW)                  // si se ha pulsado
         {  send("activar");            // enviamos activar
            delay(100);
         }
   }

//Funcion para enviar el mensaje
void send (char *message)
   {  vw_send((uint8_t *)message, strlen(message)); //Envia el mensaje
      vw_wait_tx();         // Espera hasta acabar de transmitir todo
   } 

Y en cuanto al receptor queda algo así:

/* Modulo RF 433 MHz
   Sketch del receptor

Espera hasta recibir la orden ACTIVAR para accionar un motor
durante algunos segundos, hay una pausa y el motor vuelve a 
girar en sentido contrario, simulando la apertura de una
puerta de garaje. Durante el movimiento, se activa un LED. Luego
queda a la espera de una nueva orden.
*/

#include <VirtualWire.h>  // libreria para utilizar los modulos RF

byte message[VW_MAX_MESSAGE_LEN]; //Creamos un mensaje
byte messageLength = VW_MAX_MESSAGE_LEN; //La constante VW_MAX_MESSAGE_LEN viene definida en la libreria

void setup()
   {  pinMode(13, OUTPUT);          //Configuramos el pin 13
      pinMode(7, OUTPUT);           //pines para el motor
      pinMode(8, OUTPUT);

      vw_setup(2000);         // iniciamos la comunicacion por radio
      vw_rx_start();
   }

void loop()
   { analogWrite(7,0);        // apagamos motor
     analogWrite(8,0);

     if (vw_get_message(message, &messageLength)) // leemos el mensaje          { if(comparar("activar") == 0)
            { // comparamos el mensaje
              digitalWrite(13, HIGH);     // encendemos LED
              analogWrite(7,180); // encendemos motor en un sentido
              analogWrite(8,0); // el valor 180 controla la velocidad de giro
              delay(4000);            // esperamos 4 segundos
              analogWrite(7,0);       // apagamos motor
              analogWrite(8,0);
              delay(3000);            // esperamos 3 segundos
              analogWrite(7,0);   // encendemos motor en sentido opuesto
              analogWrite(8,180);
              delay(4000);             // esperamos 4 segundos
              analogWrite(7,0);        // apagamos motor
              analogWrite(8,0);
              digitalWrite(13, LOW);      // apagamos LED
            }
        }
   } 

char comparar(char* cadena) 
   {   // Esta funcion compara el string cadena con el mensaje recibido.
       // Si son iguales, devuelve 1. Si no, devuelve 0.

       for(int i = 0; i<messageLength; i++)  
          {    if(message[i] != cadena[i])  
                  return 1;
          }
       return 0;
   }

Podemos jugar con la longitud de las antenas emisora y receptora, así como el voltaje del módulo transmisor, sin sobrepasar los 12V.

En el montaje propuesto, se consiguió activar el receptor a unos 8 metros sin contacto visual, encontrándos el transmisor en una estancia y el receptor en otra.

La librería VirtualWire.h entra en conflicto con la librería Servo.h, al utilizar las dos el Timer de Arduino,  con lo que para usar servomotores con estos módulos tenemos dos opciones:

Espero les sirva.

Suso.

02/11/2015