- Por qué necesitamos un teclado 4x4:
- Cómo funciona el teclado matricial 4x4:
- Material requerido:
- Diagrama de circuito:
- Explicación de programación:
Los teclados son dispositivos de entrada ampliamente utilizados que se utilizan en diversos proyectos integrados y electrónicos. Se utilizan para tomar entradas en forma de números y alfabetos, y alimentarlas en el sistema para su posterior procesamiento. En este tutorial vamos a conectar un teclado matricial 4x4 con PIC16F877A.
Antes de entrar en la lógica de los detalles y aprender a usar el teclado, necesitaremos saber algunas cosas.
Por qué necesitamos un teclado 4x4:
Por lo general, usamos un solo pin de E / S de una unidad de microcontrolador para leer la señal digital, como una entrada de interruptor. En pocas aplicaciones donde se necesitan 9, 12, 16 teclas para propósitos de entrada, si agregamos cada tecla en un puerto de microcontrolador, terminaremos usando 16 puertos de E / S. Estos 16 puertos de E / S no son solo para leer señales de E / S, sino que también se pueden usar como conexiones periféricas, como los soportes ADC, las conexiones I2C, SPI también son compatibles con esos pines de E / S. Como esos pines están conectados con los interruptores / llaves, no podemos usarlos sino solo como puertos de E / S. Esto no tiene ningún sentido. Entonces, ¿cómo reducir el número de pines? La respuesta es, usando un teclado hexadecimal o un teclado matricial; podemos reducir el número de pines, que asocian teclas matriciales 4x4. Utilizará 8 pines de los cuales 4 están conectados en filas y 4 conectados en columnas, por lo tanto, ahorrará 8 pines del microcontrolador.
Cómo funciona el teclado matricial 4x4:
En la imagen superior se muestra un módulo de teclado matricial a la izquierda. A la derecha se muestra la conexión interna y la conexión del puerto. Si vemos que el puerto tiene 8 pines, los primeros 4 de izquierda a derecha son X1, X2, X3 y X4 son las filas, y los últimos 4 de izquierda a derecha son Y1, Y2, Y3, Y4 son cuatro columnas. Si hacemos 4 filas o el lado X como salida y las hacemos lógicas bajas o 0, y hacemos las 4 columnas como entrada y leemos las teclas, leeremos la presión del interruptor cuando la Y correspondiente obtenga 0.
Lo mismo sucederá en la matriz nxn donde n es el número. Puede ser 3x3, 6x6, etc.
Ahora piense que se presiona 1. Entonces el 1 está situado en la fila X1 y la columna Y1. Si X1 es 0, entonces Y1 será 0. De la misma manera, podemos detectar cada tecla en la fila X1, detectando las columnas Y1, Y2, Y3 e Y4. Esto sucede para cada interruptor y leeremos la posición de los interruptores en la matriz.
Cada círculo verde es el interruptor y ambos están conectados de la misma manera.
En este tutorial, conectaremos el teclado con las siguientes especificaciones:
- Usaremos pull up interno
- Agregaremos la opción de eliminación de rebote clave
Pero no cuando los interruptores están presionados tenemos que hacer el Y1, Y2, Y3 e Y4 como alta o 1. De lo contrario no podemos detectar los cambios de la lógica cuando se pulsa el interruptor. Pero no pudimos hacerlo mediante códigos o programa debido a que esos pines se usan como entrada, no como salida. Por lo tanto, usaremos un registro de operación interno en el microcontrolador y operaremos esos pines como modo habilitado de extracción débil. Al usar esto, habrá un modo lógico de habilitación alta cuando esté en el estado predeterminado.
Además, cuando presionamos la tecla hay picos o se generan ruidos con los contactos del interruptor, y debido a esta presión múltiple ocurre lo que no se esperaba. Entonces, primero detectaremos la presión del interruptor, esperaremos unos milisegundos, nuevamente verificaremos si el interruptor aún está presionado o no y si el interruptor aún está presionado aceptaremos la presión del interruptor finalmente, de lo contrario no. Esto se denomina eliminación de rebotes de los interruptores.
Implementaremos todo esto en nuestro código y realizaremos la conexión en la placa de pruebas.
Compruebe también cómo conectar el teclado 4x4 con otros microcontroladores:
- Interfaz del teclado con Arduino Uno
- Interfaz de teclado matricial 4x4 con microcontrolador 8051
- Interfaz de teclado 4x4 con microcontrolador ATmega32
- Bloqueo de código digital Raspberry Pi en placa de pruebas
Material requerido:
- Tablero de circuitos
- Pic-kit 3 y entorno de desarrollo en su PC, es decir, MPLABX
- Alambres y conectores
- LCD de caracteres 16x2
- 20Mhz de cristal
- 2 tapas de disco de cerámica de 33pF.
- Resistencia de 4.7k
- 10k preestablecido (resistencia variable)
- Teclado matricial 4x4
- Un adaptador de 5 V
Diagrama de circuito:
Conectaremos los cristales y la resistencia en los pines asociados. Además, conectaremos la pantalla LCD en modo de 4 bits a través de PORTD. Conectamos el teclado hexadecimal o el teclado de matriz a través del puerto RB4.
Si es nuevo en PIC, comience con Primeros pasos con el microcontrolador PIC: Introducción a PIC y MPLABX
Explicación de programación:
El código completo para interconectar el teclado de matriz con el microcontrolador PIC se proporciona al final. El código es fácil y se explica por sí mismo. La biblioteca de teclado es lo único que debe entenderse en el código. Aquí hemos utilizado keypad.h y lcd.h Biblioteca para interconectar el teclado y la pantalla LCD 16x2. Así que veamos qué está sucediendo dentro de eso.
Dentro de keypad.h veremos que hemos usado el encabezado xc.h que es la biblioteca de registros predeterminada, la frecuencia de cristal está definida para el uso del retardo usado en el archivo kepad.c. Definimos los puertos del teclado en el registro PORTRB y definimos los pines individuales como fila (X) y columnas (Y).
También usamos dos funciones, una para la inicialización del teclado que redirigirá el puerto como salida y entrada, y un escaneo de pulsación de interruptor que devolverá el estado de pulsación de interruptor cuando se llame.
#incluir
En el keypad.c veremos que la siguiente función devolverá la tecla presionada cuando la función de escáner del teclado no regrese 'n'.
char switch_press_scan (void) // Obtener la clave del usuario { char key = 'n'; // Suponga que no se presiona ninguna tecla mientras (key == 'n') // Espere hasta que se presione una tecla key = keypad_scanner (); // Escanea las claves una y otra vez return key; // cuando se presiona la tecla, devuelve su valor }
A continuación se muestra la función de lectura del teclado. En cada paso haremos que las filas X1, X2, X3 y X4 sean 0 y leeremos el estado Y1, Y2, Y3 e Y4. El retardo se usa para el efecto antirrebote, cuando el interruptor aún está presionado devolveremos el valor asociado a él. Cuando no se presiona ningún interruptor, devolveremos 'n'.
char keypad_scanner (void) { X_1 = 0; X_2 = 1; X_3 = 1; X_4 = 1; si (Y_1 == 0) {__delay_ms (100); while (Y_1 == 0); devuelve '1'; } si (Y_2 == 0) {__delay_ms (100); while (Y_2 == 0); return '2'; } si (Y_3 == 0) {__delay_ms (100); while (Y_3 == 0); return '3'; } si (Y_4 == 0) {__delay_ms (100); while (Y_4 == 0); devuelve 'A'; } X_1 = 1; X_2 = 0; X_3 = 1; X_4 = 1; si (Y_1 == 0) {__delay_ms (100); while (Y_1 == 0); return '4'; } si (Y_2 == 0) {__delay_ms (100); while (Y_2 == 0); devuelve '5'; } si (Y_3 == 0) {__delay_ms (100); while (Y_3 == 0); return '6'; } si (Y_4 == 0) {__delay_ms (100); while (Y_4 == 0); devuelve 'B'; } X_1 = 1; X_2 = 1; X_3 = 0; X_4 = 1; si (Y_1 == 0) {__delay_ms (100); while (Y_1 == 0); return '7'; } si (Y_2 == 0) {__delay_ms (100); while (Y_2 == 0); return '8'; } si (Y_3 == 0) {__delay_ms (100); while (Y_3 == 0); return '9'; } si (Y_4 == 0) {__delay_ms (100); while (Y_4 == 0); return 'C'; } X_1 = 1; X_2 = 1; X_3 = 1; X_4 = 0; si (Y_1 == 0) {__delay_ms (100); while (Y_1 == 0); regreso '*'; } si (Y_2 == 0) {__delay_ms (100); while (Y_2 == 0); return '0'; } si (Y_3 == 0) {__delay_ms (100); while (Y_3 == 0); regreso '#'; } si (Y_4 == 0) {__delay_ms (100); while (Y_4 == 0); return 'D'; } return 'n'; }
También estableceremos el pull up débil en los últimos cuatro bits, y también estableceremos la dirección de los puertos como las últimas 4 entradas y los primeros 4 como salida. El OPTION_REG & = 0x7F; se utiliza para configurar el modo de extracción débil en los últimos pines.
vacío InitKeypad (vacío) { Keypad_PORT = 0x00; // Establecer valores de pin del puerto del teclado en cero Keypad_PORT_Direction = 0xF0; // Entrada de los últimos 4 pines, salida de los primeros 4 pines OPTION_REG & = 0x7F; }
En el programa PIC principal (que se muestra a continuación), primero establecemos los bits de configuración e incluimos algunas bibliotecas necesarias. Luego, en las funciones void system_init, inicializamos el teclado y la pantalla LCD. Y finalmente en la función principal hemos leído el teclado llamando a la función switch_press_scan () y devolviendo el valor a lcd.
Descargue el código completo con los archivos de encabezado desde aquí y consulte el video de demostración a continuación.