Apertura de garaje con mando a distancia

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

  • Mostrar la aplicación practica de los L293d para montar un control de apertura de una puerta motorizada de garaje..
  • Presentar los módulos RF de 433 MHz.
  • Ver su comportamineto como emisor y receptor.
  •  

    Material requerido.

    Imagen de Arduino UNO  2 x  Arduino UNO o equivalente.
    Protoboard 2 x Protoboard .
    conexiones Algunos cables de protoboard,
     componente  1 x LED rojo
    L293D Un H bridge integrado L293D
     boton contactor Un pulsador
     Emisor + receptor
    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.

    Emisor + receptor

    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.

    Detalle del montaje

    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:

    Vista general

     

    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.Esquema protoboard

    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.

    Esquema protoboard

    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:

  • Controlar los servos con PWM y micropulsos (incluida en una función, por ejemplo)
  • Trabajar con la librería ServoTimer2 (la cual no ha sido probada).
  •  

    Espero les sirva.

    Suso.

    02/11/2015