1
00:00:00,000 --> 00:00:20,210
En este capítulo aprenderás a utilizar la estructura iterativa while para conseguir

2
00:00:20,210 --> 00:00:26,149
que el código se ejecute cíclicamente. Asimismo te presentaré las funciones de tiempo necesarias

3
00:00:26,149 --> 00:00:31,230
que deberás de utilizar para conseguir no sobrecargar al ordenador o cualquier dispositivo

4
00:00:31,230 --> 00:00:36,409
que esté ejecutando tu programa. Por último verás cómo crear túneles para entrada y

5
00:00:36,409 --> 00:00:42,409
salida de datos en los bucles while. Mi nombre es Obrero Cadenas y sin más, esto empieza ya.

6
00:00:45,619 --> 00:00:51,600
Cuando se está programando, en muchas ocasiones se necesita ejecutar un determinado código durante un número de veces,

7
00:00:52,179 --> 00:00:56,039
o que un determinado código se repita mientras se cumplan determinadas condiciones.

8
00:00:56,820 --> 00:01:00,460
Para dar solución a esto, tienes disponibles las llamadas estructuras,

9
00:01:00,939 --> 00:01:06,239
un tipo particular de nodo que permite controlar la ejecución de un determinado código de programa.

10
00:01:06,939 --> 00:01:12,099
LabVIEW dispone, entre otras, de las estructuras iterativas como es el bucle WHILE,

11
00:01:12,099 --> 00:01:17,319
que permite ejecutar un determinado código mientras se cumpla una condición

12
00:01:17,319 --> 00:01:23,500
y el bucle FOR que permite la ejecución de un determinado código un cierto número de veces.

13
00:01:24,719 --> 00:01:30,659
En el diagrama de bloques, haz clic con el botón derecho y despliega la paleta de funciones

14
00:01:30,659 --> 00:01:36,359
y selecciona Programming, Estructuras, selecciona el bucle Y,

15
00:01:36,359 --> 00:01:43,439
luego haz clic con el botón izquierdo del ratón y arrastra un rectángulo de selección alrededor de

16
00:01:43,439 --> 00:01:48,680
la sección de código del diagrama de bloques que quieras incluir en el bucle cuando sueltes

17
00:01:48,680 --> 00:01:54,659
el ratón aparecerá el marco que delimita la sección que ha seleccionado el bucle white

18
00:01:54,659 --> 00:02:00,239
te permite repetir el código que se encuentra dentro del marco hasta que se cumpla una condición

19
00:02:00,239 --> 00:02:11,620
Por lo tanto usarás la estructura while loop cuando necesites que un determinado código de programa se repita mientras una determinada condición sea cierta o falsa

20
00:02:11,620 --> 00:02:16,379
El código dentro del marco while siempre se ejecuta al menos una vez

21
00:02:16,379 --> 00:02:22,099
Como puedes ver en el flujo grama, primero se ejecuta el código dentro del marco while

22
00:02:22,099 --> 00:02:25,939
Luego se mira a ver si se cumple la condición

23
00:02:25,939 --> 00:02:32,500
si no se cumple la condición de fin se vuelve a ejecutar el código. En el caso de que se cumpla

24
00:02:32,500 --> 00:02:38,919
la condición de fin el bucle while termina. Esta estructura iterativa del bucle while tiene dos

25
00:02:38,919 --> 00:02:45,139
terminales. El terminal de interacción es el terminal de salida que va contando desde i igual

26
00:02:45,139 --> 00:02:50,719
a cero el número de veces que va repitiendo la ejecución del bucle y por otro lado el terminal

27
00:02:50,719 --> 00:02:57,340
condicional que es un terminal de entrada booleana que define la condición que permite la ejecución

28
00:02:57,340 --> 00:03:02,620
del código contenido dentro de la estructura. El bucle while comprobará el estado de este

29
00:03:02,620 --> 00:03:08,199
terminal al final de cada iteración. Haciendo clic derecho con el ratón encima de este terminal

30
00:03:08,199 --> 00:03:14,319
condicional aparecerá un menú desplegable donde podrás elegir cómo quieres que se detenga la

31
00:03:14,319 --> 00:03:21,460
ejecución del bucle while. Si seleccionas la condición stop if true el bucle while se detiene

32
00:03:21,460 --> 00:03:29,860
si el terminal recibe un valor verdadero. En cambio si seleccionas la condición continue if true el

33
00:03:29,860 --> 00:03:35,819
bucle while continúa si este terminal recibe un valor verdadero o lo que es lo mismo el bucle

34
00:03:35,819 --> 00:03:42,939
while se detiene si este terminal recibe el valor falso. Cuando un bucle termina la ejecución de

35
00:03:42,939 --> 00:03:49,580
una iteración inmediatamente empieza a ejecutarse la siguiente. Esto supone para el procesador del

36
00:03:49,580 --> 00:03:55,960
equipo donde se está ejecutando estar prácticamente dedicado a ejecutar esta tarea y por lo tanto no

37
00:03:55,960 --> 00:04:01,979
tendrá tiempo para ejecutar otras tareas. Así pues hay que introducir dentro de los bucles while

38
00:04:01,979 --> 00:04:09,159
una función de tiempo de espera que haga que el VI se desactive durante un cierto tiempo y de esa

39
00:04:09,159 --> 00:04:14,919
forma el procesador pueda abordar otras tareas durante el tiempo de espera. Coloca una función

40
00:04:14,919 --> 00:04:20,819
de espera dentro del ciclo while para permitir que el VI se duerma por un cierto tiempo. Esto

41
00:04:20,819 --> 00:04:25,579
permite que el procesador atienda otras tareas, como te estoy diciendo, durante el tiempo de

42
00:04:25,579 --> 00:04:32,379
espera. Las funciones de espera utilizan el reloj de milisegundos del sistema operativo. Dos son las

43
00:04:32,379 --> 00:04:39,040
funciones utilizadas. La función wait. Si configuras un tiempo de 10 milisegundos como

44
00:04:39,040 --> 00:04:43,920
puedes ver en el gráfico cuando termina de ejecutarse el código dentro del bucle while

45
00:04:43,920 --> 00:04:50,800
se espera estos 10 milisegundos y al concluir comienza de nuevo la ejecución del código y así

46
00:04:50,800 --> 00:04:57,980
sucesivamente. Como verás a veces el código tarda más o menos tiempo en ejecutarse. Unas veces puede

47
00:04:57,980 --> 00:05:05,639
tardar 4 milisegundos otras veces puede tardar 6 milisegundos etcétera la otra función es la

48
00:05:05,639 --> 00:05:12,860
función wait until next si configuras un tiempo de 10 milisegundos como puedes ver en el gráfico

49
00:05:12,860 --> 00:05:19,740
si el código inicialmente tarda 4 milisegundos en ejecutarse el tiempo de espera o descanso de

50
00:05:19,740 --> 00:05:26,720
la cpu será de 6 milisegundos ya que el tiempo programado es de 10 milisegundos en cambio en

51
00:05:26,720 --> 00:05:33,660
el segundo ciclo el código tarda en ejecutarse 8 milisegundos. Solo estará en espera 2 milisegundos

52
00:05:33,660 --> 00:05:39,540
como puedes ver. Evidentemente para que esta función sea efectiva el tiempo que tarda en

53
00:05:39,540 --> 00:05:46,240
ejecutarse el código deberá ser inferior al tiempo especificado para esta función. Como puedes

54
00:05:46,240 --> 00:05:52,459
observar cuando se ejecuta un VI utilizando la ejecución cíclica mediante el icono de la barra

55
00:05:52,459 --> 00:05:59,060
de herramientas, la CPU del equipo donde se está ejecutando está el 70% del tiempo atendiendo a

56
00:05:59,060 --> 00:06:04,740
esta tarea, teniendo poco tiempo para realizar otras tareas. Cuando se ejecuta cíclicamente un

57
00:06:04,740 --> 00:06:10,720
programa pero utilizamos un bloque while sin función de espera dentro del bucle, la CPU es

58
00:06:10,720 --> 00:06:17,579
utilizada el 51% del tiempo por este recurso. Y por último, cuando se ejecuta cíclicamente un

59
00:06:17,579 --> 00:06:22,740
programa utilizando un bloque while donde hemos introducido una función de espera dentro

60
00:06:22,740 --> 00:06:28,680
del bucle, la CPU es utilizada solamente el 1% del tiempo por ese recurso.

61
00:06:29,279 --> 00:06:34,160
Bien, vamos a realizar un ejercicio donde vas a ver la utilidad del bucle while.

62
00:06:34,620 --> 00:06:41,360
Este ejercicio consiste en que nos va a mostrar la temperatura actual en grados centígrados,

63
00:06:41,360 --> 00:06:51,459
Vamos a modificar aquí, vamos a ponerle grados centígrados y nos va a permitir que introduzcamos un valor máximo y un valor mínimo.

64
00:06:52,000 --> 00:07:02,300
De tal manera que cuando la temperatura sea mayor del valor máximo, aparezca en este indicador de texto una advertencia y diga, por ejemplo, advertencia de golpe de calor.

65
00:07:02,300 --> 00:07:13,199
En cambio, cuando la temperatura actual sea menor que la temperatura mínima, se muestra aquí en un texto y diga, por ejemplo, advertencia de congelación.

66
00:07:13,720 --> 00:07:20,800
Si la temperatura actual está comprendida entre el valor máximo y el valor mínimo, entonces mostrará sin advertencia.

67
00:07:21,399 --> 00:07:24,519
Siempre que haya una advertencia se encenderá este LED.

68
00:07:25,019 --> 00:07:27,079
Bien, el VI que ves es este.

69
00:07:27,079 --> 00:07:31,939
aquí tendríamos el control para introducir la temperatura actual

70
00:07:31,939 --> 00:07:34,839
el control para introducir la temperatura mínima

71
00:07:34,839 --> 00:07:37,920
y el control para introducir la temperatura máxima

72
00:07:37,920 --> 00:07:42,600
además necesitamos la función de selección que ya conoces

73
00:07:42,600 --> 00:07:46,579
también tendríamos una función de comparación

74
00:07:46,579 --> 00:07:49,579
x es menor o igual a y

75
00:07:49,579 --> 00:07:52,740
y una función también de comparación mayor o igual que

76
00:07:52,740 --> 00:07:55,639
esta entrada mayor o igual que esta entrada

77
00:07:56,139 --> 00:07:58,300
Si se cumple, esto será verdadero.

78
00:07:58,939 --> 00:08:00,459
Bien, vamos entonces a empezar por aquí.

79
00:08:01,079 --> 00:08:03,500
Metemos por aquí la temperatura actual y la estamos comparando.

80
00:08:03,680 --> 00:08:08,899
Y estamos preguntando, ¿la temperatura actual es mayor o igual que la temperatura máxima?

81
00:08:09,579 --> 00:08:16,439
Si es verdadero, este texto va a salir en esta salida.

82
00:08:16,779 --> 00:08:20,560
Si es falso, este texto va a salir en esta salida.

83
00:08:20,560 --> 00:08:26,819
Por otro lado, aquí en esta otra comparación comparamos la temperatura actual con el valor mínimo

84
00:08:26,819 --> 00:08:31,660
Y decimos, la temperatura actual es menor o igual que la mínima

85
00:08:31,660 --> 00:08:36,320
Si es verdadero, lo que tenemos aquí saldrá aquí

86
00:08:36,320 --> 00:08:40,840
Si es falso, lo que tendremos aquí, el texto que tendremos aquí

87
00:08:40,840 --> 00:08:44,980
Que es el resultado de esta otra comparación, lo tendremos en la salida

88
00:08:44,980 --> 00:08:45,600
¿Sí?

89
00:08:47,100 --> 00:08:49,980
Advertencia, este sería este led de aquí

90
00:08:49,980 --> 00:08:57,539
cuando se enciende este led esta función dice que cuando estas dos entradas son distintas este led

91
00:08:57,539 --> 00:09:03,480
se enciende esta salida sería verdadera por lo tanto este led se enciende cuando lo que tengo

92
00:09:03,480 --> 00:09:10,720
aquí es distinto de este texto sin advertencias y no se enciende este led cuando lo que sale por

93
00:09:10,720 --> 00:09:19,279
aquí es el texto sin advertencias bien cómo conseguir este indicador este es un indicador

94
00:09:19,279 --> 00:09:25,340
que no hemos visto es un indicador de texto de string botón derecho encima del panel frontal

95
00:09:25,340 --> 00:09:35,840
vas a string control para introducir texto e indicador para visualizar texto en este caso

96
00:09:35,840 --> 00:09:42,659
necesitamos un indicador y este sería el indicador que tendríamos que colocar aquí hay una clara

97
00:09:42,659 --> 00:09:49,259
diferencia de símbolos y esto es debido a que yo puedo convertir este formato si

98
00:09:49,259 --> 00:09:55,500
le quitó aquí ver como un icono pues me queda así en pequeño vale y ocupa menos

99
00:09:55,500 --> 00:10:00,440
espacio también pasa lo mismo con él con el led

100
00:10:00,440 --> 00:10:07,039
en el led no podemos también poner como un icono y lo veríamos así de acuerdo

101
00:10:07,039 --> 00:10:14,080
bien por último sólo me queda comentarte que esto es una constante de texto para

102
00:10:14,080 --> 00:10:22,019
conseguir la botón derecho vamos a string y aquí abajo tenemos constante de texto

103
00:10:23,700 --> 00:10:33,980
las locas y aquí puedes escribir el texto que quieras y luego ya conectarías con la entrada

104
00:10:33,980 --> 00:10:42,080
que corresponda bien vamos a ejecutar este v y lo vamos a ejecutar cíclicamente con esta

105
00:10:42,080 --> 00:10:50,519
función si bien lo está ejecutando cíclicamente vamos a hacer control al suprimir y seleccionar

106
00:10:50,519 --> 00:10:56,720
el administrador de tareas el seleccionado rendimiento y estoy viendo que la cpu tiene

107
00:10:56,720 --> 00:11:05,740
una ocupación del 48 49 por ciento está ocupada ese porcentaje si podemos abrir el monitor de

108
00:11:05,740 --> 00:11:12,919
recursos vale y aquí tendrías el mi procesador del ordenador de la computadora tiene cuatro

109
00:11:12,919 --> 00:11:19,720
núcleos estos serían los cuatro núcleos y tiene una ocupación bueno el núcleo cpu 3 casi casi

110
00:11:19,720 --> 00:11:27,679
al 100% bien esto es lo que ocurre cuando estamos ejecutando cíclicamente con esta función vamos a

111
00:11:27,679 --> 00:11:37,860
parar y vamos a introducir el buque wild hacemos botón derecho en extracta wild loop ahora pincho

112
00:11:37,860 --> 00:11:49,019
y arrastro y voy a crear aquí un control botón derecho create control muy bien este sería el

113
00:11:49,019 --> 00:11:55,059
botón para detener el v vamos a ejecutarlo no ahora cíclicamente si no vamos a ejecutarlo

114
00:11:55,059 --> 00:12:01,179
una vez pero como tenemos el bucle white eso está ahí ejecutándose una y otra vez que estamos

115
00:12:01,179 --> 00:12:10,600
observando que prácticamente bajo algo ahora son unos 47 tal bajo algo la ocupación de la cpu pero

116
00:12:10,600 --> 00:12:19,220
bueno todavía está bastante sobrecargada bien por último vamos a parar vamos a introducir aquí una

117
00:12:19,220 --> 00:12:27,659
función de tiempo de espera botón derecho en timing wait y vamos a ponerle por ejemplo

118
00:12:28,659 --> 00:12:37,679
una constante cread constant de 10 milisegundos con 10 milisegundos de espera vamos a ver qué

119
00:12:37,679 --> 00:12:46,899
efecto conseguimos ejecutamos y miramos aquí la cpu y sorprendentemente bajo considerablemente

120
00:12:46,899 --> 00:12:59,500
Ahora tenemos la CPU ocupada, 11, 12, 14, 11, ha disminuido mucho el recurso que estamos utilizando de la computadora.

121
00:13:00,320 --> 00:13:12,399
Esta es una de las ventajas de ejecutar cíclicamente utilizando una función while, pero siempre acuérdate de poner una función de espera, aunque sea tan poco como 10 milisegundos.

122
00:13:12,399 --> 00:13:20,419
Cuando deseemos introducir datos dentro de un bucle while o sacar datos de un bucle while

123
00:13:20,419 --> 00:13:23,240
debemos utilizar los túneles

124
00:13:23,240 --> 00:13:27,559
Estos alimentan datos desde y hacia la estructura while

125
00:13:27,559 --> 00:13:32,960
El túnel aparece como un bloque sólido en el borde del ciclo while como estás viendo

126
00:13:32,960 --> 00:13:37,240
El bloque es del color del tipo de datos cableado al túnel

127
00:13:37,240 --> 00:13:42,720
En este caso el color es de naranja que representa datos con decimales.

128
00:13:42,919 --> 00:13:49,919
Cuando un túnel pasa datos a un ciclo, el ciclo se ejecuta solamente después de que los datos lleguen al túnel.

129
00:13:50,620 --> 00:14:00,179
En el ejemplo hay un control, un número elegido del 1 al 10, que entra en el túnel y una vez haya pasado al bucle,

130
00:14:00,559 --> 00:14:05,340
éste comienza a ejecutarse no volviendo a leer dicho valor del control.

131
00:14:05,340 --> 00:14:10,039
Los datos salen fuera del ciclo después de que el ciclo haya terminado

132
00:14:10,039 --> 00:14:15,019
En el ejemplo de la imagen el terminal de iteración está conectado a un túnel

133
00:14:15,019 --> 00:14:21,899
El valor en el túnel pasa al indicador de iteraciones cuando termine de ejecutarse el ciclo while

134
00:14:21,899 --> 00:14:27,799
El túnel de salida como ves aparece también en color del tipo de datos cableado

135
00:14:27,799 --> 00:14:30,720
En este caso es un dato de tipo entero

136
00:14:30,720 --> 00:14:41,659
Los túneles permiten suministrar datos hacia dentro solo antes del inicio del bucle y hacia fuera del bucle while, solo después del final del bucle.

137
00:14:42,460 --> 00:14:49,240
Los ciclos infinitos son un error común de programación que involucra un ciclo que nunca se detiene.

138
00:14:49,240 --> 00:14:57,580
Si el terminal condicional es STOPIFTRUE y le conectas un control booleano fuera del ciclo WHILE

139
00:14:57,580 --> 00:15:06,279
Ocurrirá que si el control es falso, cuando comienza el ciclo a ejecutarse provocará un ciclo infinito

140
00:15:06,279 --> 00:15:13,159
Recuerda, el valor del control STOP solamente es leído antes de que inicie el ciclo WHILE

141
00:15:13,159 --> 00:15:32,860
Por tanto, si al inicio valía falso, aunque el control de stop tome el valor verdadero una vez se haya iniciado el bucle while, no detiene el ciclo infinito, ya que el valor en el terminal condicional sigue siendo falso y no se puede detener accionando el control stop.

142
00:15:33,240 --> 00:15:41,860
Para detener un ciclo infinito, debes abortar el VI al hacer clic en el botón de abortar en la barra de ejecución.

143
00:15:43,159 --> 00:15:52,799
Por lo tanto, para poder usar un control para detener un ciclo while, debes colocar siempre el terminal dentro del bucle while como ves en la imagen.

144
00:15:53,100 --> 00:16:05,379
El VI que ves en la pantalla determina el número de iteraciones que debe hacer el bucle while para generar un número entero entre 0 y 10 que coincida con el número seleccionado en el terminal.

145
00:16:05,379 --> 00:16:21,360
Bien, para realizar un túnel de entrada, simplemente vamos a conectar este terminal, este control, pinchamos, arrastramos y conectamos con esta función de igualdad y ya se generó aquí el túnel.

146
00:16:21,980 --> 00:16:34,039
Para hacer un túnel de salida, pues lo mismo, pinchamos, arrastramos y conectamos a este indicador que nos va a determinar el número de iteraciones que va a realizar el UI.

147
00:16:34,039 --> 00:16:36,500
Vamos a ver cómo funcionaría esto.

148
00:16:36,899 --> 00:16:44,799
Aquí tenemos una función que os presento y que se trata de la función que genera un número aleatorio entre 0 y 1.

149
00:16:45,419 --> 00:16:51,580
Aquí puedes ver, produce un número de doble precisión, un número de tipo TBL entre 0 y 1.

150
00:16:53,480 --> 00:16:54,080
Aleatoriamente.

151
00:16:54,360 --> 00:17:00,399
Lo multiplico por 10, por lo tanto estoy generando un número decimal entre 0 y 10.

152
00:17:00,399 --> 00:17:09,240
con esta otra función lo que estoy haciendo es redondeando al entero más próximo al número decimal que tengo aquí

153
00:17:09,240 --> 00:17:14,119
por ejemplo si tengo 2 con 4 redondea a 2, si tengo 2 con 8 redondea a 3

154
00:17:14,119 --> 00:17:21,099
bien, ese número sería mostrado una vez ejecutamos el programa sería mostrado en este indicador de aquí

155
00:17:21,099 --> 00:17:23,940
sería el número que va generando este VI

156
00:17:23,940 --> 00:17:28,339
este bucle se va repitiendo y generaría un número

157
00:17:28,339 --> 00:17:31,859
parecería aquí, ese número lo comparamos

158
00:17:31,859 --> 00:17:34,420
con el número que hemos introducido previamente

159
00:17:34,420 --> 00:17:36,339
antes de iniciar el bucle while

160
00:17:36,339 --> 00:17:39,839
si son iguales, esto sería verdadero

161
00:17:39,839 --> 00:17:42,160
esto sería una función o

162
00:17:42,160 --> 00:17:44,799
la función o funciona de la siguiente manera

163
00:17:44,799 --> 00:17:48,900
la salida es verdadera o bien cuando esta entrada sea verdadera

164
00:17:48,900 --> 00:17:51,519
o cuando esta otra entrada sea verdadera

165
00:17:51,519 --> 00:17:53,619
o cuando las dos entradas sean verdaderas

166
00:17:53,619 --> 00:17:56,420
este terminal de interacción, esta es una salida

167
00:17:56,420 --> 00:17:59,079
y este número va contando el número de interacciones

168
00:17:59,079 --> 00:18:01,380
empezaría en 0, 1, 2, 3

169
00:18:01,380 --> 00:18:03,619
es decir que se ejecuta todo esto

170
00:18:03,619 --> 00:18:06,019
si aquí es falso

171
00:18:06,019 --> 00:18:08,099
se vuelve otra vez a ejecutar

172
00:18:08,099 --> 00:18:11,559
pero antes esperaría 500 milisegundos

173
00:18:11,559 --> 00:18:15,359
espera 500 milisegundos y otra vez vuelve a ejecutarse

174
00:18:15,359 --> 00:18:17,880
¿Coinciden estos valores? No

175
00:18:17,880 --> 00:18:21,140
¿Has pulsado el botón de stop? No

176
00:18:21,140 --> 00:18:23,859
por lo tanto aquí tendríamos falso

177
00:18:23,859 --> 00:18:25,900
y se vuelve otra vez a repetir

178
00:18:25,900 --> 00:18:30,640
es decir, cuando no pulso, cuando no acciono este pulsador

179
00:18:30,640 --> 00:18:33,039
pues es falso lo que está devolviendo

180
00:18:33,039 --> 00:18:38,779
bien, vamos a ejecutarlo, aquí selecciono el número 1

181
00:18:38,779 --> 00:18:44,269
voy a ejecutarlo, y se detiene

182
00:18:44,269 --> 00:18:48,269
a las dos iteraciones, solo hizo dos iteraciones, solo lo repitió esto dos veces

183
00:18:48,269 --> 00:18:51,690
y ya generó el número 1, vamos a poner por ejemplo

184
00:18:51,690 --> 00:18:54,710
el número 6, ejecutamos otra vez

185
00:18:54,710 --> 00:19:01,450
mientras se está ejecutando se puede cambiar este número a 4

186
00:19:01,450 --> 00:19:04,829
¿cuándo se detuvo? cuando coincidió con el 6

187
00:19:04,829 --> 00:19:08,069
porque yo a pesar de haber cambiado esto

188
00:19:08,069 --> 00:19:10,210
el bucle while recordar

189
00:19:10,210 --> 00:19:12,990
este dato que está aquí en el túnel

190
00:19:12,990 --> 00:19:15,289
es al iniciarse el bucle while

191
00:19:15,289 --> 00:19:17,089
que era 6

192
00:19:17,089 --> 00:19:19,430
aunque lo cambie y le ponga 4

193
00:19:19,430 --> 00:19:23,369
él sigue con el dato que está introducido en este túnel

194
00:19:23,369 --> 00:19:24,609
que sería 6

195
00:19:24,609 --> 00:19:27,170
y tuvo que realizar 11 iteraciones

196
00:19:27,170 --> 00:19:30,509
vamos con un numerito más

197
00:19:30,509 --> 00:19:31,730
por ejemplo vamos a

198
00:19:31,730 --> 00:19:33,849
poner el número 8

199
00:19:33,849 --> 00:19:35,630
damos aquí

200
00:19:35,630 --> 00:19:37,549
y si quiero detener el UI

201
00:19:37,549 --> 00:19:38,549
pulso

202
00:19:38,549 --> 00:19:40,190
pulso

203
00:19:40,190 --> 00:19:44,190
tengo que mantener un tiempo más de 500 milisegundos

204
00:19:44,190 --> 00:19:45,829
porque si hago una pulsación corta

205
00:19:45,829 --> 00:19:47,309
no se detiene

206
00:19:47,309 --> 00:19:48,430
por ejemplo mirad

207
00:19:48,430 --> 00:19:51,769
una pulsación corta no, pero una pulsación de más de medio segundo

208
00:19:51,769 --> 00:19:53,230
pues si se detiene

209
00:19:53,230 --> 00:19:59,859
Bien eso es todo, espero que el video tutorial te haya gustado

210
00:19:59,859 --> 00:20:02,339
Si es así por favor dale al me gusta, pulgar arriba

211
00:20:02,339 --> 00:20:05,359
Y si quieres estar informado de próximos video tutoriales que vaya subiendo

212
00:20:05,359 --> 00:20:07,660
Anímate y suscríbete a mi canal a cadenas

213
00:20:07,660 --> 00:20:12,299
En caso de que no te haya gustado puedes ponerme en comentarios en la parte de abajo del video

214
00:20:12,299 --> 00:20:16,319
Que es lo que no te ha gustado para que la próxima vez pueda mejorar en la explicación

215
00:20:16,319 --> 00:20:17,779
Gracias, hasta luego