1
00:00:00,000 --> 00:00:09,400
y buenas tardes tengo otro esquema aquí con un elemento nuevo que sería este de aquí este

2
00:00:09,400 --> 00:00:18,280
elemento es el keypad o lo que se podría llamar el teclado matricial 4x4 de arduino para el

3
00:00:18,280 --> 00:00:23,399
siguiente esquema en tinker cat vamos a usar un teclado matricial 4x4 un comento muy habitual en

4
00:00:23,399 --> 00:00:29,719
proyectos de seguridad control de accesos domótica y sistemas interactivos el teclado tiene 16 teclas

5
00:00:29,719 --> 00:00:34,619
organizadas en cuatro filas y cuatro columnas, lo que permite a Arduino detectar qué tecla se

6
00:00:34,619 --> 00:00:42,500
pulsa usando sólo ocho pines digitales en vez de 16. ¿Cómo funciona este teclado 4x4? El

7
00:00:42,500 --> 00:00:47,460
teclado no envía números directamente, internamente funciona como una matriz de interruptores. Cada

8
00:00:47,460 --> 00:00:55,520
tecla conecta una fila con una columna. Arduino activa las columnas una a una, lee qué fila recibe

9
00:00:55,520 --> 00:01:01,460
señal y con esa combinación sabe qué tecla se ha pulsado. Ejemplo, columna 4, que sería esta de aquí,

10
00:01:02,320 --> 00:01:13,180
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í

11
00:01:13,180 --> 00:01:19,500
sucesivamente. Está formado este componente con ocho pines, que serían estos de aquí, y que van

12
00:01:19,500 --> 00:01:24,980
en orden, van fila 1, fila 2, fila 3 y fila 4 y luego columna 1, columna 2, columna 3

13
00:01:24,980 --> 00:01:36,659
y columna 4. ¿Qué sucederá? Fijaos, he puesto para la fila 1 el pin 2, para la fila 2 el

14
00:01:36,659 --> 00:01:42,859
3, el 4 y el 5. Se han conectado cada uno a un pin y van en ese orden las filas del

15
00:01:42,859 --> 00:01:51,879
2 al 5. Mientras que en las columnas, desde la columna 1 va desde el 8, 9, 10 y 11. Con lo cual

16
00:01:51,879 --> 00:01:57,819
tendríamos que hemos usado para las filas los pines digitales 2, 3, 4 y 5 y para las columnas

17
00:01:57,819 --> 00:02:07,719
el 8, 9, 10 y 11. Bien, no voy a hacer el circuito porque es bastante fácil, no es nada más que

18
00:02:07,719 --> 00:02:11,819
llevar los cables a cada uno de los pines y ponerlos en orden. Entonces lo que nos vamos a

19
00:02:11,819 --> 00:02:17,259
fijar bueno primero voy a dar a iniciar para que veamos qué es lo que hace el código el código lo

20
00:02:17,259 --> 00:02:26,659
que va a hacer es ya veis aquí en el monitor en serie me aparece keypad 4x4 listo y pulsa las

21
00:02:26,659 --> 00:02:31,819
teclas asterisco para borrar y esta otra para mostrar y limpiar entonces yo lo que voy a ir

22
00:02:31,819 --> 00:02:38,960
dando esas teclas y veis me va acumulando esas teclas generando una cadena una vez que la quiero

23
00:02:38,960 --> 00:02:45,680
confirmar le doy a confirmar y me confirma esa enumeración si le quiero borrar le doy a borrado

24
00:02:45,680 --> 00:02:50,780
aquí y puedo seguir escribiendo de nuevo básicamente eso es lo que haría el programa

25
00:02:50,780 --> 00:02:57,840
el código que aparece aquí voy a quitar el monitor para que se vea el programa es este

26
00:02:57,840 --> 00:03:06,680
que aparece aquí lo tengo aquí antes que nada os voy a repasar lo que es el keypad 4x4 y veis

27
00:03:06,680 --> 00:03:13,939
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

28
00:03:13,939 --> 00:03:19,139
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í

29
00:03:19,139 --> 00:03:26,960
los 8 pines qué sucede con respecto al código vamos a empezar con la primera línea de código

30
00:03:26,960 --> 00:03:35,659
que sería esta de aquí la agrandamos y qué es lo que vemos vamos a ver que primero lo que hace es

31
00:03:35,659 --> 00:03:44,580
va a incluir una librería que sería kpad.h.

32
00:03:44,699 --> 00:03:49,680
Necesitaremos esta librería para poder hacer el código

33
00:03:49,680 --> 00:03:51,520
y utilizar los métodos de kpad.

34
00:03:52,159 --> 00:03:56,439
A continuación ha creado dos constantes de tipo byte

35
00:03:56,439 --> 00:04:01,539
en el que uno será filas, que tiene un valor inicial de 0,

36
00:04:01,639 --> 00:04:05,479
y otro es que sea columns, que sea columnas, que es un valor de 4.

37
00:04:05,659 --> 00:04:25,199
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.

38
00:04:25,199 --> 00:04:31,759
¿Veis? Esta sería la primera fila y esta la segunda, la tercera y la cuarta

39
00:04:31,759 --> 00:04:34,680
En el mismo orden que aparecen en el keypad

40
00:04:34,680 --> 00:04:38,379
Si nos miramos el keypad, aparecen en el mismo orden

41
00:04:38,379 --> 00:04:40,220
1, 2, 3, 3A

42
00:04:40,220 --> 00:04:43,459
¿Veis? En la primera fila, la segunda, la tercera y la cuarta

43
00:04:43,459 --> 00:04:44,879
Y estas serían las columnas

44
00:04:44,879 --> 00:04:51,040
Y genera esa matiz bidimensional para luego poder utilizarla

45
00:04:51,040 --> 00:04:52,120
Ya lo veremos para aquí

46
00:04:52,120 --> 00:04:54,560
Vamos a ver la primera que era esta de aquí

47
00:04:54,560 --> 00:05:21,959
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.

48
00:05:21,959 --> 00:05:32,959
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.

49
00:05:33,819 --> 00:05:43,879
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.

50
00:05:43,879 --> 00:05:58,459
¿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.

51
00:05:58,459 --> 00:06:10,459
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.

52
00:06:10,459 --> 00:06:29,800
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.

53
00:06:29,800 --> 00:06:56,100
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.

54
00:06:56,100 --> 00:07:09,000
Las teclas las hemos visto aquí, las teclas serían, cuando aquí ponemos teclas, se está refiriendo a la matriz bidimensional, que es aquí.

55
00:07:09,720 --> 00:07:20,860
Entonces, lo que está haciendo este Make Keep Map es asociar toda esta matriz bidimensional con estas unidimensionales.

56
00:07:20,860 --> 00:07:44,639
¿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,

57
00:07:44,639 --> 00:07:49,279
A la fila 3 le está asignando el 4 y a la fila 4 le está asignando el 5.

58
00:07:49,819 --> 00:07:56,699
Y a su vez, veis que aquí he puesto pines filas y luego la otra parte será la de pines columnas.

59
00:07:57,800 --> 00:08:05,480
Entonces se está asociando a la raíz de pines columnas, le está asociando que el 8 corresponde a esta columna,

60
00:08:05,939 --> 00:08:13,199
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.

61
00:08:13,199 --> 00:08:24,439
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.

62
00:08:24,439 --> 00:08:54,419
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.

63
00:08:54,440 --> 00:08:59,000
de variables como sabemos que son filas lo hemos puesto como una constante y vale 4 y

64
00:08:59,000 --> 00:09:08,480
columnas vale 4 valdría lo mismo poner un 4 aquí en 4 aquí entonces necesita de esta línea en

65
00:09:08,480 --> 00:09:18,019
nuestro objeto keypad para generarlo continuación nos queda una variable de tipo string en el que

66
00:09:18,019 --> 00:09:20,059
va a ser, va a contener una cadena

67
00:09:20,059 --> 00:09:21,580
y que en principio está vacía

68
00:09:21,580 --> 00:09:24,220
la tercera parte del código

69
00:09:24,220 --> 00:09:25,980
sería el

70
00:09:25,980 --> 00:09:28,200
voice setup, en el que lo único

71
00:09:28,200 --> 00:09:30,039
que hace es que aquí inicializa

72
00:09:30,039 --> 00:09:33,820
el monitor en serie

73
00:09:33,820 --> 00:09:35,639
esto ya lo hemos visto en otros vídeos

74
00:09:35,639 --> 00:09:37,299
y luego pues imprime

75
00:09:37,299 --> 00:09:39,799
la cabecera de ese monitor en serie

76
00:09:39,799 --> 00:09:41,940
que aparecerá nada más arrancar

77
00:09:41,940 --> 00:09:44,279
keypad 4x4 listo, pulsa teclas

78
00:09:44,279 --> 00:09:46,259
y otra línea en el que

79
00:09:46,259 --> 00:09:47,860
ponga asterisco borrar y

80
00:09:47,860 --> 00:09:55,360
mostrar y limpiar y por último nos quedaría la parte del loop que sería esta de aquí entonces

81
00:09:55,360 --> 00:10:01,539
en el loop también se crea otra variable que se llamaría tecla y utiliza un método que se

82
00:10:01,539 --> 00:10:08,559
llama un get key cuando a nuestro objeto keypad que lo hemos generado arriba le aplicamos el

83
00:10:08,559 --> 00:10:17,500
método get key nos está indicando que carácter qué carácter estamos clickeando ese carácter

84
00:10:17,500 --> 00:10:22,440
será almacenado en una variable

85
00:10:22,440 --> 00:10:25,200
de tipo char, que será variable tecla.

86
00:10:26,340 --> 00:10:29,679
A continuación lo que va a hacer es comparar ese carácter

87
00:10:29,679 --> 00:10:33,019
a ver si se corresponde con el asterisco, se corresponde con

88
00:10:33,019 --> 00:10:37,860
la tecla de hashtag o se corresponde con cualquier otra tecla.

89
00:10:38,440 --> 00:10:42,259
Si se corresponde con el asterisco, veis aquí que establece la igualdad

90
00:10:42,259 --> 00:10:45,259
a través de un condicional. Primero nos dice que si tecla

91
00:10:45,259 --> 00:10:49,279
si tecla existe, si se ha pulsado alguna tecla

92
00:10:49,279 --> 00:10:53,139
entonces entre en todo este condicional. El condicional

93
00:10:53,139 --> 00:10:57,059
va desde aquí, desde esta llave hasta esta otra llave. A su vez

94
00:10:57,059 --> 00:11:01,059
dentro va a hacer otra condición a través de otro if y va a compararlo

95
00:11:01,059 --> 00:11:03,600
con el asterisco. ¿Por qué? Porque si el asterisco

96
00:11:03,600 --> 00:11:09,080
si la tecla que ha pulsado es un asterisco lo que queremos es que borre. Entonces nos dice

97
00:11:09,080 --> 00:11:13,000
que entrada está vacía. Entrada es lo que luego va a mostrar en el

98
00:11:13,000 --> 00:11:17,120
monitoreo en serie. Y lo que hace es que en el monitoreo en serie

99
00:11:17,120 --> 00:11:20,820
imprime borrado y sale del

100
00:11:20,820 --> 00:11:24,299
con este return, saldrá de todo este if

101
00:11:24,299 --> 00:11:28,940
y leerá el siguiente. ¿Qué sucede si

102
00:11:28,940 --> 00:11:33,080
pulsas esta otra tecla? Si coincide y la tecla

103
00:11:33,080 --> 00:11:37,039
que ha pulsado es esta, entonces escribe en el monitoreo en serie confirmado

104
00:11:37,039 --> 00:11:40,740
y muestra el valor de la variable entrada

105
00:11:40,740 --> 00:11:46,870
Y a su vez también da un return y sale de él.

106
00:11:47,149 --> 00:11:50,870
Por último, guardar y mostrar a la tecla pulsada, ¿qué es lo que va haciendo?

107
00:11:50,990 --> 00:11:59,429
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.

108
00:12:00,009 --> 00:12:06,509
Esas teclas se van obteniendo desde el keypad.getkey y las va acumulando dentro de entrada.

109
00:12:06,509 --> 00:12:21,309
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.

110
00:12:21,309 --> 00:12:37,100
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.

111
00:12:39,000 --> 00:12:50,500
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.

112
00:12:50,500 --> 00:13:02,039
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.

113
00:13:02,500 --> 00:13:07,120
Entonces, primero pone la tecla que hemos dado y luego en la entrada pone lo que se va acumulando.

114
00:13:07,960 --> 00:13:16,279
Si yo voy aquí y borro, ¿veis? Borrado, ya nuestro valor de la entrada se quedaría vacío.

115
00:13:16,279 --> 00:13:24,080
lo hemos visto aquí aquí cuando le doy al asterisco lo que hace es que lo borra y entrada

116
00:13:24,080 --> 00:13:32,500
la deja vacía la vez en cambio cuando yo le voy dando teclas las 5 las 7 las va acumulando dentro

117
00:13:32,500 --> 00:13:38,259
de entrada y cuando ya lo confirmamos pues se quedaría ese valor continuación si escribo

118
00:13:38,259 --> 00:13:45,000
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

119
00:13:45,000 --> 00:13:59,429
haciendo de manera continua por tanto como repaso tenemos vamos a detenerlo y

120
00:13:59,429 --> 00:14:05,250
vamos a comentar el código esto lo bajamos y tenemos primero

121
00:14:05,250 --> 00:14:13,389
lo primero que hace es incluir la librería

122
00:14:13,389 --> 00:14:17,289
keypad porque luego tendremos que hacer crear un

123
00:14:17,289 --> 00:14:33,240
objeto keypad. Aquí lo que hace es crear dos constantes que serían filas con un

124
00:14:33,240 --> 00:14:42,039
valor de 4 y cols con un valor de 4. Podríamos haber ahorrado estas dos líneas y

125
00:14:42,039 --> 00:14:48,600
sencillamente como aparece únicamente filas y columnas haber puesto un 4 aquí

126
00:14:48,600 --> 00:14:55,539
y había puesto un 4 aquí, pero lo hacemos con una variable para poder, si nosotros queremos cambiar, por ejemplo,

127
00:14:55,860 --> 00:15:04,700
imaginaos que queremos cambiar el tamaño del array bidimensional, pues tendríamos que quitar en todos los lugares

128
00:15:04,700 --> 00:15:08,940
donde aparezcan filas y columnas, tendríamos que quitar el 4 y poner por el nuevo valor.

129
00:15:09,379 --> 00:15:14,840
En cambio, al utilizar dos constantes, solo habría que cambiarlo en la parte de arriba.

130
00:15:14,840 --> 00:15:19,440
Por eso se utilizan siempre constantes y variables para determinar determinados valores.

131
00:15:20,059 --> 00:15:34,230
A continuación, aquí tenemos el crea una matriz bidimensional de 4x4.

132
00:15:34,950 --> 00:15:39,409
Esa matriz que va a tener, concretamente lo que tiene, la matriz se llama teclas,

133
00:15:40,009 --> 00:15:47,460
y será una matriz de 4 filas por 4 columnas de caracteres.

134
00:15:47,460 --> 00:16:00,049
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.

135
00:16:01,250 --> 00:16:19,389
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.

136
00:16:19,409 --> 00:16:38,960
Estos serían dos arrays unidimensionales con los pines de las filas y de las columnas.

137
00:16:38,960 --> 00:17:12,119
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,

138
00:17:12,119 --> 00:17:16,460
o realmente no, es el constructor de Kpad

139
00:17:16,460 --> 00:17:20,480
en el que ese constructor necesita de dos, cuatro o cinco parámetros.

140
00:17:20,880 --> 00:17:25,460
Esos cinco parámetros están formados, el primero, por la función makeKeyMap.

141
00:17:26,019 --> 00:17:30,960
Es un map que lo que va a hacer es asociar la red bidimensional de teclas,

142
00:17:31,279 --> 00:17:32,339
que serían todas estas,

143
00:17:33,079 --> 00:17:36,779
la va a asociar con los pines de las filas,

144
00:17:37,279 --> 00:17:38,680
con los pines de las columnas

145
00:17:38,680 --> 00:17:43,339
y luego posteriormente indica cuántas filas y columnas hay, que sería 4 y 4.

146
00:17:43,960 --> 00:17:49,539
Entonces está asociando esta MakeKeyMap, asocia toda esta matriz bidimensional.

147
00:17:50,299 --> 00:17:58,430
¿Cómo? Pues asocia a esta fila, le asocia el valor del pin 2.

148
00:17:58,430 --> 00:18:03,049
A esta otra fila, el 3. A esta otra fila, el 4. Y a esta otra fila, el 5.

149
00:18:03,509 --> 00:18:08,309
Y a su vez las columnas, esta columna está asociada al 8, esta columna la asocia al 9,

150
00:18:08,309 --> 00:18:10,869
esta al 10 y esta al 11

151
00:18:10,869 --> 00:18:14,970
de tal manera que estamos indicando que ese objeto keypad

152
00:18:14,970 --> 00:18:20,289
tiene ya una serie de teclas que sea un 4x4

153
00:18:20,289 --> 00:18:24,789
y indica que pines tiene asociado a cada una de las filas y columnas

154
00:18:24,789 --> 00:18:29,029
para saber en ese objeto keypad donde está cada una de las teclas

155
00:18:29,029 --> 00:18:34,049
porque si os acordáis habíamos definido que para determinar una terminal tecla

156
00:18:34,049 --> 00:18:41,250
estaba asociado con el cruce que se obtenía entre su fila y su columna.

157
00:18:43,730 --> 00:19:02,009
Posteriormente crea una variable string que contiene la entrada,

158
00:19:04,180 --> 00:19:06,940
lo que vamos añadiendo y que se va a ir acumulando.

159
00:19:06,940 --> 00:19:18,460
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.

160
00:19:19,079 --> 00:19:28,579
Y ya pasamos al loop. En el loop aquí tenemos una línea que sería para saber qué tecla se está apretando.

161
00:19:28,579 --> 00:19:37,460
el keypad o el getKey o método getKey de keypad lo que nos va a dar es qué tecla se está apretando

162
00:19:37,460 --> 00:20:00,309
en ese momento por tanto almacena la tecla que se está clickeando en ese momento bien a continuación

163
00:20:00,309 --> 00:20:17,170
aquí nos van a aparecer una serie de condicionales, un condicional, condicionales para saber qué tecla es pulsada.

164
00:20:18,789 --> 00:20:21,890
En un principio, si pulsas el asterisco, ¿qué es lo que sucede?

165
00:20:22,109 --> 00:20:25,829
Pues lógicamente, como queremos que el asterisco, al pulsarlo, nos borre la cadena,

166
00:20:25,829 --> 00:20:32,690
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.

167
00:20:33,269 --> 00:20:37,829
Y procedería al RETRUM para salir del condicional.

168
00:20:38,829 --> 00:20:43,049
Posteriormente, si es esta otra tecla, ya hemos dicho que es para confirmarlo.

169
00:20:43,950 --> 00:20:50,069
Al confirmarlo, imprime la cadena de entrada, ¿veis? En el monitor en serie la imprime

170
00:20:50,069 --> 00:20:57,769
y a continuación la vuelve a vaciar para que podamos acumular una nueva entrada y sale del condicional.

171
00:20:58,529 --> 00:21:03,210
Y por último tenemos aquí la actualización guarda y muestra la tecla pulsada.

172
00:21:03,210 --> 00:21:13,650
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.

173
00:21:13,650 --> 00:21:25,769
Esto sería lo mismo que entrada igual a entrada más tecla.

174
00:21:27,109 --> 00:21:36,990
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.

175
00:21:37,210 --> 00:21:42,769
Si luego añado el 9, pues al 8 le pondría a continuación en la cadena el 9 y así sucesivamente.

176
00:21:43,650 --> 00:21:49,029
y última y lo último pues sería pues que imprime pues la entrada la tecla y

177
00:21:49,029 --> 00:21:54,769
la entrada de manera horizontal y por cada una de las

178
00:21:54,769 --> 00:22:01,450
por cada una de las entradas pues irá gracias a este println o retorno de

179
00:22:01,450 --> 00:22:06,269
carro hará que cada una de ellas aparezca de manera vertical veis tecla

180
00:22:06,269 --> 00:22:14,420
entrada tecla entrada etcétera