Buuh!!! ¿Ya ha llegado el momento de leernos? Hoy he traído una cosa sencilla pero para la que deberemos conocer qué es eso de las matrices. Se trata de un teclado para Arduino de manera que puedas utilizarlo en maquinaria para marcar algún código o para abrir una puerta con un código secreto. O una caja fuerte…

De hecho podría utilizarse hasta para marcar un número de teléfono, pero veamos de qué va esto de matricial… Porque estos aparatos se llaman teclados matriciales…

Matriciales… ¿Por qué?

Los teclados matriciales son los mismos que utilizas en tu ordenador. Pulsas una tecla y la tecla es detectada fácilmente. Para que sea detectada podría conectarse una a una cada tecla, pero esto es demasiado costoso así que lo que se hace es conectar todas las filas y columnas.

Es por esto que se llama matricial, porque se utilizan como una matriz en la que conociendo al fila y la columna podemos saber exactamente la tecla que se ha presionado. Imagina unas 16 teclas: 4 filas de 4. Si pulsas la tecla de la fila 2 y la columna 2, se puede deducir que has presionado la sexta tecla ya que una fila son 4 teclas y al sumar dos más son 6.

Esta técnica ahorra mucho cableado y es muy útil. Lo único es que está pensado para pulsar una tecla cada vez, es por eso que en los teclados, las teclas especiales como Ctrl o Mayus utilizan otro circuito ya que no se utilizan solas.

Cómo funcionan los teclados

En el mercado ya venden muchos de estos teclados a precios bastante bajos.

[ Aquí va una imagen de los teclados, pero como no encuentro ninguna libre de derechos, te va a tocar buscarla por la red 😉 ]

Los cables que tendremos serán uno por fila y uno por columna. Esto son 8 cables en lugar de 16 si fuese uno por tecla. Si en lugar de una matriz 4×4 fuese de 1×16 tendríamos una fila y 16 columnas. Es decir, necesitaríamos 17 cables para 16 teclas. La verdad es que no sería muy inteligente hacer esto pero ya ves que esto de las matrices puede ser muy ventajoso o incluso peor que hilar cada una de las teclas por separado.

Pero, ¿Qué son las teclas? Las teclas son pulsadores. Como los que hemos utilizado millones de veces pero puestos en un soporte bonito y coloreado. Como todo pulsador debemos conectar una parte a GND, otra a 5V y poner una resistencia en alguno de los lados para que la corriente no sea demasiado elevada y hagamos un cortocircuito. Al pulsar el botón, la corriente podrá pasar a través de la resistencia.

Para conectar esto a nuestro Arduino lo que deberemos hacer es revisar en las especificaciones si nuestro teclado incluye resistencias internas. De manera que estaría 5V, una resistencia y luego el pulsador. Si no es así utilizaremos las resistencias pull-up que vienen dentro de Arduino.

De esta manera, de lo que hay que preocuparse a nivel físico es de conectar los 4 cables de las filas a pines digitales que pondremos como salidas y los 4 cables de las columnas a pines digitales que pondremos como entradas con resistencia pull-up.

      He leído y acepto la política de privacidad

 

Información básica sobre Proteción de datos

Responsable ➥ Sergio Luján Cuenca
Finalidad ➥ Gestionar el envío de correos electrónicos con artículos, noticias y publicidad. Todo relacionado con los temas de rufianenlared.com
Legitimación ➥ Consentimiento del interesado
Destinatarios ➥ Estos datos se comunicarán a MailRelay para gestionar el envío de los correos electrónicos
Derechos ➥ Acceder, rectificar y suprimir los datos, así como otros derechos, como se explica en la política de privacidad
Plazo de conservación de los datos ➥ Hasta que se solicite la supresión por parte del interesado
Información adicional ➥ Puedes encontrarla en la política de privacidad y el aviso legal

Cómo programarlos

Una vez con los cables conectados, hay que configurar los pines digitales de las filas como salidas (12, 11, 10, 9):

  pinMode(12, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(9, OUTPUT);

Y los pines digitales de las columnas como entradas (8, 7, 6, 5):

  pinMode(8, INPUT);
  pinMode(7, INPUT);
  pinMode(6, INPUT);
  pinMode(5, INPUT);

También podrías sustituir este código por el código de Arduino para la resistencia de pull-up activa (Si fuese necesario por falta de resistencias en los pulsadores):

  pinMode(8, INPUT_PULLUP);
  pinMode(7, INPUT_PULLUP);
  pinMode(6, INPUT_PULLUP);
  pinMode(5, INPUT_PULLUP);

Con esto ya hay que empezar a leer. Primero se pone la primera fila en HIGH. Y se lee cada una de las columnas. Si la columna lee un HIGH, significa que el botón está pulsado ya que sino no se habría cerrado el circuito. Si solo lee LOW en todas las columnas es que ningún botón de esa fila está pulsado. Luego se pone esta fila a LOW y se pone a HIGH la fila 2. Y se repite el proceso en bucle.

Aunque parece lento, Arduino hace esas lecturas en menos de un segundo y nosotros, cuando pulsamos, seremos más lentos que el propio Arduino. De hecho, si te acuerdas de los pulsadores recordarás que tenían unos rebotes que hacían que pulsaras una tecla y la leyeses veinte veces. Para evitar esto poníamos unas esperas, que siguen siendo necesarias en este caso:

int fila = 0;
int columna = 0;

void setup() {
  pinMode(12, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(9, OUTPUT);

  pinMode(8, INPUT);
  pinMode(7, INPUT);
  pinMode(6, INPUT);
  pinMode(5, INPUT); 
}

void loop() {
  digitalWrite(12, HIGH);
  if(digitalRead(8)){
    fila = 1;
    columna = 1;
  }
  if(digitalRead(7)){
    fila = 1;
    columna = 2;
  }
  if(digitalRead(6)){
    fila = 1;
    columna = 3;
  }
  if(digitalRead(5)){
    fila = 1;
    columna = 4;
  }

    digitalWrite(11, HIGH);
  if(digitalRead(8)){
    fila = 2;
    columna = 1;
  }
  if(digitalRead(7)){
    fila = 2;
    columna = 2;
  }
  if(digitalRead(6)){
    fila = 2;
    columna = 3;
  }
  if(digitalRead(5)){
    fila = 2;
    columna = 4;
  }

    digitalWrite(10, HIGH);
  if(digitalRead(8)){
    fila = 3;
    columna = 1;
  }
  if(digitalRead(7)){
    fila = 3;
    columna = 2;
  }
  if(digitalRead(6)){
    fila = 3;
    columna = 3;
  }
  if(digitalRead(5)){
    fila = 3;
    columna = 4;
  }

    digitalWrite(10, HIGH);
  if(digitalRead(8)){
    fila = 4;
    columna = 1;
  }
  if(digitalRead(7)){
    fila = 4;
    columna = 2;
  }
  if(digitalRead(6)){
    fila = 4;
    columna = 3;
  }
  if(digitalRead(5)){
    fila = 4;
    columna = 4;
  }

  delay(500);
}

Este monstruo de ahí arriba se puede hacer mucho más rápido mediante bucles. El Señor Luis Llamas ya lo hace en su blog, así que te dejo un enlace para que veas cómo. Por otra parte, si utilizas resistencias pull-up, en lugar de leer un HIGH, deberás de leer un LOW, que sería equivalente a:

  if(!digitalRead(5)){
    fila = 4;
    columna = 4;
  }

KeyPad, la librería de Arduino que lo hace todo

Si esto de ahí arriba te ah parecido una fumada de las buenas, a alguien también se lo pareció antes, y decidió crear una librería en Arduino llamada Keypad. Solamente necesitas instalarla desde la web o desde el gestor de librerías de Arduino y utilizarlo como hacíamos con los motores paso a paso, generando un objeto Keypad:

const byte filas = 4;
const byte columnas = 4;
char teclas[filas][columnas] = {
  {'1','2','3','R'},
  {'4','5','6','U'},
  {'7','8','9','F'},
  {'#','0','*','I'}
};

byte filas_ardu[filas] = {12, 11, 10, 9};
byte columnas_ardu[columnas] = {8, 7, 6, 5, 4};
Keypad teclado = Keypad( makeKeymap(teclas), filas_ardu, columnas_ardu, filas, columnas );

Eso sí, no olvides llamar a la librería al inicio del programa:

#include <Keypad.h> 

La segunda estrella a la derecha, todo recto, hasta el amanecer

Así que ya puedes utilizar estos teclados en tus proyectos, que pueden proteger tus proyectos de ser utilizados sin tu permiso o para marcar el tipo de acción que deben de hacer. Todo es posible, incluso lo imposible…

¡Hasta luego OHANA!