Categoría Proyecto de usuario
Autor Suso
Fecha 03/13/2015
Concepto Control de acceso con clave alfa numérica.
Descripción Un proyecto que combina un keypad 4×4 y un display LCD 16×02 para establecer una clave de apertura de un control de acceso sencillo
Dificultad Media

 

 

Control de acceso con clave alfanumerica

 

  • Conmutadores de corriente alterna a 220V.
  • Presentar un interruptor inalámbrico de 4 vías.
  • Ver un caso práctico, de cómo conmutar varios dispositivos de 220V.
  •  

    Material requerido.

    <  

      Tienda España
    Imagen de Arduino UNO   Arduino UNO o equivalente.
    detalle Teclado matricial 4×4
    Display LCD Un display LCD, de 16×2 o LCD 20×4, I2C.
    componente Resistencias  1 x 100 Ohm, 1/4W  para el buzzer 2 x 330 Ohm, 1/4W para los LEDs
    Led par Un LED rojo y otro Verde.
    Protoboard
    conexiones Algunos cables de protoboard, preferiblemente Dupont macho/hembra.
    Power supply Fuente de alimentación externa 5V
    Zumbador piezoelectrico  Buzzer pasivo

     

    Simulando un acceso con clave aun local

     

    No es raro que de una forma u otra acabemos encontrandonos con la necesidad de montar un sistema de control que nos permita activar algo, una cerradura por ejemplo, mediante un codigo numerico tecleado en un keypad a modo de clave de control de acceso.

    Y como estoy seguro de que esto es algo que se nos a ocurrido a muchos, pero rara vez sacamos el tiempo suficiente para dedicarle un rato, ha llegado el momento de presentar una solucion que nos envia nuestro colaborador y amigo Jesus, que hace exactamente esto.

    En este precioso proyecto  simularemos el control de acceso a una estancia o la desactivación / activación de algún dispositivo o elemento, utilizando un teclado matricial 4×4 y un display LCD 16×2.

    También nos serviría para la desactivación de una alarma, pero eso requiere un proyecto más complejo pues se deben anular diversos sensores tipo PIR, magnéticos, sirena, etc, aparte de un sistema antisabotaje. Pero como base para montajes mayores nos sería útil.

    • Los Tened en cuenta que el problema con las alarmas y sistemas de seguridad, no es tanto su montaje e implementación, como desarrollar la certeza de que no estamos siendo hackeados, es decir que no nos están puenteando la linea o los sensores de modo que se cuelen los malos mientras nosotros en nuestra inocencia creemos que todo va bien.
    • El desarrollo de este tipo de contra medidas y de los sistemas de detección temprana de intrusión es lo que complica sobremanera el desarrollo de los circuitos de seguridad y alerta temprana.  

    Controlaremos el display LCD con el conversor I2C para sólo utilizar dos pines de Arduino para su control. Así mismo, alimentaremos el display con una fuente externa de 5V, para no sobrecargar nuestro Arduino, sobre todo cuando se ilumina la pantalla.

    El motivo fue que al activar la retroiluminación y encender un LED, bajaba un poco la intensidad del display, síntoma de falta de corriente y con la alimentación externa para el display se solucionó el problema.

    Para introducir la clave, usaremos un teclado matricial 4×4 similar a este:

    detalle

    Led par

    Zumbador piezoelectrico

    También colocaremos dos LEDs, uno rojo y otro verde, para indicar «sistema cerrado o abierto». Y por último, un buzzer (o zumbador) para emitir sonido al pulsar las teclas y también para indicar clave erronea o correcta.

    Estos serían los pines de conexión:

    Arduino
    Keypad:

    De izquierda a derecha según la  imagen

      9, 8, 7, 6, 5, 4, 3, 2

     

    Arduino A4 A5 GND 5V 10 11 12
    Display I2C SDA SCL GND Vcc
    LED Verde X
    LED Rojo X
    Buzzer X

    El montaje quedaría algo así:esquema de protoboard

    Las pilas conectadas al display simbolizan la fuente de 5V externa para alimentarlo, dejando a Arduino solo para el control. En el esquema se puede ver a Arduino alimentando con 5V la protoboard, pero no es necesario, salvo que se quiera añadir algún otro componente.

     

    Programa de control

     

    Antes de nada vamos a necesitar un par de librerías para manejar el display y el teclado. Para el teclado vamos a usar Libreria keypad y para el display Liquid Crystal I2C que ya hemos usado en sesiones anteriores.

    Este sería el sketch: Control_acceso

    #include <LiquidCrystal_I2C.h>
    #include <Wire.h>
    #include <Keypad.h>
     /* Funcion de configuracion de pines del modulo LCD/I2C 
        (Direccion,en,rw,rs,d4,d5,d6,d7,backlight,polaridad)*/
     LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
    
    const byte Filas = 4;  //Cuatro filas
    const byte Cols = 4;   //Cuatro columnas
    byte Pins_Filas[] = {9,8,7,6};//Pines Arduino a las filasbyte 
    Pins_Cols[] = {5,4,3,2}; // Pines Arduino a las columnas.
    //no utilizar los pines 1 y 0 para no interferir en Rx y Tx
    
    char Teclas [ Filas ][ Cols ] =
     {
        {'1','2','3','A'},
        {'4','5','6','B'},
        {'7','8','9','C'},
        {'*','0','#','D'}
     };
    
    char codigoSecreto[4] = {'2','2','5','5'}; // Aqui va el codigo secreto
    // Para cambiar el tamaño de la clave, solo hay que cambiar el tamaño del array
    
    int posicion=0;    // necesaria para la clave
    int cursor=5;      // posicion inicial de la clave en el LCD
    int clave=0;       // para el LCD
    int luz=0;         // para el LCD
    int tiempo=0;      // para el LCD
    int ledVerde=11;   // pin para el LED verde
    int ledRojo=12;    // pin para el LED rojo
    int buzzer=10;     // pin altavoz
    
    Keypad Teclado1 = Keypad(makeKeymap(Teclas), Pins_Filas, Pins_Cols, Filas, Cols);
    
    void setup()
       {
          Serial.begin(9600) ;
          lcd.begin(16,2);       // inicializamos el LCD.
          lcd.noBacklight();     // apagamos LCD
          pinMode (ledVerde,OUTPUT);
          pinMode (ledRojo, OUTPUT);
          pinMode (buzzer, OUTPUT);
          digitalWrite(ledRojo,HIGH); // encendemos el LED rojo
          digitalWrite(ledVerde, LOW); // apagamos el verde
    
          lcd.setCursor(0,0);     // situamos el cursor el la posición 2 de la linea 0.
          lcd.print("Introduzca clave"); // escribimos en LCD
          lcd.setCursor(cursor,1); // cursor en la posicion de la variable, linea 1
        }
    
    void loop()
       {
          char pulsacion = Teclado1.getKey() ; // leemos pulsacion
          if (pulsacion != 0) //Si el valor es 0 es que no se ha pulsado ninguna tecla
            { // descartamos almohadilla y asterisco
              if (pulsacion != '#' && pulsacion != '*' && clave==0)
               { lcd.print(pulsacion); // imprimimos pulsacion
                 cursor++;             // incrementamos el cursor
                 tone(buzzer,350);     // tono de pulsacion
                 delay(200);
                 noTone(buzzer);
    
          //--- Condicionales para comprobar la clave introducida -----------
          // comparamos entrada con cada uno de los digitos, uno a uno
          if (pulsacion == codigoSecreto[posicion])
              posicion ++; // aumentamos posicion si es correcto el digito
    
          if (posicion == 4)
           { // comprobamos que se han introducido los 4 correctamente
             digitalWrite (13,HIGH);  // encendemos LED
             lcd.setCursor(0,0);      // situamos el cursor el la pos 0 de la linea 0.
             lcd.print("Clave correcta ");         // escribimos en LCD
             delay(200);                           // tono de clave correcta
             tone(buzzer,500);
             delay(100);
             noTone(buzzer);
             tone(buzzer,600);
             delay(100);
             noTone(buzzer);
             tone(buzzer,800);
             delay(100);
             noTone(buzzer);
    
             lcd.setCursor(5,1); // cursor en la posicion 5, linea 1
             clave=1; // indicamos que se ha introducido la clave
             digitalWrite(ledRojo,LOW); // apagamos el LED rojo
             digitalWrite(ledVerde, HIGH); // encendemos el verde
         }
         //--- En el caso de que este incompleta o no hayamos acertado ----------
         if(cursor>8)        // comprobamos que no pase de la cuarta posicion
           {   cursor=5;     // lo volvemos a colocar al inicio
               posicion=0;           // borramos clave introducida
               lcd.setCursor(5,1);
               lcd.print(" ");       // borramos la clave de la pantalla
               lcd.setCursor(5,1);
               if(clave==0)         // comprobamos que no hemos acertado
                  { tone(buzzer,70,500); // para generar
                    delay(250); // tono de error
                    noTone(buzzer);
                  }
            }
         }
       } 
    
     //--- Condicionales para encender o apagar el LCD --------------
     if (pulsacion == '#' && luz==0)
         { // comprobamos tecla y encendemos si esta apagado
           lcd.backlight(); // encendemos
           luz=1; // indicamos que esta encendida
           pulsacion =0; // borramos el valor para poder leer el siguiente condicional
         }
    
     if (pulsacion == '#' && luz==1)
         { // comprobamos tecla y estado
           lcd.noBacklight(); // apagamos
           luz=0; // indicamos que esta apagada
         }
    
     //--- Condicionales para resetear clave introducida -------------
     if (pulsacion == '*')
         { // asterisco para resetear el contador
           posicion = 0;
           cursor = 5;
           clave=0;
           posicion=0;
           lcd.setCursor(0,0); // situamos el cursor el la posición 2 de la linea 0.
           lcd.print("Introduzca clave"); // escribimos en LCD
           lcd.setCursor(5,1);
           lcd.print(" "); // borramos de la pantalla los numeros
           lcd.setCursor(5,1);
        
           digitalWrite(ledRojo,HIGH); // encendemos el LED rojo
           digitalWrite(ledVerde, LOW); // apagamos el verde
        }
     }

    Para simular aún más el supuesto panel de control de acceso, he aprovechado la parte trasera de una tablet en deshuso, la cual traía ya el buzzer incorporado, quedando finalmente de esta manera:

    Entrada de clave alfa numerica

    La parte trasera quedó con este desorden de cables…

    Vista posterior

    que evidentemente está así pues no es un proyecto final, el cual se puede mejorar aún más, cambiando, por ejemplo, la placa UNO por un Arduino Nano y acortando el cableado y demás.

    En la primera foto se pueden ver los dos cables de alimentación. Uno corresponde al puerto USB el cual alimenta a Arduino, y el otro sólo alimenta el display LCD con 5V. Esta parte también se puede pulir alimentando todo el conjunto con una fuente de 7 ó 9 voltios, a Arduino mediante el jack de alimentación y al display mediante un regulador LM7805.

    • Podemos también usar un alimentador común de 1 Amperio, para nuestro Arduino, y con un único conector quedaría alimentado todo el circuito.Power supply 

    Espero les haya gustado.

    Saludos.

    Suso.
    29/11/2015


    Deja una respuesta