Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Keypad en Arduíno - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 17 de diciembre de 2025 por Francisco J. G.

3 visualizaciones

Keypad en Arduíno

Más información Transcripción

Descargar la transcripción

y buenas tardes tengo otro esquema aquí con un elemento nuevo que sería este de aquí este 00:00:00
elemento es el keypad o lo que se podría llamar el teclado matricial 4x4 de arduino para el 00:00:09
siguiente esquema en tinker cat vamos a usar un teclado matricial 4x4 un comento muy habitual en 00:00:18
proyectos de seguridad control de accesos domótica y sistemas interactivos el teclado tiene 16 teclas 00:00:23
organizadas en cuatro filas y cuatro columnas, lo que permite a Arduino detectar qué tecla se 00:00:29
pulsa usando sólo ocho pines digitales en vez de 16. ¿Cómo funciona este teclado 4x4? El 00:00:34
teclado no envía números directamente, internamente funciona como una matriz de interruptores. Cada 00:00:42
tecla conecta una fila con una columna. Arduino activa las columnas una a una, lee qué fila recibe 00:00:47
señal y con esa combinación sabe qué tecla se ha pulsado. Ejemplo, columna 4, que sería esta de aquí, 00:00:55
con la fila 1 nos daría la tecla A. La columna 2 con la fila 3 nos daría la tecla 8. Y así 00:01:02
sucesivamente. Está formado este componente con ocho pines, que serían estos de aquí, y que van 00:01:13
en orden, van fila 1, fila 2, fila 3 y fila 4 y luego columna 1, columna 2, columna 3 00:01:19
y columna 4. ¿Qué sucederá? Fijaos, he puesto para la fila 1 el pin 2, para la fila 2 el 00:01:24
3, el 4 y el 5. Se han conectado cada uno a un pin y van en ese orden las filas del 00:01:36
2 al 5. Mientras que en las columnas, desde la columna 1 va desde el 8, 9, 10 y 11. Con lo cual 00:01:42
tendríamos que hemos usado para las filas los pines digitales 2, 3, 4 y 5 y para las columnas 00:01:51
el 8, 9, 10 y 11. Bien, no voy a hacer el circuito porque es bastante fácil, no es nada más que 00:01:57
llevar los cables a cada uno de los pines y ponerlos en orden. Entonces lo que nos vamos a 00:02:07
fijar bueno primero voy a dar a iniciar para que veamos qué es lo que hace el código el código lo 00:02:11
que va a hacer es ya veis aquí en el monitor en serie me aparece keypad 4x4 listo y pulsa las 00:02:17
teclas asterisco para borrar y esta otra para mostrar y limpiar entonces yo lo que voy a ir 00:02:26
dando esas teclas y veis me va acumulando esas teclas generando una cadena una vez que la quiero 00:02:31
confirmar le doy a confirmar y me confirma esa enumeración si le quiero borrar le doy a borrado 00:02:38
aquí y puedo seguir escribiendo de nuevo básicamente eso es lo que haría el programa 00:02:45
el código que aparece aquí voy a quitar el monitor para que se vea el programa es este 00:02:50
que aparece aquí lo tengo aquí antes que nada os voy a repasar lo que es el keypad 4x4 y veis 00:02:57
aquí que como está la fila 1 2 3 y 4 que en inglés es row pues por eso aparece la r y van en orden y 00:03:06
luego tenemos el caso de las columnas de column en inglés que sería la 1 la 2 la 3 y la 4 y así 00:03:13
los 8 pines qué sucede con respecto al código vamos a empezar con la primera línea de código 00:03:19
que sería esta de aquí la agrandamos y qué es lo que vemos vamos a ver que primero lo que hace es 00:03:26
va a incluir una librería que sería kpad.h. 00:03:35
Necesitaremos esta librería para poder hacer el código 00:03:44
y utilizar los métodos de kpad. 00:03:49
A continuación ha creado dos constantes de tipo byte 00:03:52
en el que uno será filas, que tiene un valor inicial de 0, 00:03:56
y otro es que sea columns, que sea columnas, que es un valor de 4. 00:04:01
Aquí introduce el término de array que ya vimos en el paso de programación en C++ y es un array de caracteres en el que ha puesto un array bidimensional en el que tenemos que la primera sería las filas y la segunda las columnas y mete esta matriz. 00:04:05
¿Veis? Esta sería la primera fila y esta la segunda, la tercera y la cuarta 00:04:25
En el mismo orden que aparecen en el keypad 00:04:31
Si nos miramos el keypad, aparecen en el mismo orden 00:04:34
1, 2, 3, 3A 00:04:38
¿Veis? En la primera fila, la segunda, la tercera y la cuarta 00:04:40
Y estas serían las columnas 00:04:43
Y genera esa matiz bidimensional para luego poder utilizarla 00:04:44
Ya lo veremos para aquí 00:04:51
Vamos a ver la primera que era esta de aquí 00:04:52
Una vez que ha creado esas dos constantes y un char, un array de caracteres, a continuación genera otros dos tipos de arrays, que sería el pines de las filas, en el que su dimensión va a ser filas, que sea de cuatro elementos, es un array unidimensional, que sería 1, 2, 3 y 4. 00:04:54
Y luego el de columnas que sería 8, 9, 10 y 11 en el que lo que hace aquí estos dos arrays es para contener los pines digitales, los números de los pines digitales. 00:05:21
Aquí con respecto al esquema que yo tengo hay una diferencia que yo he empezado en el 2 y sería 2, 3, 4 y 5 y luego 8, 9, 10 y 11. 00:05:33
¿Por qué digo lo del 2? Porque normalmente los dos pines, el 0 y el 1, el TX y el RX, no se puede utilizar con monitor en serie y daría resultados extraños. 00:05:43
Entonces, por ello empiezo desde el 2. La única diferencia, si veis aquí, es que empezaba en el 2, 3, 4 y 5, aunque tenga en esta imagen 1, 2, 3 y 4. 00:05:58
Bien, una vez que ya tenemos las dos constantes, tenemos el array bidimensional y los dos arrays unidimensionales, esto es para contener los pines y esto para contener todas las teclas de la matriz del keypad, a continuación en el código genera de nuevo otras dos variables. 00:06:10
Una primera variable es de tipo keypad, o sea, estamos creando un objeto keypad, que sería este, y como se crea, se crea de esta manera. Se crea con este método, keypad, con otra función que lleva dentro de él, que sería el make keymap, que es un map de claves en el que serían las teclas. 00:06:29
Las teclas las hemos visto aquí, las teclas serían, cuando aquí ponemos teclas, se está refiriendo a la matriz bidimensional, que es aquí. 00:06:56
Entonces, lo que está haciendo este Make Keep Map es asociar toda esta matriz bidimensional con estas unidimensionales. 00:07:09
¿Qué quiere decir? Está asociando esta matriz de cuatro filas por cuatro columnas con estas dos filas de pines. ¿Para qué? Para asignar a la fila 1, que sería esta, le está asignando el pin 2, a la fila 2 le está asignando el pin 3, 00:07:20
A la fila 3 le está asignando el 4 y a la fila 4 le está asignando el 5. 00:07:44
Y a su vez, veis que aquí he puesto pines filas y luego la otra parte será la de pines columnas. 00:07:49
Entonces se está asociando a la raíz de pines columnas, le está asociando que el 8 corresponde a esta columna, 00:07:57
que el 9 corresponde a esta otra columna, que el 10 corresponde a esta otra columna y que el 11 corresponde a esta otra columna. 00:08:05
Por último, añade dos componentes más, que serían estos dos de aquí, que sean filas y columnas, para indicarle cuántas filas y cuántas columnas hay. 00:08:13
O sea que realmente aquí tendríamos la matriz bidimensional de los 16 caracteres y aquí tendríamos la unidimensional de los pines de la fila, los de las pines de las columnas y aquí indicaríamos de cuántas filas y de cuántas columnas consta estos dos tipos. 00:08:24
de variables como sabemos que son filas lo hemos puesto como una constante y vale 4 y 00:08:54
columnas vale 4 valdría lo mismo poner un 4 aquí en 4 aquí entonces necesita de esta línea en 00:08:59
nuestro objeto keypad para generarlo continuación nos queda una variable de tipo string en el que 00:09:08
va a ser, va a contener una cadena 00:09:18
y que en principio está vacía 00:09:20
la tercera parte del código 00:09:21
sería el 00:09:24
voice setup, en el que lo único 00:09:25
que hace es que aquí inicializa 00:09:28
el monitor en serie 00:09:30
esto ya lo hemos visto en otros vídeos 00:09:33
y luego pues imprime 00:09:35
la cabecera de ese monitor en serie 00:09:37
que aparecerá nada más arrancar 00:09:39
keypad 4x4 listo, pulsa teclas 00:09:41
y otra línea en el que 00:09:44
ponga asterisco borrar y 00:09:46
mostrar y limpiar y por último nos quedaría la parte del loop que sería esta de aquí entonces 00:09:47
en el loop también se crea otra variable que se llamaría tecla y utiliza un método que se 00:09:55
llama un get key cuando a nuestro objeto keypad que lo hemos generado arriba le aplicamos el 00:10:01
método get key nos está indicando que carácter qué carácter estamos clickeando ese carácter 00:10:08
será almacenado en una variable 00:10:17
de tipo char, que será variable tecla. 00:10:22
A continuación lo que va a hacer es comparar ese carácter 00:10:26
a ver si se corresponde con el asterisco, se corresponde con 00:10:29
la tecla de hashtag o se corresponde con cualquier otra tecla. 00:10:33
Si se corresponde con el asterisco, veis aquí que establece la igualdad 00:10:38
a través de un condicional. Primero nos dice que si tecla 00:10:42
si tecla existe, si se ha pulsado alguna tecla 00:10:45
entonces entre en todo este condicional. El condicional 00:10:49
va desde aquí, desde esta llave hasta esta otra llave. A su vez 00:10:53
dentro va a hacer otra condición a través de otro if y va a compararlo 00:10:57
con el asterisco. ¿Por qué? Porque si el asterisco 00:11:01
si la tecla que ha pulsado es un asterisco lo que queremos es que borre. Entonces nos dice 00:11:03
que entrada está vacía. Entrada es lo que luego va a mostrar en el 00:11:09
monitoreo en serie. Y lo que hace es que en el monitoreo en serie 00:11:13
imprime borrado y sale del 00:11:17
con este return, saldrá de todo este if 00:11:20
y leerá el siguiente. ¿Qué sucede si 00:11:24
pulsas esta otra tecla? Si coincide y la tecla 00:11:28
que ha pulsado es esta, entonces escribe en el monitoreo en serie confirmado 00:11:33
y muestra el valor de la variable entrada 00:11:37
Y a su vez también da un return y sale de él. 00:11:40
Por último, guardar y mostrar a la tecla pulsada, ¿qué es lo que va haciendo? 00:11:47
Lo que va haciendo es que en entrada, que es realmente lo que luego va a imprimir en el monitor en serie, va añadiendo cada tecla que nosotros vamos pulsando. 00:11:50
Esas teclas se van obteniendo desde el keypad.getkey y las va acumulando dentro de entrada. 00:12:00
Una vez que las ha acumulado, a continuación imprimirá tecla, imprimirá lo que haya acumulado y volverá a poner entrada para que podamos añadir una nueva tecla. 00:12:06
Aquí lo que hace es que imprime en orden, cuando yo le doy a simular, no está detenido, sino estaría aquí, veis, imprime la tecla que hemos pulsado en ese momento. 00:12:21
La tecla que hemos pulsado en ese momento sería, primero pone tecla, luego pone la tecla que hemos pulsado, después una barra vertical con entrada y luego nos pone lo que hay acumulado. 00:12:39
Aquí, como vemos, lo último que hemos añadido es un 7 y un 5 y no hemos borrado ni confirmado, pues va acumulando distintos caracteres que vamos cliqueando. 00:12:50
Entonces, primero pone la tecla que hemos dado y luego en la entrada pone lo que se va acumulando. 00:13:02
Si yo voy aquí y borro, ¿veis? Borrado, ya nuestro valor de la entrada se quedaría vacío. 00:13:07
lo hemos visto aquí aquí cuando le doy al asterisco lo que hace es que lo borra y entrada 00:13:16
la deja vacía la vez en cambio cuando yo le voy dando teclas las 5 las 7 las va acumulando dentro 00:13:24
de entrada y cuando ya lo confirmamos pues se quedaría ese valor continuación si escribo 00:13:32
empezaría otra vez de nuevo una vez y eso es lo que hace el código de loop y lo va a estar haciendo 00:13:38
haciendo de manera continua por tanto como repaso tenemos vamos a detenerlo y 00:13:45
vamos a comentar el código esto lo bajamos y tenemos primero 00:13:59
lo primero que hace es incluir la librería 00:14:05
keypad porque luego tendremos que hacer crear un 00:14:13
objeto keypad. Aquí lo que hace es crear dos constantes que serían filas con un 00:14:17
valor de 4 y cols con un valor de 4. Podríamos haber ahorrado estas dos líneas y 00:14:33
sencillamente como aparece únicamente filas y columnas haber puesto un 4 aquí 00:14:42
y había puesto un 4 aquí, pero lo hacemos con una variable para poder, si nosotros queremos cambiar, por ejemplo, 00:14:48
imaginaos que queremos cambiar el tamaño del array bidimensional, pues tendríamos que quitar en todos los lugares 00:14:55
donde aparezcan filas y columnas, tendríamos que quitar el 4 y poner por el nuevo valor. 00:15:04
En cambio, al utilizar dos constantes, solo habría que cambiarlo en la parte de arriba. 00:15:09
Por eso se utilizan siempre constantes y variables para determinar determinados valores. 00:15:14
A continuación, aquí tenemos el crea una matriz bidimensional de 4x4. 00:15:20
Esa matriz que va a tener, concretamente lo que tiene, la matriz se llama teclas, 00:15:34
y será una matriz de 4 filas por 4 columnas de caracteres. 00:15:40
El tipo de dato de esa matriz son caracteres y los pone entre llaves poniendo que está la primera fila, la segunda fila, la tercera fila y la cuarta fila, como aparece en el keypad. 00:15:47
Después ajusta estos pines, esta sería la creación de dos arrays subdimensionales en el que el primero de cuatro, dos arrays de cuatro elementos cada uno, en el que en cada uno de ellos pone los pines de las filas y los pines de las columnas. 00:16:01
Estos serían dos arrays unidimensionales con los pines de las filas y de las columnas. 00:16:19
A continuación aquí nos va a crear un objeto, aquí crea un objeto keypad y ¿cómo lo crea? Lo crea con el método keypad o realmente también esto podría ser, 00:16:38
o realmente no, es el constructor de Kpad 00:17:12
en el que ese constructor necesita de dos, cuatro o cinco parámetros. 00:17:16
Esos cinco parámetros están formados, el primero, por la función makeKeyMap. 00:17:20
Es un map que lo que va a hacer es asociar la red bidimensional de teclas, 00:17:26
que serían todas estas, 00:17:31
la va a asociar con los pines de las filas, 00:17:33
con los pines de las columnas 00:17:37
y luego posteriormente indica cuántas filas y columnas hay, que sería 4 y 4. 00:17:38
Entonces está asociando esta MakeKeyMap, asocia toda esta matriz bidimensional. 00:17:43
¿Cómo? Pues asocia a esta fila, le asocia el valor del pin 2. 00:17:50
A esta otra fila, el 3. A esta otra fila, el 4. Y a esta otra fila, el 5. 00:17:58
Y a su vez las columnas, esta columna está asociada al 8, esta columna la asocia al 9, 00:18:03
esta al 10 y esta al 11 00:18:08
de tal manera que estamos indicando que ese objeto keypad 00:18:10
tiene ya una serie de teclas que sea un 4x4 00:18:14
y indica que pines tiene asociado a cada una de las filas y columnas 00:18:20
para saber en ese objeto keypad donde está cada una de las teclas 00:18:24
porque si os acordáis habíamos definido que para determinar una terminal tecla 00:18:29
estaba asociado con el cruce que se obtenía entre su fila y su columna. 00:18:34
Posteriormente crea una variable string que contiene la entrada, 00:18:43
lo que vamos añadiendo y que se va a ir acumulando. 00:19:04
A continuación, en el voice setup, no lo voy a comentar porque realmente no es más que inicializar el monitor en serie y luego imprime las dos líneas de inicialización del monitor. 00:19:06
Y ya pasamos al loop. En el loop aquí tenemos una línea que sería para saber qué tecla se está apretando. 00:19:19
el keypad o el getKey o método getKey de keypad lo que nos va a dar es qué tecla se está apretando 00:19:28
en ese momento por tanto almacena la tecla que se está clickeando en ese momento bien a continuación 00:19:37
aquí nos van a aparecer una serie de condicionales, un condicional, condicionales para saber qué tecla es pulsada. 00:20:00
En un principio, si pulsas el asterisco, ¿qué es lo que sucede? 00:20:18
Pues lógicamente, como queremos que el asterisco, al pulsarlo, nos borre la cadena, 00:20:22
pues la entrada, que era lo que iba acumulando cada una de las teclas que vamos dando, pues la deja vacía y pone borrado. 00:20:25
Y procedería al RETRUM para salir del condicional. 00:20:33
Posteriormente, si es esta otra tecla, ya hemos dicho que es para confirmarlo. 00:20:38
Al confirmarlo, imprime la cadena de entrada, ¿veis? En el monitor en serie la imprime 00:20:43
y a continuación la vuelve a vaciar para que podamos acumular una nueva entrada y sale del condicional. 00:20:50
Y por último tenemos aquí la actualización guarda y muestra la tecla pulsada. 00:20:58
Cada vez que damos una tecla, mientras no se haya borrado o no se haya confirmado, va a ir añadiendo esa tecla a la entrada o la cadena string. 00:21:03
Esto sería lo mismo que entrada igual a entrada más tecla. 00:21:13
Si yo he añadido en la entrada esta vacía y aprieto el 8, pues se acumularía entrada como está vacío, sería vacío más el 8, nos quedaría el 8. 00:21:27
Si luego añado el 9, pues al 8 le pondría a continuación en la cadena el 9 y así sucesivamente. 00:21:37
y última y lo último pues sería pues que imprime pues la entrada la tecla y 00:21:43
la entrada de manera horizontal y por cada una de las 00:21:49
por cada una de las entradas pues irá gracias a este println o retorno de 00:21:54
carro hará que cada una de ellas aparezca de manera vertical veis tecla 00:22:01
entrada tecla entrada etcétera 00:22:06
Idioma/s:
es
Materias:
Informática
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado básico
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado medio
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado superior
      • Primer Curso
      • Segundo Curso
Autor/es:
Francisco José González Constanza
Subido por:
Francisco J. G.
Licencia:
Todos los derechos reservados
Visualizaciones:
3
Fecha:
17 de diciembre de 2025 - 21:51
Visibilidad:
Público
Centro:
IES CIFP a Distancia Ignacio Ellacuría
Duración:
22′ 17″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
427.57 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid