1
00:00:11,250 --> 00:00:15,189
Tenemos que leer los sensores, en este caso solamente tenemos el botón.

2
00:00:15,869 --> 00:00:24,690
Yo voy a definirme una variable, que va a ser la variable que voy a llamar con la letra B.

3
00:00:32,450 --> 00:00:52,200
Si en esta conexión del pin 4 me va a llegar 5 voltios, del pin número 4.

4
00:00:52,200 --> 00:01:10,140
Voy a leer fin 4 y lo voy a almacenar en B.

5
00:01:13,920 --> 00:01:26,370
De esa forma yo le pregunto si está en low, almacenaré low en B, y si es high, almacenaré high.

6
00:01:28,310 --> 00:01:34,489
Y luego en función de cómo esté B, hacemos la decisión.

7
00:01:34,489 --> 00:01:54,239
Preguntamos, ¿ves hype? ¿Preguntamos? ¿Respuestas posibles? ¿Sí? ¿Y no? Y dijimos que si era

8
00:01:54,239 --> 00:01:58,799
que sí, teníamos que hacer un montón de cosas, una secuencia larga de acciones, ¿verdad?

9
00:01:59,799 --> 00:02:05,060
¿Por qué? Porque se supone que el disco de los coches, el semáforo de los coches

10
00:02:05,060 --> 00:02:17,580
estaba en verde, teníamos que apagar el verde y ya una vez que habíamos puesto el seno

11
00:02:17,580 --> 00:02:29,780
francófono, que era apagar. Y después, cuando ya habíamos esperado el tiempo de espera

12
00:02:29,780 --> 00:03:16,379
de que el peatón cruzara, apagábamos el verde y encendíamos el rojo. Coches verdes

13
00:03:16,379 --> 00:03:26,819
off. Coches amarillo, on. Espera. ¿Cuánto le hemos dicho? ¿Dos segundos? ¿Puedo recordar?

14
00:03:28,439 --> 00:03:36,539
¿Lo miramos? Dos segundos, creo que era, ¿no? Cuando estaba amarillo, lo de coches.

15
00:03:37,199 --> 00:03:46,960
Sí, lo estuve. Dos segundos. Luego, coches amarillo, off. Coches rojo, on. Y aquí dábamos

16
00:03:46,960 --> 00:04:00,419
¿Cuánto era? Cuando encendíamos el de rojo, para cruzar las peatones.

17
00:04:00,419 --> 00:04:13,240
Un segundo de lámpara, vamos a esperar un segundo de lámpara.

18
00:04:13,240 --> 00:04:18,579
Y luego, coches...

19
00:04:18,579 --> 00:04:27,120
Sí, coches...

20
00:04:27,120 --> 00:04:30,120
No, no puede ser.

21
00:04:30,120 --> 00:04:49,879
Ocho y nueve...

22
00:04:49,879 --> 00:04:57,879
Eso es. Sí, esperábamos aquí.

23
00:04:57,879 --> 00:05:15,879
esperábamos 2 segundos, aquí esperábamos otros 5 segundos, después hacíamos, ah no, perdón, perdón, sí, es verdad, esperábamos un segundo y poníamos el de peatones en verde,

24
00:05:15,879 --> 00:05:26,439
con lo cual, peatones en rojo, o peatones en verde, o. Y ahora ya sí, ahora ya esperábamos

25
00:05:26,439 --> 00:05:39,370
cuánto era, ¿verdad? Cinco, cinco. Vale, sigo aquí a la derecha, ¿vale? Sigo ahí.

26
00:05:41,589 --> 00:05:46,550
Después de esperar cinco segundos que ya el peatón ha cruzado, le ponemos primero

27
00:05:46,550 --> 00:06:00,759
el peatón, el semáforo, esperábamos un otro segundo, ¿no? Y después de eso, ya,

28
00:06:02,459 --> 00:06:10,560
como ya teníamos el peatón, el semáforo, simplemente era apagar el coche y encender

29
00:06:10,560 --> 00:06:18,519
el coche verde. Y luego habíamos dicho que esperábamos 5 segundos para dar el tiempo

30
00:06:18,519 --> 00:06:34,420
a los coches que no se formaran. ¿Vale? Bueno, pues, estas cosas se ejecutan seguidas si

31
00:06:34,420 --> 00:06:48,670
se puse al otro. Y si no, ¿qué hay que hacer? Simplemente, coche en verde, ya está, mantendremos

32
00:06:48,670 --> 00:07:12,209
del disco verde. Y cuando terminamos, volvemos a hacerlo. ¿Vale? Es una radiograma. Y si

33
00:07:12,209 --> 00:07:20,610
no, pues la cerrada. ¿De acuerdo? ¿Cómo simularíamos esto en nuestro software de

34
00:07:20,610 --> 00:07:30,310
PSI? ¿Vale? Vamos a ir a PSI y arrancar el programa de PSI. Por favor. Y vamos a hacer

35
00:07:30,310 --> 00:07:35,629
un programa, que vamos a llamar semáforo, y vamos a simular esto en PSI, porque hay

36
00:07:35,629 --> 00:07:42,750
una estructura que necesitamos conocer. ¿Cómo hacemos en PSI un bucle infinito? Un programa

37
00:07:42,750 --> 00:07:48,509
que no termine nunca, ¿vale? Ya os lo expliqué en clase, pero quiero hacer un caso práctico

38
00:07:48,509 --> 00:08:00,560
para entenderlo. Mirad, arrancamos un nuevo algoritmo, vamos aquí, ya, en la pizarra,

39
00:08:00,560 --> 00:08:11,889
entonces ahora vamos a empezar a construir nuestro algoritmo

40
00:08:11,889 --> 00:08:15,790
lo primero que hacemos es leer un pin

41
00:08:15,790 --> 00:08:20,050
eso nosotros lo simulamos, os acordáis, preguntándole al usuario

42
00:08:20,050 --> 00:08:22,850
que valor tendría ese terminal

43
00:08:22,850 --> 00:08:25,410
entonces vamos a escribirle al usuario

44
00:08:25,410 --> 00:08:34,110
como está el botón

45
00:08:34,110 --> 00:08:39,889
como está el pin 4

46
00:08:39,889 --> 00:08:44,100
y le voy a dar la suerte de que me ponga

47
00:08:44,100 --> 00:08:45,759
h para high o l

48
00:08:45,759 --> 00:08:52,759
¿vale? y ahora voy a leer

49
00:08:52,759 --> 00:08:55,100
la variable

50
00:08:55,100 --> 00:09:06,139
que he llamado, voy a leer

51
00:09:06,139 --> 00:09:08,399
el valor

52
00:09:08,399 --> 00:09:12,559
y lo voy a almacenar en la variable

53
00:09:12,559 --> 00:09:13,559
si entonces

54
00:09:13,559 --> 00:09:15,779
hacemos

55
00:09:15,779 --> 00:09:18,659
si b

56
00:09:18,659 --> 00:09:20,879
es igual a h

57
00:09:20,879 --> 00:09:21,759
a high

58
00:09:21,759 --> 00:09:28,879
si b es igual a h

59
00:09:28,879 --> 00:09:30,759
entonces ¿qué hacemos?

60
00:09:30,759 --> 00:09:38,440
Bueno, pues hacemos todo aquello, ¿vale? Vamos a ponerle a escribir y vamos a ir escribiendo

61
00:09:38,440 --> 00:09:44,639
por pantalla toda la secuencia de acciones y luego lo haremos, ¿vale? ¿Qué es? Pues

62
00:09:44,639 --> 00:10:12,789
Primero hemos dicho que eran coches, verde, off. Luego, escribir, coches, amarillo. Luego, escribir. Luego tenemos que esperar, ¿no?

63
00:10:12,789 --> 00:10:15,519
Espera

64
00:10:15,519 --> 00:10:18,299
¿Cuánto era? Un segundo

65
00:10:18,299 --> 00:10:20,379
O dos

66
00:10:20,379 --> 00:10:23,480
Dos segundos

67
00:10:23,480 --> 00:10:24,679
Vale

68
00:10:24,679 --> 00:10:27,100
Voy a escribir por parte de la espera

69
00:10:27,100 --> 00:10:28,919
Porque si no, no va a hacer nada

70
00:10:28,919 --> 00:10:29,779
Que me voy a dar cuenta

71
00:10:29,779 --> 00:10:33,000
Escribir, esperamos

72
00:10:33,000 --> 00:10:34,879
Dos segundos, para que yo me entere

73
00:10:34,879 --> 00:10:38,450
Luego

74
00:10:38,450 --> 00:10:41,730
Claro, todo lo que estoy escribiendo

75
00:10:41,730 --> 00:10:42,490
Todo lo que estoy escribiendo

76
00:10:42,490 --> 00:10:46,240
Corches, amarillo

77
00:10:46,240 --> 00:11:05,789
O, esto es O, perdón, aquí es O. Escribir, coches, rojo, ojo. Ahora, esperar un segundo,

78
00:11:09,139 --> 00:11:16,200
¿vale? Voy a escribir que voy a esperar un segundo, para saber que estamos esperando

79
00:11:16,200 --> 00:11:44,899
ese segundo, teatones, rojo, o, escribir, teatones, verde, on, escribir, no, y aquí

80
00:11:44,899 --> 00:12:02,179
esperar, ¿cuánto hemos dicho ahora? 5, ¿no? 5 segundos. Vale. Escribir, esperamos 5 segundos.

81
00:12:03,799 --> 00:12:15,500
Y después, ya que hayan cruzado los peatones, paramos el semáforo de peatones, el verde

82
00:12:15,500 --> 00:12:47,940
a o, el rojo de peatones a on, esperamos un segundo, esperar segundos, escribir, esperamos

83
00:12:47,940 --> 00:13:16,340
un segundo y ahora ya simplemente el de coches, coches rojos a O y coches verdes a O. Y aquí

84
00:13:16,340 --> 00:13:33,240
esperamos 5 segundos para que pasen algunos coches y para. Eso es todo lo que hay que

85
00:13:33,240 --> 00:13:55,679
hacer. Si ve, está cruzado. Pero si no, solamente escribir coches verde aún. Vale. Y ya está.

86
00:13:55,679 --> 00:14:05,860
Y terminamos. Vale, fijaros. Si yo lo he puesto así, como lo tengo ahí en la pantalla, me

87
00:14:05,860 --> 00:14:11,700
lo voy a ejecutar solo una vez. ¿Lo veis? ¿Por qué? Porque voy a empezar con el mismo

88
00:14:11,700 --> 00:14:16,820
ritmo, pregunto cómo está el pin, si está impulsado a la vuelta de la secuencia y si

89
00:14:16,820 --> 00:14:22,519
no, no. ¿Pero cómo hago que esto se esté repitiendo eternamente? Pues dijimos que hoy

90
00:14:22,519 --> 00:14:30,379
vamos a hacer con un bucle while, un bucle mientras, pero todo esto lo metemos dentro

91
00:14:30,379 --> 00:14:40,480
de bucle, ¿vale? Todo eso lo metemos dentro del bucle. ¿Pero cuál es la condición de

92
00:14:40,480 --> 00:14:47,620
salida? No existe. Vamos a hacer un mientras true. True es una palabra, perdón, en este

93
00:14:47,620 --> 00:14:57,740
caso, mientras verdadero. Verdadero es una palabra clave que entiende PSI y que siempre

94
00:14:57,740 --> 00:15:03,100
devuelve el valor verdadero. ¿Cuándo salíamos de un bucle mientras? Cuando la condición

95
00:15:03,100 --> 00:15:09,419
era falsa, pero como yo le he obligado a que la condición sea siempre verdad, no hay ninguna

96
00:15:09,419 --> 00:15:15,929
condición. ¿Es verdad? Sí, claro, es verdad, entro. ¿Es verdad? Sí, entro. ¿Es verdad?

97
00:15:16,090 --> 00:15:24,269
Entro. Mientras que verdadero sea verdadero, que siempre lo va a ser, entrará. Y entonces

98
00:15:24,269 --> 00:15:28,929
nunca saldremos de esto. Entonces, fijaros que lo que he hecho ha sido traducirme el

99
00:15:28,929 --> 00:15:44,759
tiene la pinta que tiene el de la pizarra. ¿Lo veis? El verdadero, si os fijáis, mientras

100
00:15:44,759 --> 00:15:48,899
que sea verdadero, va a entrar hacia abajo, es la parte que está con la flecha hacia

101
00:15:48,899 --> 00:15:54,919
abajo, y si, a ver si puedo ampliar esto, si, ¿veis? La parte que está verdadera es

102
00:15:54,919 --> 00:15:59,259
la que está hacia abajo, y claro, verdadero nunca va a ser falso, con lo cual la salida

103
00:15:59,259 --> 00:16:09,009
por lo tanto va a ser siempre eterno en la parte del verdadero preguntaremos cómo está el pin

104
00:16:09,009 --> 00:16:17,080
si b está high y luego si está high pues toda la secuencia de acciones

105
00:16:17,080 --> 00:16:38,490
al ejecutar vale ahí lo tenemos cómo está el pin 4 h o l pues le voy a poner que está low

106
00:16:40,169 --> 00:16:49,860
coche verde es on perfecto cómo está el botón perfecto pues entonces coche verde

107
00:16:49,860 --> 00:16:57,820
y mientras que esté en low, la luz de los coches en verde se va a estar encendida. Supongamos

108
00:16:57,820 --> 00:17:08,660
que viene alguien y pulsa el botón, ¿vale? Al pulsar el botón, coche verde es off, amarillo

109
00:17:08,660 --> 00:17:27,170
on, esperamos dos segundos, coche amarillo es off, coche rojo es off, esperamos a chequear

110
00:17:27,170 --> 00:17:37,740
el botón. Ha hecho toda la secuencia. ¿Cómo está el pin? Si le damos al low, es como

111
00:17:37,740 --> 00:17:43,740
estaría sin pulsar pues otra vez se queda eternamente en el

112
00:17:43,740 --> 00:17:46,059
verde

113
00:17:47,119 --> 00:17:52,119
que va a estar este programa va a estar ejecutado continuamente no para nunca si os fijáis no va a terminar

114
00:17:52,119 --> 00:18:10,460
y es como va a funcionar en PSI si esto va muy rápido también lo puedes hacer hay una forma de ejecutar que pone ejecutar paso a paso

115
00:18:10,460 --> 00:18:16,839
Si yo ejecuto paso a paso, lo que va a hacer es ejecutar una orden y esperar a que yo le dé a que ejecute la siguiente.

116
00:18:25,440 --> 00:18:29,119
Si yo le quito el esperar unos segundos, se lo voy a quitar, ¿vale?

117
00:18:30,980 --> 00:18:36,519
El escribirlo. O sea, voy a esperar, voy a esperar, pero el escribir se lo voy a quitar. ¿Por qué?

118
00:18:37,160 --> 00:18:45,359
Porque ahora voy a hacer una ejecución para todas las esperas, le quito el texto de, digamos, de información,

119
00:18:46,400 --> 00:18:48,759
porque ahora ya, como voy a hacerlo paso a paso, puedo comprobar.

120
00:18:48,759 --> 00:18:52,349
Y ahora voy a hacer una ejecución paso a paso.

121
00:18:52,589 --> 00:19:13,410
Mira, ejecución iniciada. Fijaros que ahora tengo el programa, me está marcando una línea verde en lo que está ejecutando y aquí a la derecha tengo el botón de avanzar un paso, avanzar un paso, avanzar un paso, avanzar un paso.

122
00:19:13,410 --> 00:19:20,089
¿Lo veis? Entonces, fijaros, me ha puesto por pantalla, como está el 54, leerle, bueno,

123
00:19:20,150 --> 00:19:30,980
pues yo aquí en la pantalla, le voy a poner, ¿vale? Se ha ido al sino, ha ejecutado, ¿vale?

124
00:19:31,019 --> 00:19:41,099
Un segundito. Detener. Vale. Entonces, vamos al primer paso. ¿Vale? Estaba en automático,

125
00:19:41,240 --> 00:19:45,160
por eso lo estaba haciendo todo seguido. Lo he detenido y le he dicho que vaya al principio.

126
00:19:45,160 --> 00:19:55,119
Mientras ver la demo, escribe por pantalla el pin 4 de aquí.

127
00:19:55,119 --> 00:20:06,660
Lo siguiente, leer B, avanzamos un paso, se queda esperando, le digo que es low.

128
00:20:06,660 --> 00:20:11,309
Avanzamos un paso.

129
00:20:11,309 --> 00:20:16,309
Entonces, si B es H, ¿es H? No, porque le he puesto que se ve, ¿no?

130
00:20:16,309 --> 00:20:24,690
Entonces, salta directamente al sino y escribe por la pantalla coches verdeos.

131
00:20:24,690 --> 00:20:26,690
Filme mientras y vuelve arriba.

132
00:20:26,690 --> 00:20:30,589
¿Cómo está el tip 4? Vuelvo a preguntar y ahora te voy a poner high.

133
00:20:33,200 --> 00:20:34,299
Voy a entrar en el tópico, ¿eh?

134
00:20:35,380 --> 00:20:40,000
Escribí el coche verde off, coche amarillo on, con lo cual apago en el universo.

135
00:20:41,890 --> 00:20:44,890
Y ahora esperamos dos segundos. Uno y dos.

136
00:20:45,970 --> 00:20:48,210
Vale. Ahora, coches amarillos off.

137
00:20:49,349 --> 00:20:52,930
¿Vale? Coches en rojo on. Se pone el semáforo en rojo.

138
00:20:53,769 --> 00:20:55,109
Y esperamos un segundo.

139
00:20:56,349 --> 00:20:58,789
Pedatones en rojo off, pedatones en verde on.

140
00:20:58,789 --> 00:21:05,539
Tenemos el semáforo de coches en rojo y el de peatones en verde.

141
00:21:05,539 --> 00:21:10,539
Termina de pasar la gente. Peatones en verde, off. Peatones en rojo, on.

142
00:21:10,539 --> 00:21:19,829
Y esperamos un segundo. Y ahora ya una vez que hay coches en verde, on.

143
00:21:19,829 --> 00:21:21,829
Y esperamos cinco segundos.

144
00:21:21,829 --> 00:21:25,829
Y cuando termina la espera de cinco segundos, han pasado unos cuantos coches,

145
00:21:25,829 --> 00:21:31,829
terminan así y vuelve a cerrar el bloque y vuelve a preguntarme cómo está el motor.

146
00:21:31,829 --> 00:21:53,450
Si en vez de preguntarme cómo está el botón, a mí lo estuviera leyendo del pin correcto del robot, esto sería automático, porque va a mirar cómo está, si está en high o en low, y va a comprobar, y va a comprobar, y va a comprobar, y va a comprobar, y va a comprobar, y va a comprobar, y en el momento en que yo pulse, va a dar el ciclo.

147
00:21:53,450 --> 00:21:55,089
Y así es como funciona

148
00:21:55,089 --> 00:21:55,869
¿Vale?

149
00:21:56,869 --> 00:21:59,230
Bueno, esto lo voy a subir a la hora virtual

150
00:21:59,230 --> 00:22:00,930
Para que tengáis el programa, si queréis

151
00:22:00,930 --> 00:22:01,549
¿Vale?

152
00:22:06,900 --> 00:22:07,619
Semáforo

153
00:22:07,619 --> 00:22:12,230
Sin escribir

154
00:22:12,230 --> 00:22:17,180
Y ya está

155
00:22:17,180 --> 00:22:19,279
Vale, entonces, una vez que hemos visto

156
00:22:19,279 --> 00:22:20,779
Que con PSI

157
00:22:20,779 --> 00:22:23,240
Podemos hacer simulación de programas de robots

158
00:22:23,240 --> 00:22:24,960
Ahora podemos también simularlos

159
00:22:24,960 --> 00:22:25,940
Con

160
00:22:25,940 --> 00:22:28,420
Nuestro TinkerBot

161
00:22:28,420 --> 00:22:30,940
Nos vamos al TinkerBot, nos simulamos nuestro

162
00:22:30,940 --> 00:22:32,799
Robot

163
00:22:32,799 --> 00:22:39,799
ponemos nuestra placa y ahora vamos a hacer el programa. Vamos a hacer exactamente lo mismo que acabamos de hacer en PSI.

164
00:22:39,799 --> 00:22:46,799
Por lo tanto, lo primero que hay que hacer es definirse la variable, porque aquí la tengo que definir.

165
00:22:46,799 --> 00:23:04,960
Y ya lo definimos el otro día con el valor que leamos en las entradas del pasador digital.

166
00:23:04,960 --> 00:23:20,829
Entonces, como en el pasador digital lo que yo mire es que está el botón acá, esos serían los dos primeros cambios.

167
00:23:20,829 --> 00:23:33,299
Y ahora hay que decidir. Para decidir, vamos a utilizar la estructura de control y, o sea, si, entonces, si no.

168
00:23:33,940 --> 00:23:40,599
Es decir, si se cumple una condición, hacemos el entonces y si no se cumple, hacemos el si no.

169
00:23:41,200 --> 00:23:43,920
¿Vale? Si se cumple, hacemos una cosa y si no, otra.

170
00:23:44,779 --> 00:23:49,099
¿Qué condiciones van a cumplirse? Pues en este caso es una igualdad.

171
00:23:49,099 --> 00:24:06,839
Vamos a matemáticas, cogemos el bloque de forma de hexágono, lo empotro aquí dentro y lo que tengo que ver es si la variable b es igual a high, que lo tengo aquí en matemáticas.

172
00:24:06,839 --> 00:24:18,420
veis que tengo alta o baja, ¿veis? Mirad, lo que he hecho ha sido coger en matemáticas

173
00:24:18,420 --> 00:24:29,349
el bloque de estas funciones, tengo la función mayor, si es distinto, si es igual, están

174
00:24:29,349 --> 00:24:38,339
dentro. Entonces, la he seleccionado, la he metido dentro, y lo que quiero comparar es

175
00:24:38,339 --> 00:24:45,019
si b, que es la variable que la tengo definida en variables, es igual, y en este caso, como

176
00:24:45,019 --> 00:24:48,460
pero lo que quiero saber es si está en alta o en baja, si está a 5 voltios o a 0 voltios,

177
00:24:48,940 --> 00:24:57,450
utilizo el valor alta, pero tengo condiciones, si B es alta, si B es alta es el botón pulsado,

178
00:24:57,569 --> 00:25:02,730
entonces tengo que acercar la secuencia, y la secuencia ahora la voy a hacer poniendo

179
00:25:02,730 --> 00:25:09,490
los pines digitales a ON o a OFF, en alta o en baja, pues venga, y esperando, define

180
00:25:09,490 --> 00:25:48,420
El pasador, hemos dicho que es, lo primero que tenemos que hacer era apagar el verde, que era el pasador, el verde lo apago, y después el pasador amarillo, que es el nueve, lo enciendo, y ahora me espero dos segundos, ¿vale?

181
00:25:48,420 --> 00:25:50,740
después

182
00:25:50,740 --> 00:26:04,220
eso es toda la secuencia

183
00:26:04,220 --> 00:26:05,880
y en la parte D

184
00:26:05,880 --> 00:26:07,339
si no pulsamos el botón

185
00:26:07,339 --> 00:26:08,180
solamente

186
00:26:08,180 --> 00:26:11,319
ponemos el verde

187
00:26:11,319 --> 00:26:13,279
que es el 8

188
00:26:13,279 --> 00:26:14,839
y ya estaría

189
00:26:14,839 --> 00:26:17,680
y aquí no tenemos que hacer el bucle

190
00:26:17,680 --> 00:26:23,380
porque ya os dije que aquí en el Tinkercad, todo lo que yo ponga en los bloques de ejecución,

191
00:26:25,480 --> 00:26:34,859
vale, hemos hecho lo mismo, identificando, hemos hecho todo lo mismo, identificando donde

192
00:26:34,859 --> 00:26:50,430
tengo el botón, si lo pongo en altas se enciende, si lo pongo en bajas se apaga, y el 4 simplemente

193
00:26:50,430 --> 00:27:05,759
lo voy a leer cada vez, pues si nos vamos a nuestro programa y lo ejecutamos, vemos

194
00:27:05,759 --> 00:27:17,130
que se enciende el, vale, un segundito, me falta un pequeño detalle, cuando arrancamos

195
00:27:17,130 --> 00:27:29,819
por primera vez, si no se pulsa el botón, me tengo que asegurar de que también el semáforo

196
00:27:29,819 --> 00:27:38,240
de P.A. Torres esté en rojo, por lo tanto el 7 también lo va a detectar, ¿vale? Entonces

197
00:27:38,240 --> 00:27:45,079
ahora ya sí. Ahora encendemos, arrancamos nuestros enáforos y se encienden la luz de

198
00:27:45,079 --> 00:27:54,619
coches en verde y la luz de peatones en rojo. ¿Vale? ¿Lo veis? Y ahí está, quieto parado.

199
00:27:54,700 --> 00:28:01,019
¿Está parado? No, está ejecutando el programa y está encendiendo el rojo de peatones y

200
00:28:01,019 --> 00:28:05,680
el verde de coches continuamente, por lo que estoy pulsando el botón. Vamos a pulsar

201
00:28:05,680 --> 00:28:12,579
el botón. Fijaros, en el momento en el que yo puse el botón, hago clic, se enciende

202
00:28:12,579 --> 00:28:18,339
el amarillo de coches, se encenderá el rojo de coches y un segundo después el de peatones

203
00:28:18,339 --> 00:28:24,619
en verde. Se espera que crucen los peatones, se paran los peatones y se pone el rojo y

204
00:28:24,619 --> 00:28:32,559
se cambia el de coches a verde. ¿Vale? Y ya está. Y nos quedamos ahí esperando. ¿Veis?

205
00:28:32,559 --> 00:28:49,920
Vamos a usar todo el ciclo del semáforo. Si le volvemos a pulsar, pues se pone en amarillo, se va a entrar en rojo, un segundo después cambia el de peatones, se queda esperando 5, luego cambia peatones a rojo y un segundo después, coches al revés.

206
00:28:49,920 --> 00:28:57,920
Entonces, cada vez que alguien venga y pulse el botón, pues va a estar... ¿Qué ocurre?

207
00:28:57,920 --> 00:29:03,920
Fijaros. ¿Qué ocurre si yo pulso el botón mientras que se está haciendo el ciclo? Pues

208
00:29:03,920 --> 00:29:07,920
yo pulso, está en amarillo, yo ahora puedo pulsar, estoy pulsando, pulsando, pulsando,

209
00:29:07,920 --> 00:29:12,920
no hace nada. Él está en su rollo, porque no está chequeando cómo está el botón.

210
00:29:12,920 --> 00:29:17,920
¿Vale? No está chequeando cómo está el botón. Yo le puedo dar al botón todas las

211
00:29:17,920 --> 00:29:41,200
y de hecho si os fijáis, si yo dejo pulsado el botón, lo tengo pulsado continuamente, fijaros que ahora cuando vaya al semáforo de coches en verde, rojo y verde, se queda 5 segundos hasta que vuelva a empezar el ciclo,

212
00:29:41,200 --> 00:29:54,099
Porque le hemos metido la seguridad de que aunque alguien o se haya estropeado el botón o le haya puesto algo para que esté pulsado siempre, los coches siempre pueden estar pasando.

213
00:29:56,289 --> 00:30:09,769
¿Veis? Entonces nosotros lo que hemos hecho ha sido utilizar el montaje básico de un botón, el montaje básico de un LED, para ahora montarnos un sistema y hacer algo más complejo a través de un programa.

214
00:30:09,769 --> 00:30:17,769
¿Vale? Si esto lo quisiéramos hacer con un circuito electrónico, con transistores, con resistencias, con condensadores,

215
00:30:17,769 --> 00:30:22,769
pues necesitaríamos un circuito complicadísimo para que hiciera toda esta secuencia de esta forma.

216
00:30:22,769 --> 00:30:26,009
Sin embargo, a través de programación se puede hacer de una forma diferente.