{"id":794,"date":"2012-01-10T22:28:38","date_gmt":"2012-01-10T21:28:38","guid":{"rendered":"http:\/\/electronicapractica.crearblog.com\/?p=794"},"modified":"2020-12-29T11:28:33","modified_gmt":"2020-12-29T10:28:33","slug":"teclado-numerico-3x4-con-lcd","status":"publish","type":"post","link":"https:\/\/www.diarioelectronicohoy.com\/blog\/teclado-numerico-3x4-con-lcd","title":{"rendered":"Teclado num\u00e9rico 3×4 con LCD"},"content":{"rendered":"

Prologo.<\/span><\/h2>\n

En otro art\u00edculo ya hice un esbozo superficial sobre las pantallas de cristal l\u00edquido LCD, distinguiendo dos grandes grupos, las pantallas alfanum\u00e9ricas y las pantallas gr\u00e1ficas. Por el momento, nos referiremos las pantallas LCD alfanum\u00e9ricas, en concreto las de cuatro l\u00edneas y 40 columnas. En la actualidad la mayor\u00eda de los LCD est\u00e1n controlados con el conocido HD44780 de Hitachi. El cual puede ser configurado para manejar un display de matriz de puntos de cristal l\u00edquido bajo el control de un microprocesador de 4 u 8 bits.<\/p>\n

En este art\u00edculo, pretendo hacer una aplicaci\u00f3n que tenga utilidad para quien disponga de un LCD y quiera realizar una aplicaci\u00f3n que le sirva de ayuda en su trabajo o para una aplicar en un proyecto. Hay muchas aplicaciones descritas en gran cantidad de art\u00edculos y webs de distintos autores y en todas ellas subyace un ‘toque’ personal que hace la diferencia, espero que en este, tambi\u00e9n encuentren la novedad o el punto que buscaban.<\/p>\n

El prop\u00f3sito de este art\u00edculo es reunir una serie de unidades sencillas, como base de los ejemplos, con pantalla de cristal l\u00edquido LCD, que se encuentran disponibles para trabajar con Arduino. Se describen algunos ejercicios para comprender los principios de uso y sin perder el car\u00e1cter did\u00e1ctico de lo descrito.<\/p>\n

Display LCD.<\/span><\/h2>\n

El uso de este dispositivo se ha extendido en los \u00faltimos a\u00f1os debido a la proliferaci\u00f3n de los microcontroladores con sus cada ves mayores prestaciones y los sistemas de desarrollo que los sustentan. Hay esencialmente dos tipos de pantalla para elegir, serie y paralelo, en referencia a c\u00f3mo se conectan y se comunican con el mismo PC.<\/p>\n

\"\"<\/a>En cuanto a los LCD, en el mercado pueden encontrarse distintos modelos que se adaptan a las necesidades de los proyectos que se planteen. As\u00ed, podemos encontrar LCD de una l\u00ednea y 8 a 40 caracteres, 4 l\u00edneas por 40 caracteres y tantas l\u00edneas y caracteres que se necesiten. Los LCD gr\u00e1ficos est\u00e1n avanzando tanto que sus precios son cada d\u00eda m\u00e1s asequibles a cualquier necesidad.<\/p>\n

\"\"<\/p>\n

La mayor\u00eda de los LCD paralelos son muy similares, usan chips de interfaz est\u00e1ndar en la industria (como el HD44780<\/strong> o HD44100<\/strong>) para la asignaci\u00f3n de pines, a menudo son id\u00e9nticos.<\/p>\n

\"\"<\/a>En este art\u00edculo, s\u00f3lo tratar\u00e9 de los LCD de cuatro l\u00edneas y 20 caracteres o columnas. Naturalmente por que es el que tengo a mi disposici\u00f3n. Para controlar pantallas Cristal Liquido (LCD) basada en el Hitachi HD44780 (o compatible) se necesita la \u00abNueva librer\u00eda LiquidCrystal\u00bb<\/a> que nos proporciona FM, como se le conoce en el foro. Adem\u00e1s, tambi\u00e9n utilizaremos un teclado 3×4 similar al de la imagen de abajo, dos resistencias, dos LED’s, dos pulsadores y algunos hilos de colores para conectar todo.No voy a entrar sobre los pros y los contras de cada uno, ya que este no es el objetivo del presente art\u00edculo, sin embargo, lo que voy a decir es que que, fundamentalmente, la decisi\u00f3n se reduce a su costo en comparaci\u00f3n con la facilidad de uso, es la cuesti\u00f3n.<\/p>\n

\"\"<\/a>Si bien los display’s serie son m\u00e1s f\u00e1ciles de poner en marcha y tienen un poco mejor ayuda con el software, adem\u00e1s de tener algunas caracter\u00edsticas adicionales. Por otro lado, los LCD paralelos, necesita cablearlas usted mismo, pero son mucho m\u00e1s baratos y en su mayor parte se puede mostrar la misma informaci\u00f3n.<\/p>\n

\"\"<\/a>\"\"<\/a>Lo que pretendo realizar es un teclado, con el que introducir una clave de un n\u00famero de entre 4, 6 o m\u00e1s d\u00edgitos y el programa compare los d\u00edgitos que se pulsan por el usuario, con la clave guardada y si hay coincidencia que, haga una cosa, en caso de no coincidir que, haga otra cosa. En principio, se ve sencillo.<\/p>\n

\"\"<\/a>\"\"Para abordar el proyecto, necesitamos unos pocos materiales a parte de la placa Arduino y el LCD, como estos mostrados.<\/p>\n

El m\u00e1s importante, el teclado, este tipo de teclados, a pesar de que es de los a\u00f1os 80 (foto de Futurlec<\/a>), es bastante corriente y f\u00e1cil de encontrar en el mercado. El resto de componentes, es de uso com\u00fan. El circuito electr\u00f3nico que voy a utilizar se muestra en la imagen que sigue.<\/p>\n

\"\"<\/a>Mediante la ayuda de un teclado de 12 pulsadores, podemos entrar una serie de d\u00edgitos que, formen el c\u00f3digo \u00absecreto\u00bb para activar un sistema, si existe coincidencia o por el contrario, pondr\u00e1 en acci\u00f3n otro sistema que indique que, se est\u00e1 forzando el acceso no autorizado a la instalaci\u00f3n, por un desconocido.<\/p>\n

Para esto, en primer lugar debemos configurar la librer\u00eda Keypad.zip<\/a> y declararemos los 7 pines de Arduino que conformaran el teclado, por un lados las 4 l\u00edneas (rows) y las 3 columnas (cols) y la conformaci\u00f3n que tomar\u00e1n los contactos, como se puede ver a continuaci\u00f3n:<\/p>\n

El primer paso es incluir la librer\u00eda y las constantes que vamos a utilizar:<\/p>\n

<\/p>\n

 #include \"Keypad.h\" \r\n\r\n const byte ROWS = 4; \/\/four rows \r\n const byte COLS = 3; \/\/three columns \r\n char keys[ROWS][COLS] = { \r\n  {'1','2','3'}, \r\n  {'4','5','6'}, \r\n  {'7','8','9'}, \r\n  {'*','0','#'} \r\n };<\/pre>\n
El paso que sigue es, reservar memoria en bytes, para los valores de los pulsadores y la asignaci\u00f3n del pin que se corresponde con los de Arduino. Sin embargo, hay que observar que, vamos a necesitar un n\u00famero alto de pines en este y los siguientes ejemplos. Por este motivo, la asignaci\u00f3n de pines, se hace con vistas a no tener que cambiar con frecuencia dicha disposici\u00f3n. Adem\u00e1s, se asignaran otras variables, en funci\u00f3n de las necesidades que surjan.<\/p>\n
  byte rowPins[ROWS] = {5, 4, 3, 2}; \/\/conecta los pinouts row del keypad \r\n  byte colPins[COLS] = {8, 7, 6}; \/\/conecta los pinouts column del keypad<\/pre>\n
Este es el momento de ‘crear’ el teclado propiamente dicho, es decir, con esta sentencia, el programa generar\u00e1 una matriz que ver\u00e1 como un teclado, al que se remitir\u00e1, cuando tenga que representar un d\u00edgito. Esto se consigue con la siguiente l\u00ednea:<\/p>\n
 Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );<\/pre>\n
Tenemos que guardar una clave, luego, necesitamos hacer una reserva de memoria y adem\u00e1s, el c\u00f3digo que introduzca el usuario, tambi\u00e9n requiere un espacio de memoria. Posteriormente, con s\u00f3lo comparar ambas matrices, obtendremos f\u00e1cilmente si hay coincidencia entre ambas. Veamos como se hace:<\/p>\n
  char PIN[6]={'1','2','3','4','5','6'}; \/\/ o numero secreto (!) \r\n  char attempt[6]={0,0,0,0,0,0}; \/\/ usado para comparar<\/pre>\n
En la asignaci\u00f3n de las dos matrices de 6 d\u00edgitos, utilizamos la funci\u00f3n char<\/strong> para almacenar los bytes de cada matriz. Una, para los d\u00edgitos de entrada llamada attempt<\/strong>, se comparar\u00e1n con la otra matriz, contenida en PIN<\/strong>. S\u00f3lo, si hay coincidencia, la clave es correcta y actuar\u00e1 la salida correspondiente. Se han dispuesto dos salidas complementarias, las cuales se pueden conectar a los dispositivos adecuados que, deriven la potencia necesaria para sus actuadores.<\/p>\n
En el setup<\/strong>, configuramos los distintos pines, seg\u00fan convenga a cada uno, se declara el puerto serie y su velocidad:<\/p>\n
 pinMode(sal1, OUTPUT); \r\n pinMode(sal2, OUTPUT); \r\n Serial.begin(9600); \/\/Configura la velocidad del puerto serie \r\n\r\n keypad.setHoldTime(500); \/\/ Default is 1000mS \r\n keypad.setDebounceTime(250); \/\/ Default is 50mS<\/pre>\n
Destacar las funciones que afectan al rebote de los pulsadores que, est\u00e1n integrados en la librer\u00eda keypad<\/strong> representados por keypad.setHoldTime<\/strong> y keypad.setDebounceTime<\/strong>. Aqu\u00ed. se ha reducido su tiempo de mantenimiento como se puede apreciar en el propio c\u00f3digo.<\/p>\n
Adem\u00e1s, se ha incluido el mensaje que presentar\u00e1 al inicio del programa. En este mensaje, se puede hacer una descripci\u00f3n corta de lo que hay que hacer para entrar el c\u00f3digo PIN. Esto se ha hecho con el siguiente c\u00f3digo:<\/p>\n
 Serial.println(\" Debe introducir la secuencia: \"); \r\n Serial.print(\" * X X X X X X # \"); \r\n Serial.println(\" >> X = del 0 al 9\"); \r\n incorrectPIN();Serial.print(\" \"); \r\n Serial.println(\" Intentelo: \");<\/pre>\n
En este punto, para una mayor claridad, se deben declarar las rutinas que intervengan en el programa, acu\u00e9rdese de hacer comentarios, para poder comprender qu\u00e9 hace cada rutina. As\u00ed pues, se declara la rutina void correctPIN()<\/span> que, se ejecutar\u00e1 en el caso de haber coincidencia, es decir:<\/p>\n
 digitalWrite(10, LOW); \/\/ desactiva un contacto pin 1 \r\n digitalWrite(11, HIGH); \/\/ activa un contacto pin 2<\/pre>\n
Y le seguir\u00e1 la rutina void incorrectPIN()<\/span> que se ejecutar\u00e1 en el caso contrario. Que hace exactamente lo mismo pero invertidos<\/p>\n
 digitalWrite(11, LOW); \/\/ desactiva un contacto pin 2 \r\n digitalWrite(10, HIGH); \/\/ activa un contacto pin 1<\/pre>\n
Se ha incluido una rutina para activar un sistema (en este caso, visual) para activar un LED en su caso. Con void readKeypad()<\/strong>, se lee cualquier entrada de teclado, o sea, hace un chequeo del teclado, de modo que cuando se presione un pulsador o llave. Esto lo consigue mediante este c\u00f3digo, asignando a char key<\/strong>, todo lo que llegue por el teclado con: char key = keypad.getKey();<\/span> si no se produce una entrada, permanecer\u00e1 en espera. Gracias a esta sentencia de if (key != NO_KEY)<\/span>, en la cual permanecer\u00e1 la ejecuci\u00f3n del programa, esperando a que se produzca una entrada. As\u00ed que, este es el listado:<\/p>\n
 char key = keypad.getKey(); \r\n if (key != NO_KEY)<\/pre>\n
Le sigue la funci\u00f3n switch (key)<\/span> que es capaz de detectar la tecla que se ha pulsado. Cuando se produce una entrada del teclado, se guarda en la variable attempt<\/span>, lo reconoce y eval\u00faa con PIN[]<\/span> si es exactamente igual, sale de esta subrutina y salta a la subrutina correctPIN()<\/span> y sigue hasta el final de la misma.<\/p>\n
En caso de que la evaluaci\u00f3n no sea exacta, salta a la subrutina incorrectPIN();<\/span> y cuando termina, vuelve hasta la l\u00ednea: for (int zz=0; zz<6; zz++) <\/span> \/\/ borrar tentativa<\/span>, para borrar la tentativa actual.<\/p>\n
En \u00faltimo lugar est\u00e1 el lazo o loop()<\/span> que, en este caso, contiene la llamada a readKeypad();<\/span> que ejecutar\u00e1 continuamente.<\/p>\n
Veamos un primer ejemplo, este es el c\u00f3digo para el programa de reconocimiento de clave:<\/p>\n
N\u00famero PIN<\/span><\/h2>\n
\/\/ \r\n\/\/ pin_clave.pde - keypad switch con seis-digitos para el PIN \r\n\/\/ basado en un programa de: http:\/\/tronixstuff.wordpress.com\/ \r\n\r\n\/* Usando el actual ejemplo de hardware se pueden activa algo o\r\ndesactivar mediante el teclado - emulando lo que se puede \r\nencontrar en algunos sistemas de alarma y as\u00ed\u00ad sucesivamente. \r\nNuestro objetivo con este ejemplo es muy simple. El sistema \r\nespera para obtener un PIN que se guarda previamente. \r\nSi el PIN es correcto, hacer algo. Si el PIN es incorrecto, \r\nhacer otra cosa. Este ejemplo es para darle un concepto y un \r\nmarco para construir ideas propias. \r\n 19.10.2011 funciona bien. \r\n*\/ \r\n#include \"Keypad.h\" \r\nconst byte ROWS = 4; \/\/four rows \r\nconst byte COLS = 3; \/\/three columns char \r\nkeys[ROWS][COLS] = { \r\n {'1','2','3'}, \r\n {'4','5','6'}, \r\n {'7','8','9'}, \r\n {'*','0','#'}}; \r\n\r\nbyte rowPins[ROWS] = { \r\n 5, 4, 3, 2}; \/\/connect to the row pinouts of the keypad \r\nbyte colPins[COLS] = { \r\n 8, 7, 6}; \/\/connect to the column pinouts of the keypad \r\n\r\nKeypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );\r\n\r\nchar PIN[6]={'1','2','3','4','5','6'}; \/\/ su numero secreto (!) \r\nchar attempt[6]={0,0,0,0,0,0}; \/\/ usado para comparar int z=0; \r\nint led13= 13; int sal1 = 10; \/\/ salida1, pin A4 \r\nint sal2 = 11; \/\/ salida2, pin A5 \r\n\r\nvoid setup() \r\n{ \r\n pinMode(sal1, OUTPUT); \r\n pinMode(sal2, OUTPUT); \r\n Serial.begin(9600); \/\/Configura la velocidad del puerto serie \r\n keypad.setHoldTime(500); \/\/ Default is 1000mS \r\n keypad.setDebounceTime(250); \/\/ Default is 50mS \r\n Serial.println(\" Debe introducir la secuencia: \"); \r\n Serial.print(\" * X X X X X X # \"); \r\n Serial.println(\" >> X = del 0 al 9\"); \r\n incorrectPIN();\r\n Serial.print(\" \"); \r\n Serial.println(\" Intentelo: \"); \r\n} \r\nvoid correctPIN() \/\/ hacer esto. Si el PIN escrito es correcto \r\n{ \r\n digitalWrite(10, LOW); \/\/ desactiva un contacto pin 1 \r\n digitalWrite(11, HIGH); \/\/ activa un contacto pin 2 \r\n Serial.print(\" Correcto \"); \r\n Serial.print(attempt); \r\n} \r\nvoid incorrectPIN() \u00a0\u00a0 \/\/ hacer esto. Si el PIN escrito es incorrecto \r\n{ \r\n digitalWrite(11, LOW); \/\/ desactiva un contacto \r\n digitalWrite(10, HIGH); \/\/ activa un contacto \r\n Serial.print(\"Incorrecto \"); \r\n \/\/Serial.print(\" \"); \r\n} \r\nvoid led() \r\n{ \r\n if (led13 == LOW) \r\n led13= HIGH; \r\n else \r\n { \r\n  led13 = LOW; \r\n } \r\n} \r\nvoid checkPIN() \r\n{ \r\n int correct=0; \r\n for (int q=0; q<=5; q++) \r\n  { \u00a0 \r\n  if (attempt[q]==PIN[q]) \r\n   { correct++; \r\n   } \r\n  } \r\n  if (correct==6) \r\n  { correctPIN(); \r\n  } else \r\n  { incorrectPIN(); \r\n  } \r\n  for (int zz=0; zz<6; zz++) \/\/ borrar tentativa \r\n   { attempt[zz]=0; \r\n   } \r\n } \r\nvoid readKeypad() \r\n{ \r\n char key = keypad.getKey(); \r\n if (key != NO_KEY) \r\n { \r\n  switch(key) \r\n { \r\n  case '*': z=0; \r\n  Serial.println(\" \"); \r\n  break; \r\n  case '#': delay(50); \r\n  Serial.println(\" \"); \r\n  checkPIN(); \r\n  break; \r\n  default: attempt[z]=key; z++; \r\n } \r\n  Serial.print(\"*\"); \r\n  led(); \r\n  } \r\n} \r\nvoid loop() \r\n{ \r\n readKeypad(); \r\n}<\/pre>\n
Este c\u00f3digo, es susceptible de ser modificado y mejorado, sin duda. Por ese motivo, vamos a seguir en nuestro empe\u00f1o en descubrir nuevos modos de lograr ese resultado e incluso mejorarlo. A continuaci\u00f3n, veremos otra forma de enfocar el proyecto para lograr el mismo resultado.<\/p>\n
Ejemplo PIN con LCD.<\/span><\/h2>\n
Esto esta listo, sin embargo, si le a\u00f1adimos un LCD, tendremos un proyecto mucho m\u00e1s profesional que, podremos incluir en un proyecto que requiera de un sistema de seguridad que, incluya una clave de 6 o m\u00e1s d\u00edgitos. Veamos los pasos a seguir, para comprender c\u00f3mo lograrlo.<\/p>\n
EL CIRCUITO.<\/span><\/h2>\n
En primer lugar, presento el esquema electr\u00f3nico es muy sencillo, a pesar de los cables que necesita utilizar para el conexionado de los distintos componentes. Se adjunta el archivo Fritzing<\/a>, aunque lleva peque\u00f1as modificaciones (el teclado y el PCF8574 son de mi creaci\u00f3n).<\/p>\n
\"\"<\/a>Como previsiblemente se van a necesitar muchos puertos del Arduino, he pensado en aplicar un expansor de puertos, para actualizar y refrescar conocimientos, se puede leer el expansor de puerto<\/a>. Aqu\u00ed, lo utilizamos para interconectar el teclado, porque necesita 7 entradas\/salidas, de igual modo, se podr\u00eda haber utilizado para el LCD. En este ejemplo, se ha dotado de un display LCD de 20×4 como se aprecia en el circuito anterior.<\/p>\n
El c\u00f3digo.<\/span><\/h2>\n
El siguiente es el c\u00f3digo del segundo ejemplo, en este listado, he introducido unos cambios que permitir\u00e1n una mayor flexibilidad, en el especto de margen de clave a utilizar, gracias a usar la librer\u00eda Password<\/a> que, nos facilita esta labor a la hora de crear y comparar una matriz de n<\/strong><\/em> d\u00edgitos.<\/p>\n
La idea es la misma descrita en el ejemplo anterior. La inclusi\u00f3n de un LCD, para su control, hace necesario el uso de la librer\u00eda LiquidCrystal<\/a>, por supuesto, tambi\u00e9n hace falta usar las librer\u00edas incluidas en el ejemplo anterior que, no es necesario repetir.<\/p>\n
Un punto a resaltar es que debido a que necesitamos m\u00e1s puertos del Arduino, en este caso, vamos a utilizar las entradas anal\u00f3gicas como entradas digitales, esto es posible si los declaramos con el numeral que le corresponde, es decir, en Arduino, los pines digitales normalmente, van del pin0 al pin13. Seg\u00fan el playground de Arduino:<\/p>\n
Mapeo de Pins. \r\n\r\n\u00b7Los pines de Arduino correspondientes a los pines anal\u00f3gicos son desde el 14 al 19. \r\n\u00b7Observa que esto son pines de Arduino y no corresponden con los n\u00fameros \r\n de los pines f\u00edsicos del chip Atmega. Los pines anal\u00f3gicos, pueden usarse \r\n de manera id\u00e9ntica que los digitales, as\u00ed que por ejemplo, podr\u00edas ver un \r\n c\u00f3digo como este para configurar un pin anal\u00f3gico, y establecerlo a HIGH: \r\n\r\n  pinMode(14, OUTPUT); \r\n  digitalWrite(14, HIGH);<\/pre>\n
Aqu\u00ed, usaremos los siguientes, del pinA0 por pin14 a pinA3 por pin17, procurando no utilizar los pines anal\u00f3gicos pinA4 y pinA5, por si se emplean en alg\u00fan momento como E\/S I2C.<\/p>\n
 byte rowPins[ROWS] = {5, 4, 3, 2}; \/\/ pines a conectar los row del teclado. \r\n byte colPins[COLS] = {16, 15, 14}; \/\/ AN0, AN1 y AN2. Por falta de pines \r\n const int buttonPin = 6; \/\/ para los rel\u00e9s mediante una R de 10k y un transistor NPN \r\n int sal1 = 17; \/\/ pin A4 salida a rele \r\n int sal2 = 18; \/\/ pin A5 salida a rele<\/pre>\n
En la subrutina: \u00abvoid keypadEvent(KeypadEvent eKey)<\/strong>\u00bb se hace atiende al teclado y compara con la clave guardada. La subrutina: \u00abvoid guessPassword()<\/strong>\u00bb es la que, mediante la ayuda de un transistor universal NPN, permite activar o desactivar un rel\u00e9 con el que, podemos manejar la potencia necesaria para abrir o cerrar el sistema de acceso, si es el caso.<\/p>\n
N\u00famero PIN largo.<\/span><\/h2>\n
\/* password_lcd.pde \r\nBasado en art\u00edculos de la red. \r\nModificado y adaptado el 07.11.2011 por V. Garcia. \r\nPara hispavila.com Utilizamos las librer\u00edas: \r\n[Password.h LiquidCrystal.h Keypad.h] que puede \r\nencontrar en:\r\nhttp:\/\/www.hispavila.com\/3ds\/atmega\/clavenum.html \r\nUsando el actual ejemplo de hardware se pueden activa \r\nalgo o desactivar mediante el teclado - emulando lo \r\nque se puede encontrar en algunos sistemas de alarma y \r\nas\u00ed\u00ad sucesivamente. Nuestro objetivo con este ejemplo \r\nes muy simple. Un sistema de espera para obtener un PIN \r\nque se especifique previamente. Si el PIN es correcto, \r\nhacer algo. Si el PIN es incorrecto, hacer otra cosa. \r\nLo que las acciones pueden llegar a hacer. Con el proyecto \r\nvamos a activar o desactivar una salida digital. \r\nEste ejemplo es para darle un concepto y un marco para \r\nadaptar o construir ideas propias. \r\nUsa 4654 bytes con el IDE v. 00013 \r\n*\/ \r\n#include <Password.h> \r\n#include <LiquidCrystal.h> \r\n#include <Keypad.h> \r\nLiquidCrystal lcd(7, 8, 9, 10, 11, 12); Password \r\npassword = Password( \"1234456\" ); \/\/ aqu\u00ed puede poner su pasword \r\nconst byte ROWS = 4; \/\/ Cuatro rows \r\nconst byte COLS = 3; \/\/ Tres columns \r\n\/\/ Define el Keymap \r\nchar keys[ROWS][COLS] = { \r\n {'1','2','3',}, \r\n {'4','5','6',}, \r\n {'7','8','9',}, \r\n {'*','0',' ',} }; \r\n\/\/ Conectar keypad ROW0, ROW1, ROW2 y ROW3 a los pines de Arduino. \r\nbyte rowPins[ROWS] = {5, 4, 3, 2}; \/\/ pines a conectar los row del teclado. \r\nbyte colPins[COLS] = {16, 15, 14}; \/\/ AN0, AN1 y AN2. Por falta de pines \r\nconst int buttonPin = 6; \/\/   \r\nint buttonState = 0; \r\nint i; \r\nint sal1 = 17; \/\/ pin A4 salida a rele \r\nint sal2 = 18; \/\/ pin A5 salida a rele \r\n\r\n\/\/ Crear el Keypad \r\nKeypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS ); \r\n#define ledPin 13 \r\n\r\nvoid setup()\r\n{ \r\n pinMode(buttonPin, INPUT); \r\n pinMode(sal1, OUTPUT); \r\n pinMode(sal2, OUTPUT); \r\n pinMode(ledPin, OUTPUT); \r\n lcd.begin(20, 4); \r\n digitalWrite(ledPin, LOW); \u00a0 \/\/ pone el LED off \r\n\r\n Serial.begin(9600); \r\n keypad.addEventListener(keypadEvent); \/\/a\u00f1ad. un evento listener para el keypad \r\n keypad.setDebounceTime(250); \r\n lcd.clear(); \u00a0 \u00a0 \/\/Borra el LCD \r\n lcd.setCursor(0,0); \r\n lcd.print(\"Entre secuencia PIN:\"); \r\n lcd.setCursor(2,2); \r\n lcd.print(\"* Para terminar\"); \r\n lcd.setCursor(0,3); \u00a0\r\n lcd.print(\" Intentelo: \"); \r\n} \r\nvoid loop()\r\n{ \r\n keypad.getKey(); \r\n buttonState = digitalRead(buttonPin); \r\n if (buttonState == HIGH) \r\n { \r\n  lcd.clear(); \r\n } \r\n} \r\n\/\/ atender algunos eventos especiales \r\nvoid keypadEvent(KeypadEvent eKey)\r\n{ \r\n switch (keypad.getState())\r\n { case \r\n PRESSED: lcd.print(eKey); \r\n switch (eKey)\r\n  { \r\n   case ' ': guessPassword(); \r\n   break; \r\n   default: password.append(eKey); \r\n  } \r\n } \r\n} \r\nvoid guessPassword()\r\n{ \r\n if (password.evaluate())\r\n { \r\n  digitalWrite(ledPin,HIGH); \/\/ activa el LED de la puerta .5 seg. delay(500); \r\n  digitalWrite(ledPin,LOW); \/\/ desactiva LED de la puerta \r\n  digitalWrite(sal1, HIGH); \/\/ activa rel\u00e91 de la puerta \r\n  digitalWrite(sal2, LOW); \u00a0\/\/ desactiva rel\u00e92 de la puerta \r\n  lcd.clear(); \r\n  lcd.setCursor(0,0); \r\n  lcd.print(\"PASSWORD VALIDO \"); \/\/ \r\n  password.reset(); \/\/resetea password despues de entrada correcta\r\n  delay(1000); \r\n  lcd.setCursor(0,0); \r\n  lcd.print(\"Bienvenido, Sr.\"); \r\n  delay(1000); \r\n  for (int positionCounter = 0; positionCounter < 22; positionCounter++) \r\n   { \r\n   \/\/ scroll one position right: \r\n    lcd.scrollDisplayRight(); \/\/ espera un poco \r\n    delay(150); \r\n   } \r\n   delay(35000); \/\/ espera 35 segundos antes de volver a\u00f1 inicio \r\n   setup(); \/\/ al inicio \r\n   } else\r\n   { \r\n    i = i++; \r\n    digitalWrite(ledPin,LOW); \r\n    digitalWrite(sal1, LOW); \r\n    digitalWrite(sal2, HIGH); \r\n    lcd.clear(); \r\n    lcd.print(\"PASSWORD INVALIDO \"); \r\n    password.reset(); \/\/resets password after INCORRECT entry \r\n    delay(2000); \/\/ tiempo de retardo \r\n    lcd.clear(); \r\n    lcd.setCursor(0,2); \r\n    lcd.print(\" Intentelo: \"); \r\n   } \r\n   if (i==3) \r\n   { \r\n    lcd.setCursor(0,1); \r\n    lcd.print(\"Lo siento... \"); \r\n    lcd.setCursor(0,2); \r\n    lcd.print(\"Intentelo mas tarde\"); \r\n    delay(30000); \r\n    lcd.clear(); \r\n    lcd.setCursor(0,2); \r\n    lcd.print(\" Intentelo: \"); \r\n    i=0; \r\n   } \r\n }<\/pre>\n
A estas subrutinas, se les ha incluido unos mensajes que, est\u00e1n acordes en cada caso, para hacer comprender al usuario, la situaci\u00f3n que impera en cada momento. De modo que al iniciar el proceso, rige un mensaje que invita a introducir un n\u00famero PIN y la forma de hacer su entrada mediante la pulsaci\u00f3n de la tecla \u00ab*<\/strong>\u00bb (asterisco), como confirmaci\u00f3n del PIN introducido.<\/p>\n
Mediante la librer\u00eda Pasword<\/strong>, se eval\u00faa el PIN introducido y se produce un destello de un LED por un corto per\u00edodo de tiempo 1\/2 segundo cuando hay coincidencia con la clave correcta. En ese momento, el mensaje que muestra la pantalla LCD, cambia a un nuevo mensaje que, le indica al usuario que ha obtenido el acceso y termina el proceso.<\/p>\n
Un tiempo despu\u00e9s (este intervalo de tiempo se puede ajustar a su gusto, antes de compilar), se vuelve a inicia todo el proceso, a la espera de un nuevo intento por un nuevo usuario.<\/p>\n
Este ejemplo es un proyecto \u00abcompleto\u00bb, ya que como elementos externos, s\u00f3lo necesita de dos resistencias de 10k, dos transistores universales NPN y dos diodos 1N4007 y dos rel\u00e9s de 12V con doble contacto o similar, para poder activar cargas de mayor consumo. Para terminar el presente tutorial, se muestra un archivo AVI<\/a> que ilustra el proyecto.<\/p>\n