| Categoría | Proyecto de usuario |
|---|---|
| Autor | Suso |
| Fecha | 02/11/2015 |
| Concepto | Apertura de puerta de garaje con mando a distancia. |
| Descripción | Un proyecto que combina un par de Arduinos y unos modulos de RF para controlar la apertura de una puerta motorizada mediante un L293D, y un mando a distancia |
| Dificultad | Media |
Objetivos
<
Material requerido.
 |
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 |
Modulos sencillo de RF
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.
|
Transmisor |
Arduino |
|---|---|
| Vcc | 3.3V |
| Data | pin 12 |
| GND | GND |
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:
| Receptor | Arduino |
|---|---|
| Vcc | 5V |
| Data | Pin 11 |
| GNG | GND |
| LED | Pin 13 |
Y para el control del motor
| L293D | Arduino |
|---|---|
| Pin 1, 9, 16 | 5V |
| Pin 2 | D7 |
| Pin 7 | D8 |
| Pin 3 y 6 | Al motor |
| Pin 4 y 5 | GND |
| 8 | Al positivo de la fuente alimentación externa para el 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.
Programa de control
Necesitamos incluir la librería VirtualWire.h la cual nos facilita el manejo de estos módulos.
[highlight variation=»grey»] Transmisor [/highlight] [hr size=»small» top=»no»/]
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
}
[highlight variation=»grey»] Receptor[/highlight] [hr size=»small» top=»no»/]
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;
}
Notas Finales
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