Matriz de teclado de prototipos de 64 teclas para Arduino

Acerca de este proyecto

Actualización:he mejorado el código, consulte "Actualización" al final.

Actualmente estoy trabajando en un proyecto que tendrá un teclado integrado, que presentó un problema:¿cómo incluyo un teclado en el prototipo de la placa de desarrollo? No puedo usar un teclado USB o un teclado existente basado en Arduino, porque el teclado en el proyecto real está conectado directamente al microcontrolador que maneja todas las demás funciones. Así que diseñé esta matriz de teclado de prototipos de 64 teclas básica basada en PCB.

Esta PCB no contiene ningún IC (circuitos integrados). Las filas y columnas de la matriz del teclado están conectadas directamente a los encabezados de los pines para que el teclado se pueda conectar a un Arduino o cualquier otro microcontrolador. Es perfecto para crear prototipos de sus proyectos que incluirán un teclado integrado.

He incluido un código detallado y muy comentado para que esto funcione con cualquier placa de desarrollo compatible con Arduino que tenga suficientes pines de E / S disponibles; se requieren 11 pines. El teclado tiene 64 teclas, incluidos modificadores de mayúsculas, mayúsculas, ctrl, alt, fn y "especial". También hay seis teclas adicionales que se pueden usar para lo que quiera. Las funciones de cada tecla se pueden definir individualmente, incluida la función de cada tecla cuando un modificador está activo. En mi opinión, esto es significativamente más útil que el código de teclado existente que limita severamente su capacidad para personalizar el comportamiento de las teclas.

El código proporcionado imprimirá texto en Serial. Esto se puede cambiar fácilmente si desea que el texto vaya a otro lugar.

Una nota sobre el tamaño del programa:

El código que proporciono es bastante grande, porque no utiliza ninguna biblioteca existente. Escribí este código completamente desde cero para permitir la personalización que necesitaba. En un Arduino UNO, esto usará 9100 bytes (28%) del espacio de almacenamiento del programa y las variables globales usan 394 bytes (19%) de memoria dinámica.

Mi código probablemente podría ser más eficiente y sus bibliotecas y bocetos para teclados son ciertamente más pequeños, pero esta es la única forma que pude idear para proporcionar una flexibilidad completa sobre cada tecla con cada modificador. También tiene en cuenta el uso del teclado en el mundo real. Por ejemplo, con mi código presionando la tecla Shift mientras el Bloqueo de mayúsculas está habilitado, resultará en una letra minúscula como debería. De forma predeterminada, mantener presionada la tecla FN mientras presiona ESC no hará nada. Pero ese comportamiento es completamente personalizable, por lo que puede cambiarlo como desee.

Suministros:

• La PCB personalizada
• Botones pulsadores momentáneos táctiles de 6x6x5 mm (x64)
• Diodos de conmutación 1N4148 (x64)
• Encabezados de 1x8 pines, hembra o macho (x2)
• 74HC595 registro de desplazamiento
• Cables de puente
• Protoboard
• Arduino Uno o cualquier placa de desarrollo de microcontrolador compatible con Arduino

Paso 1:Cómo funciona una matriz de teclado

¿Por qué es necesaria una matriz de teclado?

Este teclado tiene 64 teclas. Si tuviera que conectar todos y cada uno de esos botones a su placa de desarrollo directamente, necesitaría 64 pines de E / S. Eso es mucho de pines y más de lo que la mayoría de las placas de desarrollo tienen disponibles. Para reducir eso a un número mucho más razonable, podemos usar una matriz de teclado, que solo requiere un número de pines igual a la raíz cuadrada (redondeado hacia arriba) del número de teclas.

Se configura una matriz de teclado para que cada interruptor de tecla en una fila esté conectado y cada interruptor de tecla en una columna esté conectado. Cuando queremos ver qué teclas están presionadas, "activamos" la primera fila y luego verificamos cada columna. Si una columna en particular está activa, sabemos que se presionó la tecla en esa columna y fila 1. Luego desactivamos la fila 1 y activamos la fila 2, luego revisamos todas las columnas nuevamente. Después de que se hayan activado todas las filas, simplemente comenzamos de nuevo en la primera fila.

Cómo escaneamos la matriz del teclado:

Debido a que estamos trabajando con un microcontrolador, "activar" significa configurar esa fila en BAJA o ALTA. En este caso, estamos configurando la fila en BAJO porque estamos usando las resistencias pullup integradas del microcontrolador. en nuestros pines de entrada de columna. Sin una resistencia pullup o pulldown, un pin de entrada reaccionará de manera impredecible como resultado de la interfaz, que registrará presiones de botón falsas.

El microcontrolador ATmega328P utilizado en Arduino UNO no tiene resistencias pulldown incorporadas, solo resistencias pullup. Entonces los estamos usando. Las resistencias pullup conectan cada pin de entrada a 5V, asegurándose de que siempre lean ALTO hasta que se presiona un botón.

Todas las filas también se establecen normalmente en ALTO, lo que evita que los pines de la columna se conecten a los pines de la fila, ya sea que se haya presionado un botón o no. Pero cuando estemos listos para marcar una fila, podemos establecer esa fila en BAJA . Si se presiona un botón en esa fila, esto proporcionará una ruta para que el pin de entrada se lleve a tierra, lo que da como resultado que esa columna ahora se lea como BAJA .

Entonces, para resumir:establecemos una fila en BAJO y luego verificamos qué pines de columna ahora están leyendo BAJO. Aquellos corresponden a botones presionados. Este proceso ocurre muy rápidamente, por lo que podemos escanear todo el teclado muchas veces por segundo. Mi código limita esto a 200 veces por segundo, lo que equilibra el rendimiento, el rebote y garantiza que se detecte cada pulsación de tecla.

Diodos, imagen fantasma y sustitución de teclas n:

Los diodos en el circuito están ahí para evitar presionar teclas involuntariamente cuando se mantienen presionadas ciertas combinaciones de botones. Los diodos solo permiten que la corriente fluya en una dirección, lo que evita las imágenes fantasma. Si no usamos diodos, entonces presionar ciertas teclas podría causar que se registre otra tecla no presionada, ya que la corriente fluye a través de los interruptores adyacentes. Esto se muestra en el gráfico simplificado donde al presionar cualquier cosa con tres teclas adyacentes, la tecla en la cuarta esquina se registra incluso cuando no se presiona. Los diodos evitan eso y habilitan el "cambio de tecla n", lo que significa que podemos presionar tantas teclas como queramos en la combinación que queramos sin ningún problema.

Guardar pines con un registro de desplazamiento:

Los astutos probablemente notaron que dije que una matriz de teclado requiere un número de pines igual a la raíz cuadrada del número de teclas, pero que yo también Dijo que el diseño de mi teclado solo requiere 11 pines. Debería ser 16, ¿verdad? No, porque estamos usando un registro de desplazamiento 74HC595. Este registro de desplazamiento nos permite usar solo tres de los pines de E / S de Arduino para controlar hasta ocho pines de salida. Esos tres pines nos permiten enviar un byte (ocho bits) al registro de desplazamiento, que establece sus ocho pines de salida en ALTO o BAJO. Al usar el registro de desplazamiento para los pines de la fila de salida, ¡ahorramos 5 pines de E / S completos!

"Entonces, ¿por qué no usar un registro de desplazamiento para los pines de entrada también?" usted pregunta. La respuesta más simple es que la entrada requiere un tipo diferente de registro de desplazamiento y yo no tenía ese tipo a mano. Pero el uso de un registro de desplazamiento para la entrada también complica la forma en que leemos las columnas y puede causar problemas de ruido y "rebotes". Baste decir que es un dolor de cabeza que no tuve que afrontar en este caso.

Paso 2:Diseño de PCB

Diseño esquemático

Ahora que comprende cómo funciona una matriz de teclado, el diseño de mi PCB debería ser sencillo. Diseñé el PCB en KiCAD (lo siento jueces Eagle) y comencé con el esquema. Simplemente coloqué un símbolo de botón y un símbolo de diodo, luego los copié y pegué hasta que tuve mi cuadrícula de 64 teclas. Luego agregué dos símbolos de encabezado de pin de 1x8, uno para las filas y otro para las columnas. Un lado de los botones estaba conectado en columnas y el otro lado de los botones estaba conectado en filas.

El siguiente paso fue asignar huellas de PCB a cada uno de esos símbolos esquemáticos. La biblioteca de huellas incluida de KiCAD tenía las huellas necesarias incorporadas. Cuando diseñe sus propias PCB, debe tener mucho cuidado de elegir las huellas correctas, porque esas son las que realmente terminarán en su PCB. Hay muchos componentes que tienen huellas muy similares, pero con tonos ligeramente diferentes o lo que sea. Asegúrese de elegir aquellos que coincidan con sus componentes del mundo real.

Huellas y números de PIN

Preste especial atención a los números de pin. KiCAD tiene un problema extraño en el que los números de pin del símbolo de diodo esquemático no coinciden con los números de pin de la huella. Esto da como resultado que los diodos estén al revés, lo cual es un problema serio dada su polaridad. No me di cuenta de ese error y tuve que tirar el primer lote de PCB que pedí. Para solucionar este problema en la segunda revisión, tuve que crear una huella de diodo personalizada con los números de pin intercambiados.

Diseño de PCB

Con el esquema hecho y las huellas asignadas, pasé al diseño de PCB real. El contorno de la placa se creó en Autodesk Fusion 360, se exportó como DXF y luego se importó a KiCAD en la capa Edge Cuts. La gran mayoría del trabajo posterior consistió simplemente en organizar los botones para que tuvieran un diseño similar al de un teclado normal.

Luego se enrutaron todos los rastros. Debido a que el diseño real de los botones no coincide con la matriz ordenada y ordenada del esquema, esta parte se volvió un poco complicada y tuve que recurrir al uso de vías en algunos lugares. Vias te permite enrutar un rastro de una capa a otra, lo que es realmente útil cuando estás usando un tablero de 2 capas que tiene muchos rastros superpuestos. Finalmente, agregué regiones llenas, porque es una buena práctica.

Fabricación de PCB

Con el tablero diseñado, simplemente tracé todas las capas y las agregué a una carpeta zip. Esa carpeta se proporciona aquí y se puede cargar directamente a un servicio de fabricación de PCB como JLCPCB.

Aquí está el enlace a los archivos de PCB Gerber:https://drive.google.com/file/d/10YriLLtghV0Sb84Wm ...

Paso 3:Ensamblaje de PCB

Este es el paso más fácil, pero más tedioso, de todo el proyecto. Simplemente suelde todos los componentes en su lugar. Todos son componentes de orificios pasantes y son fáciles de soldar. Preste especial atención a la orientación de los diodos. La marca de los diodos debe coincidir con las marcas de la PCB.

En mi experiencia, fue más fácil sostener el PCB en su lugar con una tercera mano y colocar todos los diodos primero. Luego voltee la placa y suéldalos todos, luego sujete los cables. Luego coloque todos los botones y suéldelos. Luego suelde los cabezales de los pines en su lugar. Puede usar encabezados de pines femeninos o masculinos, depende completamente de usted. Si usa la cabeza masculina y la coloca debajo el tablero, el espaciado es correcto para pegarlos directamente en un tablero.

Paso 4:conecta el teclado a tu Arduino

El cableado parece complicado, pero realmente no es tan malo cuando prestas atención a dónde va todo.

Ocho cables de puente irán desde el encabezado de la columna directamente a los siguientes pines de Arduino:

• Columna 1> A0
• Columna 2> A1
• Columna 3> A2
• Columna 4> A3
• Columna 5> A4
• Columna 6> A5
• Columna 7> 5
• Columna 8> 6

A continuación, coloque el registro de cambios 74HC595 en su placa de pruebas a ambos lados del descanso del medio. ¡Toma nota de la orientación del chip! El punto indica Pin 1

Eche un vistazo al diagrama de cableado para ver dónde van las conexiones de 5 V y tierra. El registro de desplazamiento tiene dos pines conectados a 5V y dos pines conectados a tierra.

Solo se necesitan tres cables para conectar el registro de desplazamiento al Arduino. Ellos son:

• Mayús (reloj) 11> 4
• Mayús (Latch) 12> 3
• Mayús (datos) 14> 2

Por alguna razón tonta, los pines de salida del registro de desplazamiento están dispuestos de una manera contraria a la intuición. Preste especial atención al diagrama de distribución de pines del registro de cambio cuando los conecte a los pines de la fila. Ellos son:

• Fila 1> Mayús (Q0) 15
• Fila 2> Mayús (Q1) 1
• Fila 3> Mayús (Q2) 2
• Fila 4> Mayús (Q3) 3
• Fila 5> Mayús (Q4) 4
• Fila 6> Mayús (Q5) 5
• Mayús 7> Mayús (P6) 6
• Mayús 8> Mayús (Q7) 7

No hay nada conectado a los pines Arduino 0 o 1, porque esos también se utilizan para el puerto serie y causan conflictos.

Paso 5:Actualice el código Arduino

Actualice su Arduino con el código proporcionado aquí. No hay nada especial en esto, simplemente cargue el código como lo haría con cualquier otro proyecto de Arduino.

Todo en el código tiene comentarios detallados que puede leer, por lo que no entraré en muchos detalles aquí. Básicamente, los pines se configuran como entradas y salidas. El bucle principal solo contiene una función de temporizador. Cada 5ms, llama a la función para escanear el teclado. Esa función llama a una función separada para establecer el registro de desplazamiento antes de verificar cada columna. Las teclas presionadas imprimen su valor en Serie.

Si desea cambiar lo que se imprime cuando presiona una tecla, simplemente cambie Serial.print ("_"); en la sentencia if que corresponda a la condición. Por ejemplo, puede configurar lo que se imprime cuando mantiene presionada la tecla FN y presiona N. Lo mismo es cierto para todas las demás teclas con cada modificador.

Muchas teclas no hacen nada en absoluto en este código, porque solo se imprime en Serial. Eso significa que la tecla de retroceso no tiene ningún efecto, porque no se puede eliminar del monitor de serie; esos datos ya se han recibido. Sin embargo, es libre de cambiar eso si lo desea.

Uso del teclado con sus propios proyectos

Es bueno imprimir en serie, pero ese no es realmente el objetivo de este teclado. El propósito de este teclado es crear prototipos de proyectos más complejos. Por eso es fácil modificar la funcionalidad. Si, por ejemplo, desea imprimir el texto escrito en una pantalla OLED, simplemente puede reemplazar cada Serial.print ( con display.print ( o lo que requiera su pantalla particular. Reemplazar todo del IDE de Arduino La herramienta es excelente para reemplazarlos todos en un solo paso.

¡Gracias por leer esto y espero que este teclado te ayude con tus proyectos!

Actualización del 30/1/21:

Este nuevo código está completamente reescrito y funciona mejor que el código original. Esto se hizo principalmente para abordar un problema con mi algoritmo que evitaba que se ingresaran caracteres cada vez que se presionaba una tecla. Se verificó el código original para asegurarse de que una clave en particular no fuera la última tecla a presionar. Esto causaba un problema si se mantenían presionadas 2 o más teclas, lo que causaría que se ingresara algo como "fgfgfgfgfgfgfgfgfgfg". Esto también le impidió ingresar la misma clave una y otra vez con mucha rapidez, como cuando escribe las dos m en la palabra "bummer".

El nuevo código resuelve ambos problemas y también es más elegante. En lugar de realizar un seguimiento de la última tecla que se presionó, verificamos el estado de todo el teclado y lo comparamos con el estado completo del teclado en el último ciclo. Esto significa que el ciclo puede ejecutarse mucho más rápido y también puede ingresar la misma clave una y otra vez muy rápidamente. El rendimiento se mejora drásticamente. Todos los caracteres también están en matrices en la parte superior, por lo que puede encontrarlos y cambiarlos fácilmente. Hay matrices independientes para cada modificador. El código también es mucho más corto.

La única desventaja de este nuevo enfoque es que usa más memoria dinámica, aunque usa significativamente menos espacio de programa. En un Arduino Uno, ahora usa:3532 bytes (10%) de espacio de almacenamiento del programa y 605 bytes (29%) de memoria dinámica.

Como beneficio adicional, este código funciona igual de bien en microcontroladores rápidos como el ARM Cortex-M4. El temporizador de intervalos para comprobar el teclado está en microsegundos, por lo que funcionará igual en cualquier placa. También puede ajustar fácilmente la frecuencia con la que se revisa el teclado. De forma predeterminada, se ejecuta un bucle cada 500 microsegundos. Se necesitan 8 bucles para verificar el teclado, para un total de 4000 microsegundos (4 milisegundos o 250 veces por segundo), aunque puede llevar más tiempo si el micro no es lo suficientemente rápido para ejecutar el código tan rápido.

 Sin vista previa (solo descarga). 

 / * Sketch para prototipos de teclado V1.2 * por Cameron Coward 30/1/21 * * Probado en Arduino Uno. Requiere PCB * personalizado y un registro de desplazamiento 74HC595. * * Más información:https://www.hackster.io/cameroncoward/64-key-prototyping-keyboard-matrix-for-arduino-4c9531 * / const int rowData =2; // Pin de datos de registro de desplazamiento para rowsconst int rowLatch =3; // Cambio de registro Latch pin para rowsconst int rowClock =4; // shift register Pin de reloj para filas // estos son nuestros pines de entrada de columna. El pin 0 y el pin 1 no se utilizan, // porque causan problemas (presumiblemente porque son TX y RX) const int colA =A0; const int colB =A1; const int colC =A2; const int colD =A3; const int colE =A4; const int colF =A5; const int colG =5; const int colH =6; // shiftRow es el byte de registro de desplazamiento requerido para cada fila, rowState contendrá teclas presionadas para cada rowconst byte shiftRow [] ={B01111111, B10111111, B11011111, B11101111, B11110111, B11111011, B11111101, B11111110}; byte rowState [] ={B00000000, B00000000, B00000000, B0000, B0000State, B0000 ] ={B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000}; // Códigos ASCII para teclas sin modificadores presionados. Los modificadores son NULL (0), // porque los comprobaremos por separado y sus valores no deben imprimirse.const char key [] ={0, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 45, 61, 0, 9, 113, 119, 101, 114, 116, 121, 117, 105, 111, 112, 91, 93, 92, 7, 97, 115, 100, 102, 103, 104, 106, 107, 108, 59, 39, 0, 0, 122, 120, 99, 118, 98, 110, 109, 44, 46, 47, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0}; // Códigos ASCII para teclas con mayúsculas presionadas Y mayúsculas es activeconst char capsShiftKey [] ={0, 33, 64, 35, 36, 37, 94, 38, 42, 40, 41, 95, 43, 0, 9, 113, 119, 101, 114, 116, 121, 117, 105, 111, 112, 123, 125, 124, 7, 97, 115, 100, 102, 103, 104, 106, 107, 108, 58, 22, 0, 0, 122, 120, 99, 118, 98, 110, 109, 44, 46, 47, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0}; // Códigos ASCII para teclas con shift presionado.const char shiftKey [] ={0, 33, 64, 35, 36, 37, 94, 38, 42, 40, 41, 95, 43, 0, 9, 81, 87, 69, 82, 84, 89, 85, 73, 79, 80, 123, 125, 124, 7, 65, 83, 68, 70, 71, 72, 74, 75, 76, 58, 22, 0, 0, 90, 88, 67, 86, 66, 78, 77, 44, 46, 47, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0}; // Códigos ASCII para teclas con ctrl presionado.const char ctrlKey [] ={ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0}; // Códigos ASCII para teclas con spcl presionado.const char spclKey [] ={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // Códigos ASCII para las teclas con alt presionado.const char altKey [] ={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // Códigos ASCII para teclas con fn presionado .const char fnKey [] ={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // Los códigos ASCII para claves con mayúsculas son activeconst char capsKey [] ={0, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 45, 61, 0 , 9, 81, 87, 69, 82, 84, 89, 85, 73, 79, 80, 91, 93, 92, 7, 65, 83, 68, 70, 71, 72, 74, 75, 76, 59 , 39, 0, 0, 90, 88, 67, 86, 66, 78, 77, 44, 46, 47, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0 }; long previousKeyboardMicros =0; // se almacenará la última vez que se verificó el teclado // las siguientes variables son largas porque el tiempo, medido en milisegundos, // se convertirá rápidamente en un número mayor que el que se puede almacenar en un int.long keyboardInterval =500; // intervalo en el que comprobar el teclado (microsegundos) int rowToCheck =0; // Comprobamos una fila por ciclo de checkKeyboard (), esto combinado con keyboardInterval // le da al shiftRegister tiempo para actualizarse completamente entre las filas checksbool caps =false; // ¿Está el bloqueo de mayúsculas activado? bool shift =false; // ¿Está presionada la tecla Mayús izquierda o derecha? bool capsShift =false; // ¿Están activos shift AND caps? bool ctrl =false; // ¿Está presionada la tecla ctrl? bool spcl =false; // ¿Está presionada la tecla spcl? bool alt =false; // ¿Está presionada la tecla alt? bool fn =false; // ¿Está presionada la tecla de función? void setup () {Serial.begin (9600); // configura todos los pines de la columna como entradas con resistencias pullup internas pinMode (colA, INPUT_PULLUP); pinMode (colB, INPUT_PULLUP); pinMode (colC, INPUT_PULLUP); pinMode (frío, INPUT_PULLUP); pinMode (COLE, INPUT_PULLUP); pinMode (colF, INPUT_PULLUP); pinMode (colG, INPUT_PULLUP); pinMode (colH, INPUT_PULLUP); // las salidas necesarias para controlar el registro de desplazamiento 74HC595 pinMode (rowLatch, OUTPUT); pinMode (rowClock, OUTPUT); pinMode (datos de fila, SALIDA); updateShiftRegister (B11111111); // asegúrese de que el registro de desplazamiento comience en ALTO} void loop () {mainTimer ();} void mainTimer () {unsigned long currentMicros =micros (); // ¿Cuántos microsegundos ha estado funcionando Arduino? if (currentMicros - previousKeyboardMicros> keyboardInterval) {// si el tiempo transcurrido desde la última verificación excede el intervalo // guardar la última vez que se verificó el teclado previousKeyboardMicros =currentMicros; checkKeyboard (); // verifica todas las claves e imprime los resultados en serie}} void updateShiftRegister (fila de bytes) {// esta función establece el registro de desplazamiento de acuerdo con el byte que se le pasó digitalWrite (rowLatch, LOW); // establece el pestillo en bajo para que podamos escribir un byte completo a la vez shiftOut (rowData, rowClock, MSBFIRST, row); // escribe ese byte digitalWrite (rowLatch, HIGH); // establece el pestillo de nuevo en alto para que el registro de desplazamiento permanezca estable hasta el próximo cambio} void checkKeyboard () {// establece el registro de desplazamiento en el valor de byte de la fila actual, desde la matriz de bytes shiftRow [] updateShiftRegister (shiftRow [rowToCheck]); // Verifique cada columna if (digitalRead (colA) ==LOW) {bitSet (rowState [rowToCheck], 0); } else {bitClear (rowState [rowToCheck], 0); } if (digitalRead (colB) ==LOW) {bitSet (rowState [rowToCheck], 1); } else {bitClear (rowState [rowToCheck], 1); } if (digitalRead (colC) ==LOW) {bitSet (rowState [rowToCheck], 2); } else {bitClear (rowState [rowToCheck], 2); } if (digitalRead (colD) ==LOW) {bitSet (rowState [rowToCheck], 3); } else {bitClear (rowState [rowToCheck], 3); } if (digitalRead (colE) ==LOW) {bitSet (rowState [rowToCheck], 4); } else {bitClear (rowState [rowToCheck], 4); } if (digitalRead (colF) ==LOW) {bitSet (rowState [rowToCheck], 5); } else {bitClear (rowState [rowToCheck], 5); } if (digitalRead (colG) ==LOW) {bitSet (rowState [rowToCheck], 6); } else {bitClear (rowState [rowToCheck], 6); } if (digitalRead (colH) ==LOW) {bitSet (rowState [rowToCheck], 7); } else {bitClear (rowState [rowToCheck], 7); } // establece todos los pines del registro de desplazamiento en ALTO, esto evita que los valores "sangren" al siguiente ciclo updateShiftRegister (B11111111); rowToCheck =rowToCheck + 1; // iterar a la siguiente fila // después de comprobar la 8ª fila, comprobar los estados (pulsaciones de botones) y luego empezar de nuevo en la 1ª fila if (rowToCheck> 7) {checkPressedKeys (); rowToCheck =0; }} void checkPressedKeys () {// verifica si se presiona alguna tecla de mayúsculas if (bitRead (rowState [5], 1) | bitRead (rowState [6], 4)) {shift =true; } else {shift =false; } // verifica si se presiona la tecla ctrl if (bitRead (rowState [6], 5) | bitRead (rowState [7], 3)) {ctrl =true; } más {ctrl =falso; } // verifica si se presiona alguna de las teclas spcl if (bitRead (rowState [6], 6) | bitRead (rowState [7], 2)) {spcl =true; } más {spcl =falso; } // verifica si se presiona alguna de las teclas alt if (bitRead (rowState [6], 7) | bitRead (rowState [7], 1)) {alt =true; } más {alt =falso; } // verifica si se presiona la tecla FN if (bitRead (rowState [7], 4)) {fn =true; } más {fn =falso; } // comprobar que las mayúsculas están activas y se presiona shift if (shift ==true &&caps ==true) {capsShift =true; } else {mayShift =false; } for (int i =8; i> =0; i--) {// iterar a través de cada fila para (int j =7; j> =0; j--) {// iterar a través de cada bit en esa fila bool newBit =bitRead (rowState [i], j); // verifica el estado de ese bit bool prevBit =bitRead (prevRowState [i], j); // verifica el estado anterior de ese bit if ((newBit ==1) &&(prevBit ==0)) {// solo permite presionar el botón si el estado ha cambiado a verdadero int thisChar =(i * 8) + j; // calcula qué posición en la matriz de caracteres seleccionar if (mayShift ==true) {processKey (capsShiftKey [thisChar]); } else if (shift ==true) {processKey (shiftKey [thisChar]); } else if (ctrl ==true) {processKey (ctrlKey [thisChar]); } else if (alt ==true) {processKey (altKey [thisChar]); } else if (spcl ==true) {processKey (spclKey [thisChar]); } else if (fn ==true) {processKey (fnKey [thisChar]); } else if (caps ==true) {processKey (capsKey [thisChar]); } else {clave de proceso (clave [thisChar]); }} if (newBit ==1) {bitSet (prevRowState [i], j); // establece el estado del bit anterior en verdadero si se presiona una tecla} else {bitClear (prevRowState [i], j); // establece el estado del bit anterior en falso si no se presiona la tecla, para que se pueda presionar nuevamente}}}} void processKey (charivedKey) {if (selectedKey ==7) {// verifica las funciones especiales de la misma manera como mayúsculas (agregue nuevas declaraciones "else if") mayúsculas =! mayúsculas; } else {Serial.print (clave recibida); // si char no corresponde a una función especial, simplemente imprima ese char}}