0
00:00:00,000 --> 00:00:04,000
Hola, muy buenas. La práctica de hoy se llama pulsadores con clase y en ella

1
00:00:04,000 --> 00:00:09,000
exploraremos nuevas características de los pulsadores y a la vez aprenderemos

2
00:00:09,000 --> 00:00:13,000
nuevos elementos de programación. Pero antes de explicar detalladamente en qué

3
00:00:13,000 --> 00:00:17,000
consiste esta práctica voy a hacer unas cuestiones sobre la práctica anterior

4
00:00:17,000 --> 00:00:21,000
de pulsadores. Para ello entraré en Tinkercad, en la práctica que tenemos de

5
00:00:21,000 --> 00:00:27,000
pulsadores. Aquí la tenemos. En esta práctica por defecto el led primero

6
00:00:27,000 --> 00:00:31,000
aparece apagado y cuando pulsamos se enciende, mientras que en los dos

7
00:00:31,000 --> 00:00:36,000
anteriores funciona justamente el revés. Están encendidos por defecto y si

8
00:00:36,000 --> 00:00:40,000
pulsamos se apaga. La cuestión es la siguiente. ¿Podemos modificar el código

9
00:00:40,000 --> 00:00:44,000
para que el tercer pulsador funcione como el primero? La respuesta obviamente

10
00:00:44,000 --> 00:00:48,000
es sí. Vamos a verlo. Vamos a hacer el texto más grande y fijaros, nos vamos a

11
00:00:48,000 --> 00:00:53,000
centrar en el tercer pulsador, este de aquí abajo. Una solución posible es

12
00:00:53,000 --> 00:00:57,000
crearnos una función que devuelva el valor adecuado del pulsador. En este caso

13
00:00:57,000 --> 00:01:01,000
esta función, a diferencia de todas las que nos hemos hecho anteriormente, va a

14
00:01:01,000 --> 00:01:06,000
devolver un dato de tipo entero. Por eso la primera palabra que ponemos es int.

15
00:01:06,000 --> 00:01:10,000
A continuación pondremos el nombre de la función. Yo le voy a dar el nombre leerPulsador.

16
00:01:10,000 --> 00:01:15,000
Esta función va a necesitar un parámetro de tipo entero que es el

17
00:01:15,000 --> 00:01:20,000
pin del pulsador que vamos a leer y como siempre lo que haga la función lo

18
00:01:20,000 --> 00:01:23,000
pondremos entre llaves. Vamos a aprovechar esta línea de código que

19
00:01:23,000 --> 00:01:27,000
tenemos aquí y nos la vamos a llevar aquí dentro de la función. Lo único que

20
00:01:27,000 --> 00:01:32,000
cambiamos este pinPulsa, que aquí no tiene sentido, por pinPulsador. A

21
00:01:32,000 --> 00:01:36,000
continuación miraremos el nivel de ese valor. Si el pin resulta que está a nivel

22
00:01:36,000 --> 00:01:42,000
alto entonces nosotros devolveremos un valor bajo y si está a nivel bajo

23
00:01:42,000 --> 00:01:47,000
nosotros devolveremos un valor alto. Esto lo podemos hacer con una estructura de

24
00:01:47,000 --> 00:01:53,000
programación, el famoso if en inglés. Para realizar un código condicional en C

25
00:01:53,000 --> 00:01:57,000
tendremos que utilizar la palabra reservada if y entre paréntesis poner la

26
00:01:57,000 --> 00:02:02,000
condición. En este caso preguntaremos si val es igual a high. Fijaros que el

27
00:02:02,000 --> 00:02:06,000
operador de comparación no es un igual sino dos iguales juntos. Esto es muy

28
00:02:06,000 --> 00:02:10,000
importante. Si el valor es alto la función tendrá que devolver un valor

29
00:02:10,000 --> 00:02:15,000
bajo y esto se hace con la sentencia return. Fijaros que esta estructura es

30
00:02:15,000 --> 00:02:20,000
muy parecida al bucle while que ya empleamos en otra práctica. Mientras se

31
00:02:20,000 --> 00:02:24,000
cumpla la condición se haría lo de dentro. En este caso si lo de dentro sólo

32
00:02:24,000 --> 00:02:28,000
se tiene que hacer una vez se pone if. Si se cumple la condición se hace lo de

33
00:02:28,000 --> 00:02:33,000
dentro. La sentencia return devuelve el valor de la función y termina la

34
00:02:33,000 --> 00:02:38,000
función. Aunque hubiera cosas por detrás si se ejecuta esta línea se acaba la

35
00:02:38,000 --> 00:02:42,000
función y se devolvería lo. ¿Y qué pasa si en lugar de estar a nivel alto está a

36
00:02:42,000 --> 00:02:46,000
nivel bajo? Es decir si es el otro valor posible de los dos que tenemos. Pondríamos

37
00:02:46,000 --> 00:02:52,000
la palabra else y dentro de else return high. En definitiva juntas leemos el

38
00:02:52,000 --> 00:02:55,000
valor. Si ese valor está a nivel alto nosotros decimos que lo ponga a nivel

39
00:02:55,000 --> 00:02:59,000
bajo y si no que lo ponga a nivel alto. Bueno y ahora tendríamos que venir a

40
00:02:59,000 --> 00:03:04,000
nuestro programa principal y decir que la variable val va a valer lo que nos

41
00:03:04,000 --> 00:03:10,000
diga la función leerPulsador y en este caso el parámetro que le tenemos que

42
00:03:10,000 --> 00:03:17,000
poner aquí es el pinPulsa. Si ejecutamos ahora vemos como por

43
00:03:17,000 --> 00:03:21,000
defecto está apagado el led y sólo se enciende cuando pulsamos tal y como

44
00:03:21,000 --> 00:03:25,000
queríamos. Bien en este ejemplo podemos ver cómo podemos modificar el

45
00:03:25,000 --> 00:03:28,000
comportamiento de un circuito a través de software de una manera relativamente

46
00:03:28,000 --> 00:03:33,000
sencilla. Ahora la pregunta que os voy a hacer es ¿yo podría hacer el botón que

47
00:03:33,000 --> 00:03:38,000
cuando pulso una vez se encienda y aunque suelte se quede encendido cuando

48
00:03:38,000 --> 00:03:42,000
pulse la siguiente vez se apague y así sucesivamente? Pues sí claro que lo

49
00:03:42,000 --> 00:03:46,000
podríamos hacer pero ojo aquí hay que tener en cuenta varias cosas. Una

50
00:03:46,000 --> 00:03:50,000
realmente las actuaciones serían cuando pasa de un nivel alto a un nivel bajo y

51
00:03:50,000 --> 00:03:54,000
eso lo tendríamos que hacer almacenando el valor anterior en una variable y

52
00:03:54,000 --> 00:03:58,000
comprobando si ha cambiado y luego tendríamos que tener otra variable para

53
00:03:58,000 --> 00:04:02,000
el estado que queremos del led si encendido o apagado. Aquí vemos que esto

54
00:04:02,000 --> 00:04:05,000
se nos empieza a complicar y tendríamos que tener múltiples variables para

55
00:04:05,000 --> 00:04:10,000
controlar el estado del pulsador y si yo ahora os pregunto ¿y si quisiera tener un

56
00:04:10,000 --> 00:04:14,000
pulsador de tal manera que sólo se enciende el led cuando lo mantengo

57
00:04:14,000 --> 00:04:17,000
pulsado tres segundos? ¿se podría hacer? Pues también pero otra vez de nuevo

58
00:04:17,000 --> 00:04:21,000
tendríamos que tener una serie de variables para controlar el estado del

59
00:04:21,000 --> 00:04:25,000
pulsador, ir contando el tiempo que va pasando desde que pulsamos la primera

60
00:04:25,000 --> 00:04:29,000
vez, etcétera, etcétera. Como vemos todo esto se complica simplemente para un

61
00:04:29,000 --> 00:04:34,000
pulsador pero afortunadamente hoy vamos a ver que hay una serie de técnicas que

62
00:04:34,000 --> 00:04:38,000
me permite manejar un pulsador o cualquier otro elemento del circuito

63
00:04:38,000 --> 00:04:42,000
gracias al trabajo que han hecho otras personas previamente. Ahora presta

64
00:04:42,000 --> 00:04:45,000
atención porque para realizar esta práctica tendrás que hacer lo siguiente

65
00:04:45,000 --> 00:04:51,000
En este Tinkercad yo he entrado como un alumno más de una clase. Para esta

66
00:04:51,000 --> 00:04:55,000
práctica tendré que venirme aquí a clases

67
00:04:55,000 --> 00:05:02,000
entrar en la clase en la que estoy registrado, pinchar en la práctica

68
00:05:02,000 --> 00:05:07,000
correspondiente y pulsar en este botón para copiar el proyecto que me ha dejado

69
00:05:07,000 --> 00:05:11,000
ya el profesor. A continuación le voy a poner un nombre adecuado quitándole el

70
00:05:11,000 --> 00:05:16,000
de copy off. Lo dejamos con pulsadores con clase. Al igual que el resto de las

71
00:05:16,000 --> 00:05:20,000
prácticas si lo estáis haciendo con un compañero poner el nombre de las dos

72
00:05:20,000 --> 00:05:25,000
personas que lo estáis haciendo y no olvidéis de dar a intro. Ahora vamos a

73
00:05:25,000 --> 00:05:29,000
ver el código. Lo primero que nos llama la atención es que hay muchísimas líneas

74
00:05:29,000 --> 00:05:34,000
escritas. Estas líneas de código nos van a permitir programar con una

75
00:05:34,000 --> 00:05:38,000
metodología que se conoce como programación orientada a objetos. Con

76
00:05:38,000 --> 00:05:42,000
esta metodología se pretende tener componentes de código que se pueden

77
00:05:42,000 --> 00:05:48,000
manipular como si fuera un objeto. Voy a poner un ejemplo. Si yo tuviera un

78
00:05:48,000 --> 00:05:53,000
componente de código para simular un coche puedo esperar de ese componente, de

79
00:05:53,000 --> 00:05:57,000
ese objeto, que tenga una serie de propiedades como por ejemplo el color

80
00:05:57,000 --> 00:06:02,000
como por ejemplo el número de puertas y una serie de métodos es decir de

81
00:06:02,000 --> 00:06:08,000
funciones como acelerar, frenar, girar a la izquierda, girar a la derecha, dar

82
00:06:08,000 --> 00:06:14,000
marcha atrás. A continuación vamos a ver cómo podemos aplicar esta metodología a

83
00:06:14,000 --> 00:06:19,000
este ejemplo concreto. Pues bien todo lo que tenemos desde esta línea para arriba

84
00:06:19,000 --> 00:06:24,000
es el código necesario para poder tener objetos que simulen un pulsador. Todos

85
00:06:24,000 --> 00:06:30,000
esos objetos van a pertenecer a la clase Button. Os adelanto que en la mayoría de

86
00:06:30,000 --> 00:06:34,000
las aplicaciones ni siquiera llegamos a ver el código de la clase. Cuando

87
00:06:34,000 --> 00:06:38,000
utilicemos directamente Arduino todo esto no lo veremos. Irá puesto en un

88
00:06:38,000 --> 00:06:43,000
fichero aparte y no estará dentro de nuestro programa principal. Tinkercad es

89
00:06:43,000 --> 00:06:47,000
una plataforma de simulación de Arduino muy buena pero tiene un pequeño fallo.

90
00:06:47,000 --> 00:06:51,000
Hay clases que sí que puedo utilizar, esto lo hacemos aquí en las bibliotecas,

91
00:06:51,000 --> 00:06:56,000
sin necesidad de incluir el código dentro del programa principal. Pero hay

92
00:06:56,000 --> 00:07:01,000
otras clases que no podemos utilizar en forma de librerías independientes sino

93
00:07:01,000 --> 00:07:06,000
que tenemos que incrustar el código dentro del programa principal. En

94
00:07:06,000 --> 00:07:10,000
cualquier caso yo lo que he hecho ha sido poner todo el código, lo he copiado de

95
00:07:10,000 --> 00:07:15,000
alguien que lo ha hecho y a continuación pues empezará nuestra aplicación que es

96
00:07:15,000 --> 00:07:20,000
donde nos tenemos que preocupar. Pues bien vamos a ver cómo programaríamos esto.

97
00:07:20,000 --> 00:07:25,000
Para los LEDs tendremos que crearnos una variable como siempre pinLEDIZQ

98
00:07:25,000 --> 00:07:31,000
de izquierda y le asignamos el valor 11 que es al que está conectado el LED y

99
00:07:31,000 --> 00:07:36,000
ahora para nuestro pulsador de la izquierda nos crearemos un objeto de

100
00:07:36,000 --> 00:07:41,000
tipo Button y eso se hace poniendo el tipo de datos, que no es nada más que la

101
00:07:41,000 --> 00:07:47,000
clase, el nombre que le queremos dar al objeto, por ejemplo ButtonIZQ y

102
00:07:47,000 --> 00:07:51,000
llamando al constructor de la clase. El constructor de una clase no es nada más

103
00:07:51,000 --> 00:07:56,000
que una función especial que se emplea cuando se crea el objeto. En el

104
00:07:56,000 --> 00:08:00,000
constructor de la clase Button podemos utilizar tres parámetros. El primer

105
00:08:00,000 --> 00:08:06,000
parámetro es el pin al que tenemos asociado nuestro pulsador, en este caso

106
00:08:06,000 --> 00:08:11,000
sería el 12. El segundo parámetro que necesita este constructor es el estado

107
00:08:11,000 --> 00:08:16,000
en el que está el pulsador cuando pulsamos, en este caso sería high, es

108
00:08:16,000 --> 00:08:21,000
decir, cuando yo aprieto el pulsador el valor que se lee es alto. Y admite un

109
00:08:21,000 --> 00:08:24,000
tercer parámetro que es opcional que hace referencia a si estamos utilizando

110
00:08:24,000 --> 00:08:29,000
o no la resistencia de pull-up que nos pone Arduino. En este caso como no la

111
00:08:29,000 --> 00:08:34,000
estamos utilizando lo podemos dejar sin poner. Ahora en el setup tenemos que

112
00:08:34,000 --> 00:08:40,000
utilizar la función pinMode para indicar que el pin del LED izquierdo se utiliza

113
00:08:40,000 --> 00:08:46,000
en modo salida. Con el pin que utilizamos para el objeto ButtonIZQ no

114
00:08:46,000 --> 00:08:50,000
es necesario inicializarlo puesto que se encarga de hacerlo el constructor. Yo

115
00:08:50,000 --> 00:08:55,000
todo esto lo sé porque quien ha hecho todo este código, la clase para poder

116
00:08:55,000 --> 00:09:00,000
utilizar el objeto, ha escrito una pequeña referencia indicando cómo

117
00:09:00,000 --> 00:09:05,000
utilizar este código. Bien, volvamos al código. Ya hemos inicializado tanto el

118
00:09:05,000 --> 00:09:10,000
LED como el objeto para el pulsador izquierdo. Ahora vamos a ver cómo podemos

119
00:09:10,000 --> 00:09:17,000
emplearlo. Si volvemos a la referencia de la clase Button podremos ver que hay que

120
00:09:17,000 --> 00:09:22,000
llamar a la función listen y esto lo hacemos poniendo el nombre del objeto

121
00:09:22,000 --> 00:09:28,000
punto y ahora el nombre del método que no deja de ser una función del objeto

122
00:09:28,000 --> 00:09:33,000
que es listen. De esta manera internamente el objeto va a ver en qué

123
00:09:33,000 --> 00:09:38,000
estado se encuentra el botón. Ahora podemos utilizar la función isPress del

124
00:09:38,000 --> 00:09:43,000
objeto ButtonIZQ que nos dice si el pulsador se encuentra presionado o no.

125
00:09:43,000 --> 00:09:49,000
Esta función devuelve true en caso de ser verdadero o false en caso de ser

126
00:09:49,000 --> 00:09:54,000
falso y esto lo podemos utilizar dentro de una estructura de tipo if para

127
00:09:54,000 --> 00:09:59,000
realizar una acción u otra. Vamos a verlo con un ejemplo. If, entre paréntesis,

128
00:09:59,000 --> 00:10:06,000
ponemos el resultado de la instrucción. En este caso será ButtonIZQ.isPress.

129
00:10:06,000 --> 00:10:13,000
Si esto es verdadero escribiremos sobre el pin del LED

130
00:10:13,000 --> 00:10:21,000
el valor de alto y si no, y eso lo hacemos con la sentencia else, escribiremos el

131
00:10:21,000 --> 00:10:23,000
valor de bajo.

132
00:10:24,000 --> 00:10:27,000
Vamos a probarlo.

133
00:10:27,000 --> 00:10:32,000
Fenomenal, aquí lo tenemos. Bueno, esto que es tan sencillo y bastante intuitivo

134
00:10:32,000 --> 00:10:36,000
vemos que ocupa varias líneas. Podemos conseguir reducir el número de líneas

135
00:10:36,000 --> 00:10:42,000
utilizando el operador ternario del lenguaje de programación C. Este operador

136
00:10:42,000 --> 00:10:47,000
sirve para asignar un valor a una variable en función de si se cumple una

137
00:10:47,000 --> 00:10:51,000
condición o no. Vamos a verlo con un ejemplo. Nos vamos a crear una variable

138
00:10:51,000 --> 00:10:56,000
que la vamos a llamar PALIZQ. A continuación ponemos el igual y ahora

139
00:10:56,000 --> 00:11:01,000
utilizamos el método de antes para preguntar si está presionado. A

140
00:11:01,000 --> 00:11:05,000
continuación una interrogación y el valor que queremos asignar a la variable

141
00:11:05,000 --> 00:11:10,000
en caso de ser verdadero lo anterior. Seguido de dos puntos y el valor que

142
00:11:10,000 --> 00:11:14,000
queremos asignar a la variable en caso de que sea falso lo anterior. Y por último

143
00:11:14,000 --> 00:11:20,000
el punto y coma, no se nos puede olvidar. Y ahora vamos a utilizar esta función

144
00:11:20,000 --> 00:11:26,000
de aquí, DIGITALWRITE, y le vamos a asignar el valor de la variable. Por último

145
00:11:26,000 --> 00:11:32,000
elimino todo esto, que ya no necesitamos. Vamos a probar cómo funciona.

146
00:11:32,000 --> 00:11:38,000
Vemos que efectivamente hace lo que nosotros queremos. Bueno, a lo mejor para

147
00:11:38,000 --> 00:11:42,000
conseguir este efecto no necesitábamos realmente la clase. ¿Pero qué pasa si, por

148
00:11:42,000 --> 00:11:47,000
ejemplo, queremos encender o apagar el LED alternativamente cada vez que hago

149
00:11:47,000 --> 00:11:52,000
una pulsación sobre el pulsador? Pues bien, este objeto tiene un método que se

150
00:11:52,000 --> 00:11:57,000
llama ONPRESSASTAGAL que me hace este trabajo. Fijaros que lo único que he

151
00:11:57,000 --> 00:12:01,000
hecho ha sido sustituir el nombre del método anterior por este nuevo. Vamos a

152
00:12:01,000 --> 00:12:04,000
ver cómo funciona.

153
00:12:04,000 --> 00:12:09,000
Cliqué una vez y se enciende y aunque lo suelte sigue encendido. Cuando le vuelva

154
00:12:09,000 --> 00:12:13,000
a dar se apagará y aunque suelte sigue apagado. Lo vuelvo a dar, se vuelve a

155
00:12:13,000 --> 00:12:18,000
encender y así sucesivamente. Fijaros de qué forma más fácil lo hemos conseguido.

156
00:12:18,000 --> 00:12:22,000
No tenemos que estar guardando los valores en variables ni nada como

157
00:12:22,000 --> 00:12:28,000
comentamos al inicio del vídeo. Y eso es porque estamos utilizando un objeto de

158
00:12:28,000 --> 00:12:33,000
una clase que alguien se ha encargado ya de hacer todo ese trabajo sucio.

159
00:12:33,000 --> 00:12:38,000
Vamos a ver ahora cómo podríamos utilizar el pulsador del centro donde

160
00:12:38,000 --> 00:12:43,000
utilizamos un circuito de pull-up. Pues igual que antes crearemos una variable

161
00:12:43,000 --> 00:12:51,000
para el led del centro. La vamos a llamar pinLedMid y le asignamos el valor de 9.

162
00:12:51,000 --> 00:12:57,000
Vamos a crearnos un nuevo objeto de la clase Button para el pulsador del centro.

163
00:12:57,000 --> 00:13:03,000
Asignamos el pin 10 y en este caso sabemos que cuando pulsamos

164
00:13:03,000 --> 00:13:09,000
verdaderamente se pone a nivel bajo. Al revés que en el circuito de pull-down.

165
00:13:09,000 --> 00:13:16,000
Ahora nos tenemos que acordar de poner el led del medio en modo salida

166
00:13:16,000 --> 00:13:22,000
y haremos algo parecido a lo que tenemos aquí. Lo vamos a copiar, lo vamos a pegar

167
00:13:22,000 --> 00:13:29,000
pero en este caso estamos utilizando el botón del medio. Tengo que cambiarlo en

168
00:13:29,000 --> 00:13:34,000
todos los lados, no se me puede olvidar ninguno. Bien, vamos a probarlo.

169
00:13:34,000 --> 00:13:38,000
Bueno, aquí nos aparece un error típico de programación porque se me ha olvidado

170
00:13:38,000 --> 00:13:43,000
cambiar el nombre aquí arriba. Lo ejecutamos y vamos a ver si funciona.

171
00:13:43,000 --> 00:13:48,000
Efectivamente cuando pulsamos se enciende, cuando volvemos a pulsar otra

172
00:13:48,000 --> 00:13:53,000
vez se apaga y así alternativamente. ¡Perfecto!

173
00:13:53,000 --> 00:13:58,000
¿Y qué tenemos que hacer para encender el led sólo cuando mantenemos pulsado el

174
00:13:58,000 --> 00:14:04,000
pulsador un determinado tiempo? Por ejemplo 3 segundos. Bien, pues esta clase

175
00:14:04,000 --> 00:14:10,000
nos proporciona un par de métodos para ello. El primero, Set Hold Delay, nos permite

176
00:14:10,000 --> 00:14:14,000
especificar el tiempo que deseamos que transcurra hasta que se encienda el led.

177
00:14:14,000 --> 00:14:19,000
Y eso lo hacemos empleando nuestro objeto, por ejemplo el del medio, el método y

178
00:14:19,000 --> 00:14:24,000
indicando un parámetro que es el tiempo en milisegundos, por ejemplo 3000

179
00:14:24,000 --> 00:14:29,000
milisegundos para que sea 3 segundos. Y luego aquí tendremos que utilizar el

180
00:14:29,000 --> 00:14:36,000
método Is Hold. Vamos a probarlo. Pulso y no se enciende. Vuelvo a pulsar, sigue sin

181
00:14:36,000 --> 00:14:42,000
encenderse, pero si ahora mantenemos pulsado durante 3 segundos veremos cómo

182
00:14:42,000 --> 00:14:46,000
se enciende el led. Bueno, y vamos con el último para completar la práctica de hoy

183
00:14:46,000 --> 00:14:51,000
en el que nos vamos a crear una tercera variable para el led. En este caso la

184
00:14:51,000 --> 00:14:57,000
vamos a llamar DCH. Le vamos a asignar el valor de 7. Nos vamos a crear otro botón,

185
00:14:57,000 --> 00:15:04,000
en este caso pues también la llamaremos botón DCH, que no se nos olvide como

186
00:15:04,000 --> 00:15:09,000
antes cambiar el nombre aquí. Le asignamos su pin que es el 8.

187
00:15:09,000 --> 00:15:15,000
Y en este caso necesitamos un tercer parámetro para indicar al objeto que va

188
00:15:15,000 --> 00:15:21,000
a utilizar la resistencia de pull up que pone arduino. Y eso lo hacemos poniendo

189
00:15:21,000 --> 00:15:26,000
el valor de true, de verdadero. A continuación pondremos

190
00:15:26,000 --> 00:15:32,000
el pin de salida para el led correspondiente.

191
00:15:35,000 --> 00:15:43,000
Y por último vamos a utilizar código similar a este pero con el botón

192
00:15:43,000 --> 00:15:49,000
de la derecha. Tengo que cambiarlo en todos los lados, que no se me olvide

193
00:15:49,000 --> 00:15:53,000
ninguno. Si no, no va a funcionar como deseamos.

194
00:15:53,000 --> 00:15:59,000
Podemos darle un tiempo de espera distinto al anterior. Por ejemplo aquí le

195
00:15:59,000 --> 00:16:04,000
vamos a decir que espere tan solo un segundo para que se enciende. Pero aquí

196
00:16:04,000 --> 00:16:08,000
nos tenemos que acordar de que este es nuestro botón DCH. Vamos a ver si es verdad.

197
00:16:08,000 --> 00:16:14,000
Pulsamos y hasta que no alcanza el segundo no se enciende el led. Aquí fijaros

198
00:16:14,000 --> 00:16:19,000
cómo tarda bastante más, hasta que no alcanza el tiempo de los tres segundos.

199
00:16:19,000 --> 00:16:23,000
Bueno y esto es todo en esta práctica. Ahora esto a vosotros, a ver qué tal lo

200
00:16:23,000 --> 00:16:26,000
hacéis. Venga, ánimo.