Info

  • Intermedio.
  • Edades: 13+

Temas STEAM

  • Tecnología
  • Ingeniería
  • Matemática

Logros y habilidades:

  • Identificar el teclado matricial y su funcionamiento.
  • Reconocer las posibilidades que se tienen al trabajar con el teclado matricial.
  • Utilizar el teclado matricial como medio para ingresar información.

Recomendaciones

  • Haber realizado la guía de pantalla LCD.

Introducción

En esta guía vas a aprender  a trabajar con el teclado matricial y a ingresar información a la  tarjeta Innobot por medio del teclado.

Materiales

  • Tarjeta Innobot o Arduino UNO.
  • Protoboard.
  • Display LCD 16×2.
  • Cables jumper.
  • Potenciómetro de 10KΩ.
  • Resistencia de 220 Ω.
  • Sensor de temperatura LM35.

Desarrollo de la actividad

Programa 1: Tecla presionada.

En este programa se logrará que en la pantalla LCD aparezca el carácter de la tecla presionada en el teclado matricial.

Paso 1

Construya el siguiente circuito.

Si es con la Innobot:

Si es con Arduino UNO:

Nota: recuerde que en la tarjeta Innobot el pin 8 esta conectado al speaker, por esto no se usa.

Paso 2

Realice  el siguiente programa en CODE:

/**********************************/
/* Empresa:       Pygmalion       */
/* Fecha:         11-07-2018      */
/* Nombre:        Teclado matricial*/
/* Autor:         Felipe Arias    */
/**********************************/

#include <LiquidCrystal.h>                //incluimos la libreria para trabajar con la pantalla LCD
#include <Keypad.h>                       //incluir libreria para trabajar con teclado matricial

//inicio del codigo necesario para trabajar con la libreria Keypad

const byte filas = 4;                     //numero de filas
const byte columnas = 3;                  //numero de columnas
byte pinsFilas[filas] = {9, 7, 6, 5};     //pines donde van conectadas las filas
byte pinsColumnas[columnas] = {4, 3, 2};  //pines donde van conectadas las columnas

char teclas[filas][columnas] =            //declaramos los caracteres que van en cada posicion fila-columna
{
  {'1', '2', '3'},                        //arreglo de la matriz del teclado
  {'4', '5', '6'},
  {'7', '8', '9'},
  {'*', '0', '#'}
};

Keypad teclado = Keypad(makeKeymap(teclas), pinsFilas, pinsColumnas, filas, columnas); //creamos el objeto teclado

//fin del codigo necesario para trabajar con la libreria Keypad

char tecla;                               //variable donde almacenaremos el caracter de la tecla presionada

LiquidCrystal lcd(A0, A1, A2, A3, A4, A5);//declaramos los pines de la tarjeta a los que vamos a conectar el display en el siguiente orden:
//(RS, E, D4, D5, D6, D7)

void setup()
{
  pinMode(A0, OUTPUT);                    //definimos los pines analogicos como salidas digitales
  pinMode(A1, OUTPUT);
  pinMode(A2, OUTPUT);
  pinMode(A3, OUTPUT);
  pinMode(A4, OUTPUT);
  pinMode(A5, OUTPUT);
  lcd.begin(16, 2);                       //tamaño (#columnas, #filas) de la pantalla LDC que voy a usar
  lcd.clear();                            //limpiamos la pantalla LCD
  lcd.print("Tecla prosionada");          //imprimir el caracter almacenado en tecla
}

void loop()
{
  tecla = teclado.getKey();               //guardamos el caracter de la tecla presionada
  if (tecla != NO_KEY)                    //si tecla es diferente de "no tecla"... (si se presiona una tecla)
  {    
    lcd.setCursor(7, 1);                  //ubicamos el cursor en la (columna, fila) convenientemente
    lcd.print(tecla);                     //imprimir el caracter almacenado en tecla
    delay(500);
  }
}

Programa 2: Contraseña de acceso

Ahora es necesario realizar  un programa de acceso con clave de 4 dígitos. Si ingresa la clave correcta, se enciende el led verde, de lo contrario se enciende  el led rojo. En ambos casos mandará un mensaje por la pantalla LCD indicándolo.

Paso 1

Construya  el siguiente circuito.

Si es con Innobot:

Si es con Arduino UNO:

Paso 2

Ahora realice el siguiente programa en CODE:

/**********************************/
/* Empresa:       Pygmalion       */
/* Fecha:         16-07-2018      */
/* Nombre:        Clave de acceso */
/* Autor:         Felipe Arias    */
/**********************************/

#include <LiquidCrystal.h>                          //incluimos la libreria para trabajar con la pantalla LCD
LiquidCrystal lcd(A0, A1, A2, A3, A4, A5);          //declaramos los pines de la tarjeta a los que vamos a conectar el display en el siguiente orden:
//(RS, E, D4, D5, D6, D7)

#include <Keypad.h>;                                //incluir libreria para trabajar con teclado matricial
char contrasena[] = "1234";                         //definimos una contraseña de 4 digitos
char codigo[4];                                     //arreglo donde almacenaremos la contraseña digitada
int digito = 0;                                     //variable que nos dira en que digito vamos

const byte filas = 4;                               //numero de filas del teclado
const byte columnas = 4;                            //numero de columnas del teclado
char teclas[filas][columnas] =                      //arreglo donde declaramos los caracteres que van en cada posicion fila-columna
{
  {'1', '2', '3'},
  {'4', '5', '6'},
  {'7', '8', '9'},
  {'*', '0', '#'}
};

byte pinsFilas[filas] = {9, 7, 6, 5};               //pines donde van conectadas las filas
byte pinsColumnas[columnas] = {4, 3, 2};            //pines donde van conectadas las columnas

Keypad teclado = Keypad(makeKeymap(teclas), pinsFilas, pinsColumnas, filas, columnas); //creamos el objeto teclado

void setup()
{
  lcd.begin(16, 2);                                 //tamaño (#columnas, #filas) de la pantalla LDC que voy a usar
  pinMode(A0, OUTPUT);                              //definimos los pines analogicos como salidas digitales
  pinMode(A1, OUTPUT);
  pinMode(A2, OUTPUT);
  pinMode(A3, OUTPUT);
  pinMode(A4, OUTPUT);
  pinMode(A5, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(12, OUTPUT);
  lcd.clear();                                      //limpiamos la pantalla LCD
  lcd.setCursor(0, 0);                              //ubicamos el cursor en la (columna, fila) convenientemente
  lcd.print("Ingrese su clave");                    //imprimir mensaje
}

void loop()
{
  char tecla = teclado.getKey();                    //guardamos el caracter de la tecla presionada en la variable tecla
  if (tecla != NO_KEY)                              //si "tecla" es diferente de "no tecla"... (si se presiona una tecla)
  {
    codigo[digito] = tecla;                         //almacena en la posicion "digito" de "codigo" el caracter de la "tecla" presionada
    lcd.setCursor(digito + 5, 2);                   //se posiciona el cursor convenientemente
    lcd.print('*');                                 //se imprime "*" cada vez que se oprime una tecla
    digito = digito + 1;                              //incrementar la variable digito para almacenar los cuatro digitos presionados
    if (digito == 4)                                  //si ya se llenaron los 4 digitos de codigo...
    {
      if (codigo[0] == contrasena[0] && codigo[1] == contrasena[1] && codigo[2] == contrasena[2] && codigo[3] == contrasena[3]) //si el "codigo" digitado es igual a la "contraseña"
      {
        delay(500);                                 //esperar medio segundo
        digitalWrite(11, HIGH);                     //encender el led verde
        lcd.setCursor(0, 1);                        //ubicamos el cursor en la (columna, fila) convenientemente
        lcd.print(" Clave correcta ");              //imprimimos el letrero diciendo clave correcta
        delay(3000);                                //esperamos 3 segundos
        lcd.clear();                                //limpuamos la pantalla LCD
        digitalWrite(11, LOW);                      //apagamos el led verde
      }
      else                                          //de lo contrario (si el "codigo" es diferente a la "clave")
      {
        delay(500);                                 //esperamos medio segundo
        digitalWrite(12, HIGH);                     //encendemos el led rojo
        lcd.setCursor(0, 2);                        //ubicamos el cursor en la (columna, fila) convenientemente
        lcd.print("Clave incorrecta");              //imprimimos el letrero diciendo clave incorrecta
        delay(2000);                                //esperamos 2 segundos
        lcd.clear();                                //limpiamos la pantalla LCD
        digitalWrite(12, LOW);                      //apagamos el led rojo
      }
      digito = 0;                                   //reseteamos la variable digito
      lcd.setCursor(0, 0);                          //ubicamos el cursor en la (columna, fila) convenientemente
      lcd.print("Ingrese su clave");                //volvemos a imprimir el letrero pidiendo la clave
      delay(500);                                  //esperamos medio segundo
    }
  }
}

Conceptos Claves

Teclado matricial

Físicamente es un arreglo matricial de pulsadores, que al presionarlos permite la conducción entre su fila y columna correspondiente. De esta manera, sabiendo por que pin fila sale el dato y por que pin columna lo recibe se puede determinar que tecla se a presionado.

Codigo ASCII

Debido a que los números solo entienden números, el código ASCII se creo para darle un numero a cada letra o carácter que existe en el alfabeto latino.

Los números van desde el 0 hasta el 127 ya que tiene 8 bits de tamaño como se muestra en la siguiente tabla:

Básicamente del 48 al 57 van los caracteres de números; del 65 al 90 van los caracteres de las letras mayúsculas y del 97 al 122 los caracteres de las letras minúsculas.

Casi todos los sistemas informáticos de la actualidad utilizan el código ASCII para representar caracteres, símbolos, signos y textos.

Variable tipo char

Es un tipo de variable que almacena los diferentes caracteres que existen en el número correspondiente en el código ASCII.

Librería keypad

Para trabajar mejor con el teclado matricial, es necesario descargar e instalar la librería keypad. Esta se puede descargar desde https://playground.arduino.cc/Code/Keypad.