¿QUÉ ES UN anavar vs winstrol TECLADO MATRICIAL?

Un teclado matricial es un dispositivo que agrupa varios pulsadores y permite controlarlos empleando un número de conductores inferior al que necesitaríamos al usarlos de forma individual. Podemos emplear estos teclados como un controlador para un autómata o un procesador como Arduino.

Estos dispositivos agrupan los pulsadores en filas y columnas formando una matriz, disposición que da lugar a su nombre. Es frecuente una disposición rectangular pura de NxM columnas, aunque otras disposiciones son igualmente posibles.

Los teclados matriciales son frecuentes en electrónica e informática. De hecho, los teclados de ordenador normales son teclados matriciales, siendo un buen ejemplo de teclado matricial con disposición no rectangular.

Una de las desventajas de usar un teclado matricial es que pueden causar problemas cuando se pulsa más de una tecla simultáneamente. Este es uno de los motivos por el que los teclados de ordenador usan una disposición no rectangular, agrupando ciertas teclas en circuitos diferentes (Ctrl, Alt, Shift…)

¿CÓMO FUNCIONA UN TECLADO MATRICIAL?

Como hemos dicho, un teclado matricial agrupa los pulsadores en filas y columnas formando una matriz, lo que permite emplear un número menor de conductores para determinar las pulsación de las teclas.

La siguiente imagen muestra, a modo de ejemplo, una disposición rectangular de 4×4, aunque el funcionamiento es análogo en otras disposiciones. Al detectar la pulsación en la columna X y la fila Y, sabremos que se ha pulsado la tecla (X,Y).

El mecanismo de lectura es bastante ingenioso, ponemos a tierra un extremo del pulsador, y el otro lo conectamos a una entrada digital con una resistencia de pull-up.

Para leer todas las teclas tendremos que hacer un barrido por filas. En primer lugar ponemos todas las filas a 5V, y definimos todas las columnas como entradas con resistencia de pull-up.

Progresivamente ponemos una fila a 0V, y leemos las entradas de la columna. Una vez realizada la lectura volvemos a ponerla a 5V, pasamos a la siguiente fila, y volvemos a realizar el progreso hasta recorrer todas las filas.

Para detectar NxM pulsadores necesitamos sólo N+M conductores. Por tanto ahorro de conductores es superior cuanto más grandes sean N y M, y más parecidos entre sí. (ej: 16 pulsadores en 2×8 necesitan 10 conductores, y en 4×4 sólo 8 conductores.)

En consecuencia, los teclados de 1xM, Nx1 y 2×2 no suponen ningún ahorro en conductores aunque, independientemente, puede que os resulten de utilidad únicamente por agrupar en un mismo dispositivo la disposición que deseáis.

Como hemos comentado, la mayor desventaja de la disposición matricial es que pueden dar problemas al detectar la pulsación de múltiples teclas de forma simultánea.

ESQUEMA DE CONEXIÓN

El esquema de conexión es sencillo. Simplemente conectamos todos los pines a entradas digitales de Arduino. Por ejemplo, en el ejemplo de un teclado de 4×4 el esquema quedaría de la siguiente forma.

Que visto desde Arduino quedaría de la siguiente forma.

EJEMPLOS DE CÓDIGO

SIN LIBRERÍA

En el primer ejemplo, realizaremos la lectura sin emplear ninguna librería. Para ello, realizamos un bucle poniendo a LOW secuencialmente las distintas filas, y realizando la lectura por columnas. Si detectamos la pulsación de una tecla el valor se muestra por el puerto serie.

const unsigned long period = 50;
unsigned long prevMillis = 0;
 
byte iRow = 0, iCol = 0;
const byte countRows = 4;
const byte countColumns = 3;
 
const byte rowsPins[countRows] = { 11, 10, 9, 8 };
const byte columnsPins[countColumns] = { 7, 6, 5 };
 
char keys[countRows][countColumns] = {
  { '7','8','9' },
  { '4','5','6' },
  { '1','2','3' },
  { '0','A','B' }
};
 
// Leer el estado del teclado
bool readKeypad()
{
  bool rst = false;
 
  // Barrido de columnas
  for (byte c = 0; c < countColumns; c++) {
      // Poner columna a LOW
      pinMode(columnsPins[c],OUTPUT);
      digitalWrite(columnsPins[c], LOW);
    
      // Barrer todas las filas comprobando pulsaciones
      for (byte r = 0; r < countRows; r++) {
          if (digitalRead(rowsPins[r]) == LOW)   {
              // Pulsacion detectada, guardar fila y columna
              iRow = r;
              iCol = c;
              rst = true; 
          } // ENDIF
      } // FOR2

      // Devolver la columna a alta impedancia
      digitalWrite(columnsPins[c], HIGH);
      pinMode(columnsPins[c], INPUT);
  } // FOR1
  return rst;
}
 
// Inicializacion
void setup()
{
  Serial.begin(9600);
 
  // Columnas en alta impedancia
  for (byte c = 0; c < countColumns; c++)
  {
    pinMode(columnsPins[c], INPUT);
    digitalWrite(columnsPins[c], HIGH);
  }
 
  // Filas en pullup
  for (byte r = 0; r < countRows; r++)
  {
    pinMode(rowsPins[r], INPUT_PULLUP);
  }
}
 
void loop()
{
  if (millis() - prevMillis > period)   // Espera no bloqueante
  {
    prevMillis = millis();
    if (readKeypad())   // Detección de tecla pulsada
    {
      Serial.println(keys[iRow][iCol]);   // Mostrar tecla
    }
  }

}

CON LIBRERÍA

Existen varias librerías diseñaras para facilitar la lectura de teclados matriciales en Arduino. Por ejemplo, la librería Keypad, disponible en este enlace. La librería proporciona ejemplos de código, que resulta aconsejable revisar.

#include <Keypad.h>
 
const byte rowsCount = 4;
const byte columsCount = 4;
 
char keys[rowsCount][columsCount] = {
   { '1','2','3', 'A' },
   { '4','5','6', 'B' },
   { '7','8','9', 'C' },
   { '#','0','*', 'D' }
};
 
const byte rowPins[rowsCount] = { 11, 10, 9, 8 };
const byte columnPins[columsCount] = { 7, 6, 5, 4 };
 
Keypad keypad = Keypad(makeKeymap(keys), rowPins, columnPins, rowsCount, columsCount);
 
void setup() {
   Serial.begin(9600);
}
 
void loop() {
   char key = keypad.getKey();
 
   if (key) {
      Serial.println(key);
   }
}

  Arduino, Keypad