Registro de Entrada por Número PIN.
Con teclado matricial 4×4 con LCD.
PROLOGO.
En otro artículo sobre teclados ya vimos un ejemplo de cómo crear un acceso mediante un PIN a una estancia, en aquella ocasión utilizábamos un teclado de 3×4 y un LCD numérico de 20×4, ambos muy conocidos. se servían de unas librerías que actualmente se han mejorado. En esta ocasión vamos a utilizar el mismo ejemplo y las herramientas o mejor dicho los dispositivos los hemos actualizado para que el interesado pueda extraer mejores resultados y utilice los nuevos dispositivos y librerías.
El display empleado es el mismo un LCD de 4 lineas y 20 dígitos, en esta ocasión con la ayuda de un adaptador serial comercial y por otra parte un teclado de 4×4 por adaptarse bien al proyecto y ser muy económico ambos los vemos a continuación.
Fig. 1
El convertidor o mochila serie lo aplicaremos al display para reducir los puertos o pines del Arduino, además se muestra un PCB de un adaptador mediante un PCF8574A para el teclado matricial, que puede realizar con el pdf adjunto.
Fig. 2 PCB del convertidor de 8Bits.
También puede adquirir un convertidor comercial como el mostrado en la siguiente figura.
Fig. 3 Convertidor de 8Bits comercial.
En cualquiera de los dos casos, no olvide declarar la dirección del conversor, usted puede elegir entre las posibles.
Fig. 4 Tabla de direcciones.
Por otra parte hemos dispuestos las nuevas librerías necesarias para el actualizado código para manejar la entrada del PIN mediante el teclado matricial. El primer cambio esta en la declaración del teclado:
// (Adds,En,Rw,Rs,D4,D5,D6,D7)
LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3,POSITIVE);
El segundo cambio esta en la declaración del passwor, como ya se vio en el anterior artículo tenemos que crear una clave, el código que introduzca el usuario:
Password password = Password("123A4566"); // entre su passwor
El siguiente cambio esta en la declaración del mapeado del teclado:
#include "Keypad.h" const byte ROWS = 4; //four rows const byte COLS = 4; //four columns char keys[ROWS][COLS] = { {'1','2','3','A'}, {'4','5','6','B'}, {'7','8','9','C'}, {'*','0','#','D'} };
Donde hacemos constar que son 4 filas y 4 columnas, en la declaración del mapa del teclado añadimos las teclas de la cuarta columna A, B, C y D. También declaramos los pines del mapa del teclado.
// vigile el orden de los pines. byte rowPins[ROWS] = {9, 8, 7, 6}; // pines digitales - filas byte colPins[COLS] = {5, 4, 3, 2}; // pines digitales - columnas
Debemos declarar el segundo I2C que utilizaremos para el teclado.
int i2caddress = 0x38; // por ej.
Ahora es el momento de ‘crear’ el teclado propiamente dicho, es decir, con una sentencia, el programa generará una matriz que verá como un teclado, al que se remitirá, cuando tenga que representar un dígito. Esto se consigue con la siguiente línea:
// Secuencia para crear la matriz del teclado (Keypad)
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
En el caso de disponer de un convertidor I2C que contiene al chip PCF8574, lo podemos utilizar para el teclado con la siguiente línea:
Keypad_I2C kpd = Keypad_I2C( makeKeymap(keys), rowPins, colPins, ROWS, COLS, i2caddress );
El resto del código lo hemos mejorado sólo un poco. En el setup() se incluye la sentencia lcd.setBacklight(HIGH); // para activar el backlight para lo que se indica en ella. El resto de del código es bastante explicito por lo que sólo se comentará algo cuando se crea de interés. Por ejemplo, en el loop(), se han añadido las siguientes líneas:
if (buttonState == LOW) {
Serial.println("Ha pulsado el boton ....");
for(int z=0; z<6; z++){
lcd.setCursor(1,3);
lcd.print("ALARMA ACTIVADA!");
delay(1000);
lcd.setCursor(1,3);
lcd.print(" ");
delay(500);
} setup(); //incorrectPIN();
Para presentar el estado de alarma en el caso de pulsar el botón dispuesto para tal fin. Ahora veamos el código completo en el que hemos dispuesto un sólo adaptador para el display.
// clave_pin_I2C.ino - keypad switch con ocho digitos para el PIN
//
//
// clave_pin_lcd.pde - keypad switch con ocho digitos para el PIN
// basado en el chapter 42 de
// http://tronixstuff.wordpress.com/tutorials
//
/*
El circuito:
* LCD 20x4 basado en el HD44780
* 2 botones a los pines 6 y 7. Marcha/Paro y Puesta a Cero.
* LED en pin 13 (opcional para indicar la pulsacion de los botones)
PINES PINES
LCD Arduino
4 7
5 GND
6 8
11 9
12 10
13 11
14 12
Definicion de funciones de control LCD
printtime(); Escribe el tiempo
clearLCD(); Borrar el LCD
lcd.setCursor(0,0); columna -y- fila
lcd.setCursor(0,0); Escribir en la columna 1, 1a linea
lcd.setCursor(0,1); Escribir en la columna 1, 2a linea
lcd.setCursor(2,2); Escribir en la columna 3, 3a linea
lcd.setCursor(0,3); Escribir en la columna 1, 3a linea
Usando hardware descrito, se pueden activa o desactivar algo mediante el
teclado - reproduciendo lo que se puede encontrar en algunos sistemas de
alarma y asi aplicar las sugerencias que se nos ocurran. El objetivo con
este ejemplo es, simular - los sistemas de acceso para obtener un PIN
previamente especifico. Si el PIN es correcto, hacer algo. Si el PIN no es
correcto, hacer otra cosa. Las acciones que se puedan ocurrir, pero para
el ejemplo vamos a activar o desactivar una salida digital. Este ejemplo es
para aprender un concepto y un marco, para desarrollar ideas propias.
Se utiliza una clave con seis dígitos para el PIN.
El signo '#' del teclado, se emplea como la función ENTER.
09.11.2011 funciona bien. Usando IDE v.0013/0023 con 4506 bytes
adaptado por V. García. para hispavila.com
*/
#include "Password.h" // lib. Password
//#include "LiquidCrystal.h" // necesitamos esta lib. LiquidCrystal.h para los comandos de LCD
#include "LiquidCrystal_I2C.h" // lib. LiquidCrystal_I2C.h para mochila I2C
#include "Keypad_I2C.h" // lib. Keypad_I2C.h para módulo conversor
#include "Keypad.h" // libreria Keypad.h para teclado
// inicializa la libreria con los numeros de interface de los pines
// lcd (RS,RW, E, D4,D5, D6, D7)
// LiquidCrystal lcd(7, 8, 9, 10, 11, 12); // **** si no usa I2C
// El valor 0x27, debe adecuarse al elegido en los pines A0, A1 y A2
// del adaptador serie, este valor 0x27 corresponde a estos 3 pines a HIGH
// LiquidCrystal_I2C lcd(0x27); // o 39. Set the LCD I2C address
// set the LCD address to "0x27"(or "0x3f") for a 16 chars and 2 line display
// set the LCD address to "0x3f"(or "0x27") for a 16 chars and 2 line display
// En la versión LiquidCrystal_I2C de 2019, se debe usar como sigue:
// (Adds,En,Rw,Rs,D4,D5,D6,D7)
LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3,POSITIVE);
Password password = Password("123A4566"); // entre su password
const byte ROWS = 4; // Cuatro filas
const byte COLS = 4; // Tres columns, cambio añado A B C D
// Define el Keymap
char keys[ROWS][COLS] = {
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0',' ','D'}};
// vigile el orden de los pines.
byte rowPins[ROWS] = {11, 10, 9, 8}; // pines digitales - filas
byte colPins[COLS] = {5, 4, 3, 2}; // pines analógicos - column (AN2, AN1 y AN0)
const int buttonPin = 6; // pin 2 para un pulsador.
int buttonState = 0;
// Secuencia para crear el teclado (Keypad)
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
int ledPin = 13; // para uso indistinto.
int sal1 = 12; // pin 10 digital. Rele de potencia
//int sal2 = 12; // pin 11 digital. Rele de potencia
void setup(){
// lcd.setBacklightPin(3,POSITIVE); // ya declarado
lcd.setBacklight(HIGH); // para activar el backlight
pinMode(buttonPin, INPUT);
digitalWrite(buttonPin, HIGH);
digitalWrite(ledPin, LOW); // pone el LED en off
digitalWrite(sal1, LOW);
buttonState = digitalRead(buttonPin); // lee el estado inicial
pinMode(ledPin, OUTPUT);
pinMode(sal1, OUTPUT);
// pinMode(sal2, OUTPUT);
Serial.begin(9600);
lcd.begin(20, 4);
keypad.addEventListener(keypadEvent); //add an event listener for this keypa
keypad.setDebounceTime(250); // retardo anti-rebote
Serial.println("clave_pin_i2c.ino Listo \n");
lcd.clear(); //Borra el LCD
delay(500);
lcd.setCursor(1,0);
lcd.print("clave_pin_I2C.ino");
delay(2500);
lcd.clear(); //Borra el LCD
delay(500);
lcd.setCursor(0,0);
lcd.print("Entre secuencia PIN:");
lcd.setCursor(0,1);
lcd.print(" 8 digitos + # "); // X X X X X X + #
lcd.setCursor(0,2);
lcd.print("Intentelo: ");
// las 2 lineas que siguen aseguran los contactos de puertas
digitalWrite(sal1, LOW); // desactiva un contacto
// digitalWrite(sal2, HIGH); // activa un contacto
}
void loop(){
keypad.getKey();
buttonState = digitalRead(buttonPin);
if (buttonState == LOW) {
Serial.println("Ha pulsado el boton ....");
digitalWrite(buttonPin, HIGH);
lcd.clear();
for(int z=0; z < 6; z++){
lcd.setCursor(0,2);
lcd.print(" ");
digitalWrite(ledPin, HIGH);
delay(10);
lcd.setCursor(0,2);
lcd.print("ALARMA ACTIVADA! ");
digitalWrite(ledPin, LOW); delay(10);
delay(200);
lcd.setCursor(0,2);
lcd.print(" ");
delay(100); }
paraAlarma();
// setup(); //incorrectPIN();
}
}
void paraAlarma(){ // digitalWrite(buttonPin, LOW);
lcd.setCursor(0,2);
lcd.print(" ");
lcd.setCursor(0,2);
lcd.print("Pulsa parar Alarma");
keypad.getKey();
buttonState = digitalRead(buttonPin);
if (buttonState == HIGH) { // delay(2000);
Serial.println("PIT-PIT");
return;
} //
}
void correctPIN() // hacer esto. Si el PIN escrito es correcto
{
digitalWrite(sal1, HIGH); // activa un contacto pin 12
// digitalWrite(sal2, HIGH); // activa el contacto del pin 2
lcd.clear();
lcd.setCursor(2,1); // set cursor to column 2, row 0 (the first row)
lcd.print("PASSWORD VALIDO!"); Serial.println("PASSWORD VALIDO"); //
password.reset(); //resetea password después de entrada correcta
delay(1000);
lcd.setCursor(2,1);
lcd.print(" ");
for (int z=0; z>3; z++)
{
for (int positionCounter = 0; positionCounter < 21; positionCounter++) //desplaza text
{
lcd.setCursor(1,0);
lcd.print("Bienvenido...");
lcd.setCursor(2,1);
lcd.print(" "); //
// scroll una posición a derecha:
lcd.scrollDisplayRight();
// esperar un poco.
delay(120);
}
}
delay(5000);
setup();
}
void incorrectPIN() // hacer esto. Si el PIN escrito es incorrecto
{
digitalWrite(sal1, LOW); // desactiva un contacto
// digitalWrite(sal2, HIGH); // activa un contacto
lcd.clear();
lcd.setCursor(0,0);
lcd.print("PASSWORD INVALIDO "); Serial.println("PASSWORD INVALIDO");
delay(1500);
lcd.clear();
password.reset(); //resetea password después de entrada INCORRECTA
delay(100);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Entre secuencia PIN:");
lcd.setCursor(0,2);
lcd.print("Reintentar:");
}
// atender algunos eventos especiales
void keypadEvent(KeypadEvent eKey){
parpadea(); // parpadea
switch (keypad.getState()){
case PRESSED:
lcd.print(eKey); Serial.print(eKey); switch (eKey){
case ' ': guessPassword(); break;
default:
password.append(eKey);
}
}
}
void parpadea(){
digitalWrite(ledPin, HIGH); delay(10);
digitalWrite(ledPin, LOW);
}
void guessPassword(){
if (password.evaluate()){
digitalWrite(ledPin,HIGH); //activa rele de la puerta
delay(800);
digitalWrite(ledPin,LOW); //desactiva rele de la puerta .5 sec
correctPIN();
}
else{
digitalWrite(ledPin,LOW);
delay(500);
digitalWrite(ledPin,HIGH); //desactiva rele de la puerta .5 sec
incorrectPIN();
}
}
Como de costumbre seleccione el código y guárdelo con un nombre apropiado, compílelo y súbalo al Arduino, para comprobar su efectividad. Es muy recomendable actualizar las librerías a la última versión para conseguir que todo vaya bien, si no se menciona lo contrario.
En el vídeo siguiente se puede apreciar que aún conservo el Arduino de cuando empecé (buena señal) y la efectividad del programa.
Vídeo
Si tiene alguna duda haga su pregunta, intentaré responder.
