TECLADO HEXADECIMAL 4X4

OBJETIVOS

• Crear un programa Shell que capture y muestre todas las teclas que son pulsadas en un teclado numérico hexadecimal 4x4 hasta que se pulsa # mediante el comando gpio de la librería WiringPi 
• Crear un programa en C que capture y muestre todas las teclas que son pulsadas en un teclado numérico hexadecimal 4x4 hasta que se pulsa # mediante la librería WiringPi.

CONSTRUCCIÓN DEL CIRCUITO

Para poder realizar el programa, primero debemos atender al diseño del teclado, que cuenta con 8 líneas, 4 de ellas de entrada y 4 de salida.

Comentar que los pines 1 a 4 llevarán asociados pines GPIO de salida y los pines de 5 a 8 serán asociados a pines de entrada, siendo recomendable la utilización de resistencias para evitar dañar la placa.

Atendiendo a la imagen vemos que los pines del teclado que van del 1 a 4, están asociadas a las columnas que van de 1 a 4. Mientras que los pines asociados a los pines 5 a 8 están asociados a las filas 1 a 4, pero en orden contrario, o sea, el 5 pin está asociado a la 4 columna, el 3 a la 3,…

Se ha procedido a conectar las 8 líneas del teclado a pines programables, insertando resistencias en el caso de los pines de entrada.

El funcionamiento del algoritmo es relativamente sencillo. Cuando comienza el programa el primer pin de salida, que controla primera columna vale 1, o sea, emite corriente y los otros tres pines de salida que controlan las columnas restantes valen 0, no emiten corriente. En este momento, se comprueba el valor del primer pin de entrada, si vale 0 es que no ha sido pulsada la tecla, en caso contrario, si ha sido pulsada. A continuación se va realizando la comprobación con las siguientes filas. Una vez comprobada la primera columna, se repite el proceso con las siguientes columnas, volviendo a realizar la comprobación hasta la última, en cuyo caso, se vuelve a realizar la comprobación cíclicamente desde la primera.

PROGRAMA tecladogpio.sh

#!/bin/bash
#################################################################
##                                                             ##
## tecladogpio.sh                                              ##
##                                                             ##
## Este script captura cuando un botón es pulsado mediante     ##
## el comando gpio facilitado por la libreria wiring PI        ##
##                                                             ##
## Autor: M.Alvarez (miguelwarez@gmail.com) 2013               ##
## Más ejemplos en http://rpiplus.sourceforge.net              ##
##                                                             ##
## License GPLv3 http://www.gnu.org/licenses/gpl-3.0.html      ##
##                                                             ##
## Para ejecutar ./botongpio.sh                                ##
##                                                             ##
#################################################################
#pines de salida
OUTPUT[0]="25"
OUTPUT[1]="24"
OUTPUT[2]="23"
OUTPUT[3]="18"
#pines de entrada
INPUT[0]="7"
INPUT[1]="22"
INPUT[2]="4"
INPUT[3]="17"
#teclado
TECLA[0]="1"
TECLA[1]="2"
TECLA[2]="3"
TECLA[3]="A"
TECLA[4]="4"
TECLA[5]="5"
TECLA[6]="6"
TECLA[7]="B"
TECLA[8]="7"
TECLA[9]="8"
TECLA[10]="9"
TECLA[11]="C"
TECLA[12]="*"
TECLA[13]="0"
TECLA[14]="#"
TECLA[15]="D"
#configurar los pines como entrada conexión a tierra y salida
for I in 0 1 2 3
do
      gpio -g mode ${OUTPUT[$I]} out
      gpio -g write ${OUTPUT[$I]} 0
      gpio -g mode ${INPUT[$I]} in
      gpio -g mode ${INPUT[$I]} down

done
echo "Capturando teclas para salir pulsar #"
#bucle infinito que captura y muestra teclas hasta que se pulsa #
while ((1));
do
      for I in 0 1 2 3
      do
          #poner el pin de salida a 1 (el resto están a 0)
            gpio -g write ${OUTPUT[$I]} 1
          #comprobar pines de entrada si no valen 0 =>tecla pulsada
            for J in 0 1 2 3
            do
                  READ=`gpio -g read ${INPUT[$J]}`
                  sleep 0.01
                  if [ $READ -ne "0" ]
                  then
                        POS=`expr 4 "*" $I + $J`
                        echo "Pulsado el boton ${TECLA[$POS]}"
                        if [ "${TECLA[$POS]}" = "#" ]
                        then
                              exit
                        fi
                  fi
            done
            gpio -g write ${OUTPUT[$I]} 0
      done

done

PROGRAMA teclado.c

/****************************************************************
**                                                             **
** teclado.c                                                   **
**                                                             **
** Este programa permite controlar un teclado 4 x 4, recoge    **
** teclas hasta que se pulsa #                                 **
**                                                             **
** Autor: M.Alvarez (miguelwarez@gmail.com) 2013               **
** Más ejemplos en http://rpiplus.sourceforge.net              **
**                                                             **
** License GPLv3 http://www.gnu.org/licenses/gpl-3.0.html      **
**                                                             **
** Para compilar:                                              **
** gcc -o teclado -l wiringPi teclado.c                        **
**                                                             **
** Para ejecutar:                                              **
** sudo ./teclado                                              **
**                                                             **
****************************************************************/

#include <wiringPi.h>
#include <stdio.h>
#include <stdlib.h>
//pines asociados a las columnas de tipo output
int outputs[]={25,24,23,18};
//pines asociados a las filas de tipo input con resistencias 10 K
int inputs[]={7,22,4,17};//controlan filas
//la función pone a 0 atodas las filas a excepcion de la que
//se va a controlar
void columnaCero(int valor){
      int i;
      for(i=0;i<4;i++)
            if(i==valor)
                  digitalWrite(outputs[i],1);
            else
                  digitalWrite(outputs[i],0);
}
//vector que contendrá el teclado
int teclado[4][4]={{'1','2','3','A'},
                     {'4','5','6','B'},
                     {'7','8','9','C'},
                     {'*','0','#','D'}};
main(){
      int i, col, fil,valor;
      //inializamos la libreria
      if (wiringPiSetupGpio() == -1){
            perror("Error de inicializacion\n");
            exit (1) ;
      }
      //ponemos los pines como input y output, además
      //de inicializarlos
      for(i=0;i<4;i++){
            pinMode(inputs[i],INPUT);
            digitalWrite(inputs[i],0);
            pullUpDnControl(inputs[i],PUD_DOWN);
            pinMode(outputs[i],OUTPUT);
            digitalWrite(outputs[i],0);
      }
      //empezamos un bucle infinito del que se sale sólo
      //cuando se pulsa #
      printf("Capturando teclas y mostrando por pantalla\n");
      printf("Para salir pulsa #");
      while(1){
            for(col=0;col<4;col++){
                  columnaCero(col);
                  for(fil=0;fil<4;fil++){
                        valor=digitalRead(inputs[fil]);
                        delay(10);
                        if(valor!=0){
                             printf("Tecla %c\n", teclado[col][fil]);
                              digitalWrite(outputs[col],1);
                             digitalWrite(inputs[fil],0);
                             if(teclado[col][fil]=='#'){
                                   printf("Saliendo\n");
                                   exit(0);
                             }
                        }
                  }
            }
      }
}