1
00:00:22,829 --> 00:00:31,359
Vamos a simular cómo hacer algoritmos y programas usando PSI, ¿vale?

2
00:00:31,859 --> 00:00:40,859
Es una simulación porque evidentemente PSI no le podemos conectar sensores, ni motores, ni luces, ¿vale?

3
00:00:41,780 --> 00:00:44,140
Entonces tenemos que simularlo. ¿Cómo lo vamos a simular?

4
00:00:45,700 --> 00:00:50,579
Pues lo vamos a simular a través de los mensajes que intercambiamos con el usuario, ¿vale?

5
00:00:50,579 --> 00:01:20,599
Entonces, la simulación la haremos a través del intercambio de mensajes con el usuario, ¿vale?

6
00:01:21,299 --> 00:01:37,659
Entonces, por ejemplo, supongamos que yo vengo en mi robot, quiero poner un sensor de distancia, ¿vale?

7
00:01:37,659 --> 00:01:40,739
un sensor de distancia

8
00:01:40,739 --> 00:01:45,069
que estará conectado

9
00:01:45,069 --> 00:01:45,609
a mi

10
00:01:45,609 --> 00:01:50,019
esto es sensor

11
00:01:50,019 --> 00:01:52,459
de distancia

12
00:01:52,459 --> 00:01:55,879
y esta es la microcontroladora

13
00:01:55,879 --> 00:01:57,079
vale

14
00:01:57,079 --> 00:02:01,719
yo desde la placa de control

15
00:02:01,719 --> 00:02:04,140
puedo decir

16
00:02:04,140 --> 00:02:05,219
tengo un comando

17
00:02:05,219 --> 00:02:08,379
que es leer distancia

18
00:02:08,379 --> 00:02:12,379
vale

19
00:02:12,379 --> 00:02:16,120
sería leer distancia

20
00:02:16,120 --> 00:02:16,819
y aquí

21
00:02:16,819 --> 00:02:19,500
esto lo guardo

22
00:02:19,500 --> 00:02:21,000
a distancia en una valla, ¿vale?

23
00:02:31,620 --> 00:02:33,219
Yo en la microcontroladora

24
00:02:33,219 --> 00:02:51,060
y el resultado en centímetros lo va a

25
00:02:51,060 --> 00:03:03,830
guardar en... Esto sería un robot, un robot

26
00:03:03,830 --> 00:03:08,139
¿Cómo lo haría? Pues lo metemos en un aparato electrónico

27
00:03:08,139 --> 00:03:15,280
léete

28
00:03:15,280 --> 00:03:18,319
¿Vale? En este caso

29
00:03:18,319 --> 00:03:20,219
ya sé que es el sensor de distancia

30
00:03:20,219 --> 00:03:21,699
pero lo que voy a hacer es leer

31
00:03:21,699 --> 00:03:26,469
el pin 7

32
00:03:26,469 --> 00:03:29,310
que el que lo ha programado

33
00:03:29,310 --> 00:03:31,009
sabe que ahí lo que me está ofreciendo

34
00:03:31,009 --> 00:03:32,889
es una distancia, porque

35
00:03:32,889 --> 00:03:34,150
es el que lo ha conectado, ¿vale?

36
00:03:39,909 --> 00:03:44,469
dice vale mira que te encuentras en el pin 7

37
00:03:44,469 --> 00:03:51,430
en el pin 7 yo lo que tengo es la distancia que me está dando el medidor de distancia

38
00:03:51,430 --> 00:03:55,909
y esa lectura la almaceno en distancia, eso es lo que haría otro robot

39
00:03:55,909 --> 00:04:02,629
de acuerdo, por ejemplo si en el pin 9 tengo un motor

40
00:04:02,629 --> 00:04:11,800
tengo un motorcito vale pues yo lo que voy a hacer es

41
00:04:11,800 --> 00:04:19,839
activa el pin número 9

42
00:04:19,839 --> 00:04:44,860
y entonces vamos a poner 4 voltios y medio que tiene, que están numerados

43
00:04:44,860 --> 00:04:50,500
y va a estar activando o no activando la conexión donde están los actuadores

44
00:04:50,500 --> 00:04:54,500
¿Vale? Bien, ¿cómo simulamos esto?

45
00:04:54,500 --> 00:04:59,500
Esto sería el caso real, ¿vale? Esto sería el caso real

46
00:04:59,500 --> 00:05:09,829
¿Cómo simulamos esto con PSI de distancia?

47
00:05:09,829 --> 00:05:38,829
Entonces, el usuario, el que está en la cámara, va a hacer el sensor de distancia y también va a hacer el motor, que es escribir.

48
00:05:38,829 --> 00:05:55,629
Con este bloque, en pantalla, le va a aparecer al usuario que está aquí y yo, que hago el sensor de distancia.

49
00:05:55,629 --> 00:06:02,009
Y lo meto con un le y lo almaceno de la manera misma.

50
00:06:02,009 --> 00:06:05,009
Y a partir de aquí ya puedo seguir haciendo el programa.

51
00:06:05,009 --> 00:06:20,509
Cuando tengo un sensor conectado a un plan de robots, yo lo que haré es leer directamente

52
00:06:20,509 --> 00:06:27,129
el PSI, que es un programa de simulación de pseudocódigo.

53
00:06:27,129 --> 00:06:37,370
Yo lo que voy a hacer es preguntarle al usuario para ir a distancia.

54
00:06:37,370 --> 00:06:43,370
Este par de bloques sustituiría a este, el pin 7.

55
00:06:43,370 --> 00:06:50,019
Y como no hago una activación de un pin, pues pues fácil.

56
00:06:50,019 --> 00:08:14,569
esta de aquí sería simplemente, escribe, pues yo que sé, enciende motor, enciende motor 1, no se enciende nada evidentemente, y luego a lo mejor en otro motor, vale, entonces vamos a simular intercambiando mensajes con el usuario, que quiero leer un sensor, le pregunto al usuario, dame la medida de la luminosidad, dame la medida de...

57
00:08:14,569 --> 00:08:40,779
Y una vez que he aprobado las decisiones y en función de lo que he recibido de mis sensores decido activar o no activar las luces, los motores, los movimientos, luz, iluminación, un mensaje, lo que sea.

58
00:08:40,779 --> 00:09:01,159
y una salida

59
00:09:01,159 --> 00:09:05,080
bueno

60
00:09:05,080 --> 00:09:07,340
esa es la primera parte

61
00:09:07,340 --> 00:09:08,899
ahora

62
00:09:08,899 --> 00:09:13,419
¿cómo es un programa de robots?

63
00:09:14,100 --> 00:09:15,779
no sé si ya os lo he explicado

64
00:09:15,779 --> 00:09:20,139
¿cómo sería un programa de robots?

65
00:09:20,360 --> 00:09:21,039
un robot

66
00:09:21,039 --> 00:09:30,450
un programa de robots tiene la siguiente estructura

67
00:09:30,450 --> 00:09:45,960
que es la segunda que tengo que simular

68
00:09:45,960 --> 00:09:46,700
con PSI

69
00:09:46,700 --> 00:09:49,700
¿cómo es un programa de

70
00:09:49,700 --> 00:09:51,759
control de robots?

71
00:09:51,759 --> 00:10:04,919
Como es el programa de estructura interna

72
00:10:04,919 --> 00:10:06,580
O el programa que controla un robot

73
00:10:06,580 --> 00:10:09,120
Bueno, siempre tiene la misma forma

74
00:10:09,120 --> 00:10:09,860
¿Vale?

75
00:10:10,379 --> 00:10:14,320
Un robot siempre hace las cosas de la misma forma

76
00:10:14,320 --> 00:10:15,899
Y es de la siguiente

77
00:10:15,899 --> 00:10:19,879
Lo primero que tenemos que hacer es

78
00:10:19,879 --> 00:10:25,019
Leer los sensores

79
00:10:25,019 --> 00:10:28,210
¿Vale?

80
00:10:29,009 --> 00:10:31,549
Yo en mi robot tendría una serie de sensores

81
00:10:31,549 --> 00:10:50,389
yo antes de hacer nada tengo que saber que ocurre a mi alrededor y yo tengo que tener esa información

82
00:10:50,389 --> 00:11:05,889
¿Qué tipo de sensores tenemos? De todo tipo, podemos mirar luz, humedad, presión, distancia, cualquier magnitud física que se os ocurra se puede medir

83
00:11:05,889 --> 00:11:29,889
y un aparato que mide eso y me lo vuelca para que se olvida, lo siguiente que tengo que hacer es almacenar esa información

84
00:11:29,889 --> 00:11:39,590
Vale, voy a los sensores, les pregunto, dame tu medición de lo que sea, y eso lo guardo en una variable.

85
00:11:47,259 --> 00:11:49,980
Bien, ya tenemos la información de lo que ocurre alrededor.

86
00:12:00,539 --> 00:12:17,070
A lo mejor, si yo tengo que saber si estoy muy cerca o muy lejos para poder decidir si hago una cosa o la otra,

87
00:12:17,929 --> 00:12:22,149
a lo mejor la distancia la tengo que transformar en unidades o tengo que sumar dos cosas,

88
00:12:22,149 --> 00:12:54,769
O tengo que hacer algún cálculo, o tengo que compensar algo, y después de procesarla, tomar decisiones.

89
00:12:55,049 --> 00:13:08,529
Ok, ¿y cómo tomamos decisiones? Pues sabiendo lo que está pasando, estoy suficientemente cerca de la pared como para tener...

90
00:13:08,529 --> 00:13:43,200
Decidiré activar o no activar. Activar, activar, activar o no activar.

91
00:13:43,200 --> 00:14:25,500
la decisión es que no activamos algo, no enciende la luz, pues no la enciendo, no la toco, sin lucir y está encendida la tengo que apagar, activar o desactivar los actuadores, vale, y ya, ojo, esto es importante, un robot nunca termina de ejecutar su programa, es decir, yo leo los sensores, veo que ocurre, decido, tomo decisiones, actúo y vuelvo a leer,

92
00:14:25,519 --> 00:14:44,009
los sensores y veo que ha pasado. Vuelvo a agregar información, lo vuelvo a almacenar y hago lo que tenga que hacer.

93
00:14:44,009 --> 00:15:03,929
Y en ese proceso de mirar lo que ocurre, guardar la información, procesarla, decidir y activar o... ¿Entendéis?

94
00:15:03,929 --> 00:15:24,480
Cuando yo lo sigo todo en PSI, ¿qué tendremos? Lo primero es cómo hacemos que un programa no termine nunca.

95
00:15:24,480 --> 00:16:00,899
del tipo mientras, pero la condición de salida del bucle no va a existir, es decir, va a ser un mientras y luego aquí detrás le voy a poner la palabra club,

96
00:16:00,899 --> 00:16:11,860
Mientras sea verdadero, pues haces lo que tengas que hacer.

97
00:16:11,860 --> 00:16:20,179
Claro, como yo le estoy diciendo directamente que la condición es...

98
00:16:20,179 --> 00:16:24,179
Entonces, este mientras de verdadero va a hacer que no salgamos del bucle mientras.

99
00:16:24,179 --> 00:16:36,960
¿Ves ahí? Voy a simular el bucle infinito, ¿de acuerdo? Con un bucle mientras.

100
00:16:36,960 --> 00:16:41,399
Pero el bucle mientras, era mientras se cumple una condición, ejecuta algo.

101
00:16:42,299 --> 00:16:58,549
¿Qué ocurre? Que cada vuelta yo vuelvo a grabar algo.

102
00:16:58,830 --> 00:16:59,909
Siempre va a ser verdadero.

103
00:17:00,409 --> 00:17:03,990
Por lo tanto, mientras que sea verdadero, ejecute esto, pero va a ser verdadero siempre.

104
00:17:05,769 --> 00:17:06,430
Se debe decir.

105
00:17:09,220 --> 00:17:10,299
Mientras que va a dar error.

106
00:17:11,460 --> 00:17:11,740
Bien.

107
00:17:12,460 --> 00:17:13,460
Esa es la forma de circular.

108
00:17:16,170 --> 00:17:17,829
Esto me va a poner una salida.

109
00:17:20,880 --> 00:17:23,640
Luego, ¿cómo leemos los sensores?

110
00:17:24,140 --> 00:17:25,200
Pues con el comando leer.

111
00:17:26,539 --> 00:17:27,319
Ya lo hemos visto.

112
00:17:27,319 --> 00:17:30,960
con el comando leer

113
00:17:30,960 --> 00:17:33,220
¿de acuerdo?

114
00:17:33,440 --> 00:17:35,119
yo pregunto al usuario

115
00:17:35,119 --> 00:17:37,019
yo lo mismo antes

116
00:17:37,019 --> 00:17:40,759
x

117
00:17:40,759 --> 00:17:43,519
y leo la variable

118
00:17:43,519 --> 00:17:45,759
con lo cual, tanto

119
00:17:45,759 --> 00:17:47,700
el leer los sensores

120
00:17:47,700 --> 00:17:49,359
como el almacenar la información

121
00:17:49,359 --> 00:17:51,880
se hace

122
00:17:51,880 --> 00:17:53,339
con el comando leer

123
00:17:53,339 --> 00:17:55,559
yo hago un escribir

124
00:17:55,559 --> 00:17:57,160
primera información

125
00:17:57,160 --> 00:17:59,519
y almacenar

126
00:17:59,519 --> 00:18:36,630
donde yo hago cuentas, divido, multiplico, decido, y luego las decisiones, ¿cómo las tomamos?, pues las tomamos siempre con el rumbito, salida sí, salida no, y haciendo preguntas directas, una pregunta cuya respuesta solo puede ser sí o no,

127
00:18:36,630 --> 00:18:47,609
Entonces, por ejemplo, imagina que has tenido otro bosque. Pues yo pido la distancia. La almaceno en la misma variante que se medís.

128
00:18:47,609 --> 00:19:11,789
Luego, la proceso, digo la distancia. Si es que sí, párate, cambia de dirección y vente para otro lado, porque te vas a estallar contra algo.

129
00:19:11,789 --> 00:19:19,789
Entonces lo evito. Y si es que no, sigue avanzando. ¿Entendéis? La decisión se toma siempre con honor.

130
00:19:19,789 --> 00:19:31,910
con una condición del tipo si la condición entonces

131
00:19:31,910 --> 00:19:44,279
unas acciones y si no otras acciones y si la condición

132
00:19:44,279 --> 00:19:48,940
en sí y si no

133
00:19:48,940 --> 00:19:51,559
si no

134
00:19:53,700 --> 00:19:58,799
y luego

135
00:20:01,460 --> 00:20:06,720
y aquí

136
00:20:06,720 --> 00:20:10,759
aparte del sí entonces

137
00:20:11,039 --> 00:20:15,799
vale ya no son nuevas decisiones y ahora en función de que salga por una

138
00:20:15,799 --> 00:20:20,180
pata o por la otra aquí activo o desactivo autores que lo

139
00:20:20,180 --> 00:20:27,799
voy a hacer con el escribir es como yo voy a simular

140
00:20:27,799 --> 00:20:35,140
la salida de un motor una luz que se enciende o se apaga, voy a escribir por pantalla y se encienden las luces

141
00:20:35,140 --> 00:20:40,779
entonces de esta forma este programa de robots

142
00:20:40,779 --> 00:20:47,440
yo lo voy a simular primero lo tengo que meter dentro de un buquete un mientras truco

143
00:20:47,440 --> 00:20:50,859
y eso no va a ser lo importante

144
00:20:50,859 --> 00:21:24,809
Con lo cual, el programa, mientras, ejecuta. Luego, leeremos la información que será con el escribir, con esto realmente, a ver, voy a poner mejor, esto era un escribir y un leer,

145
00:21:24,809 --> 00:22:40,359
leer los sensores que teníamos de información y luego lo armazenamos, dividir y leer, de leer todo, ya hemos visto entonces como hacer los programas, ahora vamos a hacer un ejemplo y lo volvemos a simular con BSI, vamos a hacer un, bien, lo primero que tenemos que tener claro, cuando hacemos un robot, que lo veis mejor, es de

146
00:22:40,359 --> 00:22:53,730
decidir, vamos a ver, qué piezas de hardware es el que lo forma, qué piezas tengo, qué

147
00:22:53,730 --> 00:23:04,049
piezas necesito, qué sensores necesito para un robot evitando obstáculos. Si yo quiero

148
00:23:04,049 --> 00:23:09,369
un robot que vaya avanzando, el objetivo del robot evitando obstáculos, la definición

149
00:23:09,369 --> 00:23:17,049
es, quiero un robot que avance de frente, siempre y cuando no haya un obstáculo, cuando

150
00:23:17,049 --> 00:23:25,710
se encuentre con un obstáculo, antes de chocarse, debe parar, girar sobre sí mismo, un ángulo

151
00:23:25,710 --> 00:23:31,930
del que sea, cambiar de dirección y volver a avanzar hacia delante. ¿Vale? Yo voy avanzando,

152
00:23:32,009 --> 00:23:38,230
cuando llego a una pared, paro, sin chocarme, giro y avanzo en otra dirección. Y ya está.

153
00:23:38,890 --> 00:23:45,349
¿Vale? Esa es la idea. ¿Entendéis? ¿Vale? ¿Qué sensores necesitaría? Bueno, de distancia.

154
00:23:45,349 --> 00:24:10,640
desde distancia y que actuadores tengo las ruedas que son dos motores uno para cada rueda

155
00:24:11,819 --> 00:24:24,200
dos motores y algo más nada más si queremos añadir una lucecita para que cuando se pare

156
00:24:24,200 --> 00:24:29,799
pero inicialmente solamente me faltan dos motores

157
00:24:29,799 --> 00:24:33,640
es decir, necesito un sensor de distancia y dos motores

158
00:24:33,640 --> 00:24:37,619
vale, ya tengo claro mi hardware, lo que es mi robot

159
00:24:37,619 --> 00:24:41,200
el robot, lo que es mi cárcel de arriba, tendría una base

160
00:24:41,200 --> 00:24:49,420
y delante

161
00:24:49,420 --> 00:24:52,519
tendrá

162
00:24:52,519 --> 00:24:55,779
el sensor de distancia

163
00:24:55,779 --> 00:24:56,740
¿vale?

164
00:24:56,740 --> 00:25:00,519
y el robot, de lo que se trata es de que vaya bajando

165
00:25:00,519 --> 00:25:26,559
Aquí tengo el motor 1 y aquí tengo el motor 2 ¿Lo veis? Dos motores, sensor de distancia, dos ruedas y la placa de control

166
00:25:26,559 --> 00:25:39,519
que vamos a programar que estará por ahí. Ya tenemos el robot montado. Perfecto. Lo veis, ¿no? Está listo el detalle. Bien.

167
00:25:39,519 --> 00:25:48,920
Vamos a hacer el programita. Arrancamos, que es lo primero que has controlado en el control.

168
00:25:48,920 --> 00:26:39,839
leer los sensores, grabar la primera bola, tomamos el PSI, distancia, esto lo va a hacer a través de una orden pidiéndole al sensor de distancia que me devuelva

169
00:26:39,839 --> 00:26:54,759
y luego la lectura la vamos a meter en una variable que se va a llamar DIST, D-I-S-T para identificarla como distancia.

170
00:26:56,200 --> 00:27:01,200
que es el nombre de una variable

171
00:27:01,200 --> 00:27:04,200
eso es una variable

172
00:27:04,200 --> 00:27:13,640
por lo tanto ya hemos simulado

173
00:27:13,640 --> 00:27:16,640
ya hemos simulado

174
00:27:16,640 --> 00:27:19,640
la orden de la placa de control

175
00:27:19,640 --> 00:27:25,000
al sensor dentro del disk

176
00:27:25,000 --> 00:27:28,630
ya hemos cubierto las dos primeras cosas

177
00:27:28,630 --> 00:27:30,630
voy a hacer lo siguiente

178
00:27:30,630 --> 00:27:32,630
procesar la información

179
00:27:32,630 --> 00:27:39,079
ahora vamos a tomar la decisión

180
00:27:39,079 --> 00:27:41,079
¿cómo la tomamos?

181
00:27:41,079 --> 00:27:52,089
con un rompito. ¿Y qué es? ¿Cuál es la pregunta? Voy a preguntar si la distancia

182
00:27:52,089 --> 00:28:08,779
es menor de 3 centímetros. ¿Salida no? Salida sí. Vale. Si yo estoy aquí y no tengo nada

183
00:28:08,779 --> 00:28:19,630
de 3 centímetros por lado, si ya están en marcha, pues seguir poniéndolos. Pues motor,

184
00:28:19,630 --> 00:28:44,769
bueno, es decir, escribir motor 1, on, que quiere decir que lo encierro, y escribir motor 2, on, que quiere decir que lo encierro, ¿vale?

185
00:28:44,769 --> 00:29:13,420
¿Y qué pasa si por el contrario sí que me encuentro que estoy más cerca de 3 centímetros de un objeto?

186
00:29:13,720 --> 00:29:16,420
Bueno, pues lo primero que tengo que hacer es parar los motores.

187
00:29:19,559 --> 00:29:35,490
Escribir, parar, con lo cual escribir para los motores.

188
00:29:35,490 --> 00:29:42,099
pues eso quiere decir que si yo la distancia es menor de tres centímetros, tengo que mandar la orden a los motores.

189
00:29:42,099 --> 00:29:48,430
Y después, ¿cómo hacemos que el brazo gire?

190
00:29:48,430 --> 00:29:54,769
Está claro que si yo activo los dos motores hacia delante, entonces va a girar.

191
00:29:54,769 --> 00:30:03,329
Si yo ya estoy parado, delante del... ya, he llegado, y estoy aquí con un objeto que tengo más cerca de tres centímetros, ¿cómo hago que gire?

192
00:30:03,329 --> 00:30:21,619
¿Cómo? Pero en vez de activarlo hacia delante, que avance, como tengo los dos parados,

193
00:30:21,619 --> 00:30:41,690
Voy a coger el motor 2, ¿vale? Este es el 1. Escribir motor 2 atrás. Eso quiere decir que voy a activar el motor 2 que me marcha atrás.

194
00:30:50,150 --> 00:30:58,410
Cierro. Si yo estoy así, llevo un reparo. Si la rueda de la derecha me ha hecho hacia atrás, va a hacer esto.

195
00:31:00,900 --> 00:31:04,960
¿Y cuánto tiempo lo voy a tener así? Bueno, lo vamos a darle, por ejemplo, un segundo.

196
00:31:04,960 --> 00:31:26,849
con lo cual, una espera de un segundo. Eso quiere decir que yo activo la rueda y cojo un cronómetro, ¿vale?

197
00:31:27,569 --> 00:32:11,619
Y después voy a apagarla, ¿vale? Escribir, muy bien, ¿vale? Fijaros lo que he hecho.

198
00:32:14,000 --> 00:32:21,599
Cuando termino de activar o desactivar mis actuadores, ¿qué tengo que hacer? Cerrar el ciclo.

199
00:32:21,599 --> 00:32:33,099
Esto, esta vuelva, es la que yo voy a simular para el Wildtour, con el viento, es verdad.

200
00:32:33,099 --> 00:32:38,099
¿Veis o no lo que estoy haciendo? ¿Por qué no he activado aquí los motores hacia delante?

201
00:32:38,099 --> 00:32:46,369
Mirad, una cuestión. ¿Por qué no he activado aquí los motores hacia delante?

202
00:32:46,369 --> 00:32:57,259
Porque yo, a lo mejor no he girado suficiente y al girar no me encuentro con otro objeto.

203
00:32:57,259 --> 00:33:24,680
Imaginaos que yo estoy en esta esquina, yo llego, me paro y giro hacia la izquierda, me paro, si avanzo sin mirar, si tengo un objeto me choco, tengo primero que medir, por lo tanto antes de avanzar siempre tengo que medir y para evitar esos choques innecesarios, lo que hago cuando termino de hacer el giro simplemente es volver a empezar, mide, si ya no tengo nada delante pues entonces el central no.

204
00:33:24,680 --> 00:33:35,480
pero si al mirar me encuentro con que la distancia sigue siendo menos de 3 centímetros, volverá

205
00:33:35,480 --> 00:33:38,480
le echará el motor para atrás otra vez y pues girará más

206
00:33:38,480 --> 00:33:42,500
y ya se acerca la balanza

207
00:33:42,500 --> 00:33:46,500
entonces vamos a ver si este programa funciona

208
00:33:46,500 --> 00:33:48,500
voy a hacer dos cosas

209
00:33:48,500 --> 00:33:52,259
voy a poner aquí un tabique

210
00:33:52,259 --> 00:33:54,259
este sería un tabique

211
00:33:54,259 --> 00:34:11,239
y luego aquí le voy a poner un tabique así

212
00:34:11,239 --> 00:34:34,639
Vamos a ver si funciona. Este es mi entorno de pruebas para mi robot. Lo tenemos aquí. Arranco, enciendo las pilas, ON. Y el robot me charla. ¿Por qué? Porque lo primero que hace es medirme la distancia, mide la distancia y me dice tienes 80 centímetros.

213
00:34:34,639 --> 00:34:38,139
si mido 80 cm

214
00:34:38,139 --> 00:34:39,420
y comparo con 3

215
00:34:39,420 --> 00:34:40,480
es menor que 3

216
00:34:40,480 --> 00:34:43,260
no, salgo corriendo

217
00:34:43,260 --> 00:34:45,820
y que es lo que hago

218
00:34:45,820 --> 00:34:47,420
motor 1, motor 2

219
00:34:47,420 --> 00:34:48,219
he hecho

220
00:34:48,219 --> 00:34:50,699
vale, voy a tocar los dos hacia adelante

221
00:34:50,699 --> 00:34:53,420
ahora, el robot

222
00:34:53,420 --> 00:34:55,099
aquí

223
00:34:55,099 --> 00:34:58,940
me falta una cosita

224
00:34:58,940 --> 00:35:01,019
que es

225
00:35:01,019 --> 00:35:02,719
porque si no va a ir muy rápido

226
00:35:02,719 --> 00:35:06,119
voy a estar saturando el robot

227
00:35:06,119 --> 00:35:07,960
voy a hacerle una pequeña espera

228
00:35:07,960 --> 00:35:11,340
por ejemplo

229
00:35:11,340 --> 00:35:13,880
100 milisegundos

230
00:35:13,880 --> 00:35:19,250
¿por qué espero 100 milisegundos?

231
00:35:21,010 --> 00:35:22,230
100 milisegundos

232
00:35:22,230 --> 00:35:24,750
¿cuántos son 100 milisegundos en segundos?

233
00:35:27,969 --> 00:35:28,590
0,1

234
00:35:28,590 --> 00:35:30,230
una décima de segundo ¿vale?

235
00:35:30,969 --> 00:35:31,769
entonces fijaros

236
00:35:31,769 --> 00:35:34,070
yo voy a esperar una décima de segundo

237
00:35:34,070 --> 00:35:35,829
una décima de segundo para mí no es nada

238
00:35:35,829 --> 00:35:38,710
pero para otro robot

239
00:35:38,710 --> 00:35:40,909
está haciendo miles de millones de operaciones

240
00:35:40,909 --> 00:35:46,579
o sea, es muchísimo tiempo

241
00:35:46,579 --> 00:35:51,639
esperamos un segundo

242
00:35:51,639 --> 00:35:54,420
perdón, una decima de segundo

243
00:35:54,420 --> 00:36:03,769
y bueno, cuando vuelvo a medir

244
00:36:03,769 --> 00:36:06,510
sigue siendo más de 3 centímetros

245
00:36:06,510 --> 00:36:07,909
vuelvo a salir por el no

246
00:36:07,909 --> 00:36:09,130
y sigo avanzando

247
00:36:09,130 --> 00:36:11,710
vuelvo a medir, sigue siendo más de 3

248
00:36:11,710 --> 00:36:13,849
avanza, es el tracero

249
00:36:13,849 --> 00:36:15,809
llega un momento en el que el robot

250
00:36:15,809 --> 00:36:16,809
se encuentra aquí

251
00:36:16,809 --> 00:36:23,099
después de avanzar un rato, ya no nos va a ir

252
00:36:23,099 --> 00:36:23,780
¿vale?

253
00:36:23,780 --> 00:36:27,340
y entonces en ese momento cierro el bucle

254
00:36:27,340 --> 00:36:29,579
¿cuánto vale la distancia?

255
00:36:30,300 --> 00:36:31,500
2 centímetros

256
00:36:31,500 --> 00:36:33,699
cuidado que tengo un objeto delante

257
00:36:33,699 --> 00:36:35,019
y es muy cerdo

258
00:36:35,019 --> 00:36:36,019
entonces

259
00:36:36,019 --> 00:36:39,099
leer la distancia me da un 2

260
00:36:39,099 --> 00:36:41,639
¿la distancia es menos que 3 centímetros?

261
00:36:42,699 --> 00:36:43,079
sí

262
00:36:43,079 --> 00:36:44,960
para los motores

263
00:36:44,960 --> 00:36:46,699
con lo cual me despeño

264
00:36:46,699 --> 00:36:47,500
ya lo he separado

265
00:36:47,500 --> 00:36:49,139
ya lo he hecho

266
00:36:49,139 --> 00:36:53,019
el motor 2 lo pongo hacia atrás

267
00:36:53,019 --> 00:36:53,599
que es este

268
00:36:53,599 --> 00:37:39,690
con lo cual el robot va girando ese ángulo, paramos el motor 2, con lo cual me he quedado en esta posición, esperamos 10 milisegundos y volvemos a medir, mido la distancia y me quedará 70 centímetros, con lo cual salgo por el no, y repito, el bucle B mide y activa motores, me quedo en este bucle, ¿hasta cuándo?, hasta que la distancia sea menos de 2 centímetros, cuando el robot me haya llegado aquí.

269
00:37:41,840 --> 00:37:47,139
y he hecho esto a costa para meterlo aquí en una pequeña jaula

270
00:37:47,139 --> 00:37:52,519
Bueno, ahora aquí el robot, ¿qué hacemos? lo mismo que antes

271
00:37:52,519 --> 00:37:56,960
¿es menor que 3 cm? sí, para poner motores

272
00:37:56,960 --> 00:38:03,159
motor 2 atrás, gira y entonces al girar se lo va a colocar así

273
00:38:03,159 --> 00:38:11,679
pero sería más cara que haría

274
00:38:11,679 --> 00:38:32,469
con lo cual va a esperar, va a medir la distancia y como sigue siendo menos de 30 metros, vuelve a salir por el sí y vuelve a girar, ¿vale?

275
00:38:33,349 --> 00:38:44,670
Se colocaría en ese ángulo después de dos giros y ahora ya sí, en ese ángulo, tiraría por adelante y volvería a usar la núclea de él.

276
00:38:44,670 --> 00:38:52,550
entonces lo hago yo aquí

277
00:38:52,550 --> 00:38:54,710
para que veáis como funciona

278
00:38:54,710 --> 00:38:56,769
este ejemplo primero lo voy a hacer yo

279
00:38:56,769 --> 00:38:59,190
y luego el próximo día pues ya haremos

280
00:38:59,190 --> 00:39:01,389
algún otro ejemplo de otro robot que haga otra cosa

281
00:39:01,389 --> 00:39:01,889
¿vale?

282
00:39:03,489 --> 00:39:03,869
bien

283
00:39:03,869 --> 00:39:09,840
no tardo nada en hacerlo con lo cual

284
00:39:09,840 --> 00:39:10,940
ya veréis que es muy rápido

285
00:39:10,940 --> 00:39:15,280
algoritmo, fin de algoritmo, voy a poner aquí

286
00:39:15,280 --> 00:39:15,940
robot

287
00:39:15,940 --> 00:39:19,179
evita obstáculos

288
00:39:19,179 --> 00:39:20,139
¿vale?

289
00:39:21,000 --> 00:39:23,579
mirad, lo primero, lo importante, fijaros aquí

290
00:39:23,579 --> 00:39:24,780
en la pizarra

291
00:39:24,780 --> 00:39:42,760
Lo primero, necesito un repetir mientras. Esta estructura me dice que mientras que ocurra una expresión lógica, que es la condición, pero la condición que hemos dicho que tengo que poner, true, verdadero.

292
00:39:42,760 --> 00:39:45,440
¿Vale? Mientras sea verdadero

293
00:39:45,440 --> 00:39:47,440
Esto, espera, no, perdón

294
00:39:47,440 --> 00:39:49,019
Tengo que poner verdadero porque está en español

295
00:39:49,019 --> 00:39:51,639
¿Vale? Ahí me sale

296
00:39:51,639 --> 00:39:52,780
Efectivamente, ahí está

297
00:39:52,780 --> 00:39:55,539
Mientras verdadero, a cero

298
00:39:55,539 --> 00:39:57,340
Con lo cual no va a salir de núcleo ya nunca

299
00:39:57,340 --> 00:39:59,079
Y ahora

300
00:39:59,079 --> 00:40:00,880
¿Qué es lo que tengo que hacer?

301
00:40:00,960 --> 00:40:03,400
Bueno, pues lo primero que tengo que hacer es leer los sensores

302
00:40:03,400 --> 00:40:05,099
Por lo tanto escribimos

303
00:40:05,099 --> 00:40:11,320
Introduce distancia

304
00:40:11,320 --> 00:40:13,539
dos puntos de espacio

305
00:40:13,539 --> 00:40:15,659
comillas

306
00:40:15,659 --> 00:40:18,039
leemos la distancia

307
00:40:18,039 --> 00:40:21,329
dist

308
00:40:21,329 --> 00:40:24,170
después

309
00:40:24,170 --> 00:40:26,989
directamente me doy al bucle sí entonces

310
00:40:26,989 --> 00:40:28,909
¿cuál es la expresión lógica?

311
00:40:29,670 --> 00:40:31,469
distancia es menor

312
00:40:31,469 --> 00:40:33,050
voy a volverla un poquito más

313
00:40:33,050 --> 00:40:35,289
de 10 centímetros para no juntarnos tanto

314
00:40:35,289 --> 00:40:37,389
¿vale? distancia es menor que 10

315
00:40:37,389 --> 00:40:39,989
si la distancia es menor que 10

316
00:40:39,989 --> 00:40:40,949
entonces

317
00:40:40,949 --> 00:41:14,659
Entonces tenemos que primero parar motores, después enciende motor 2 hacia atrás, después esperamos, aquí vamos a poner una espera, esperar un segundo, con lo cual el programa se va a quedar parado,

318
00:41:14,659 --> 00:41:31,989
Y después de un segundo va a poner parar motor 2, ¿vale? Parar motor 2. Es justo lo que tengo ahí, ¿no? En el organigrama.

319
00:41:31,989 --> 00:42:06,460
Vale, y si no, ¿qué es lo que tengo que hacer? Escribir arranca motor 1 adelante y arranca motor 2 hacia adelante.

320
00:42:06,460 --> 00:42:09,780
Vale, ya estaría

321
00:42:09,780 --> 00:42:12,300
¿Vale? Y aquí al final del sí

322
00:42:12,300 --> 00:42:13,300
Detrás

323
00:42:13,300 --> 00:42:15,380
Tengo que poner una, esperar

324
00:42:15,380 --> 00:42:19,590
Esperar

325
00:42:19,590 --> 00:42:21,369
Voy a ponerlo otro segundo, venga

326
00:42:21,369 --> 00:42:23,309
Para que no, vale, puedo ponerle milisegundos

327
00:42:23,309 --> 00:42:24,630
Pero le voy a poner un segundo

328
00:42:24,630 --> 00:42:26,670
O cero como un segundo, me da igual, ¿vale?

329
00:42:27,130 --> 00:42:28,130
Esperar un segundo

330
00:42:28,130 --> 00:42:31,650
Venga, perfecto

331
00:42:31,650 --> 00:42:33,070
Vamos a ejecutarlo

332
00:42:33,070 --> 00:42:35,510
Ya sería el programa completo

333
00:42:35,510 --> 00:42:37,369
Hemos copiado lo que tenemos en el organigrama

334
00:42:37,369 --> 00:42:37,670
Venga

335
00:42:37,670 --> 00:42:41,250
¿Vale? Ah, me dice que falta una humedad

336
00:42:41,250 --> 00:42:42,610
¿Dónde? En la línea 8

337
00:42:42,610 --> 00:42:44,250
Ah, vale

338
00:42:44,250 --> 00:42:59,730
Vale, me faltaba el segundo

339
00:42:59,730 --> 00:43:01,210
Para que lo hiciera bien

340
00:43:01,210 --> 00:43:03,530
Venga, ya lo tengo aquí

341
00:43:03,530 --> 00:43:04,969
Venga, introduce la distancia

342
00:43:04,969 --> 00:43:07,449
Vamos a ponerle 50 centímetros

343
00:43:07,449 --> 00:43:09,869
Motor 1 adelante, motor 2 hacia adelante

344
00:43:09,869 --> 00:43:11,510
Espera el segundo que le hemos dicho

345
00:43:11,510 --> 00:43:12,630
Introduce la distancia

346
00:43:12,630 --> 00:43:14,170
Ya estamos a 30

347
00:43:14,170 --> 00:43:16,730
¿Vale? Seguimos hacia adelante

348
00:43:16,730 --> 00:43:17,969
Ahora estamos a 20

349
00:43:17,969 --> 00:43:19,670
Seguimos hacia delante

350
00:43:19,670 --> 00:43:21,670
Vamos a 16 centímetros

351
00:43:21,670 --> 00:43:23,190
Seguimos hacia delante

352
00:43:23,190 --> 00:43:25,050
11 centímetros

353
00:43:25,050 --> 00:43:26,190
Seguimos hacia delante

354
00:43:26,190 --> 00:43:27,510
Y ya me he acercado suficiente

355
00:43:27,510 --> 00:43:29,070
Ahora estamos a 8 centímetros

356
00:43:29,070 --> 00:43:31,550
Para el motor 2

357
00:43:31,550 --> 00:43:33,829
O sea, perdona, parar los motores

358
00:43:33,829 --> 00:43:34,849
Motor 2 hacia atrás

359
00:43:34,849 --> 00:43:38,510
Luego lo para y luego me vuelve a pedir un producto a la distancia

360
00:43:38,510 --> 00:43:40,150
Ha hecho todo el proceso del giro

361
00:43:40,150 --> 00:43:41,030
¿Vale?

362
00:43:41,969 --> 00:43:43,769
¿Cuánto mide la distancia ahora?

363
00:43:43,889 --> 00:43:45,789
Pues ahora ya mide 34 centímetros

364
00:43:45,789 --> 00:43:46,909
Pues otra vez hacia delante

365
00:43:46,909 --> 00:43:51,769
le va a estar continuamente preguntándole al sensor de distancia

366
00:43:51,769 --> 00:43:55,929
cuánto mide y va a estar tomando decisiones en función de la medida

367
00:43:55,929 --> 00:43:59,309
y en función de que esté muy cerca, uno del objeto

368
00:43:59,309 --> 00:44:03,309
me va a hacer una acción u otra, y así le hemos hecho un robot

369
00:44:03,309 --> 00:44:06,590
fijaros que es fácil, y no termina nunca, os dais cuenta de que esto no termina nunca

370
00:44:06,590 --> 00:44:10,989
lo puedo tirar así toda la vida, yo le puedo poner el número que me dé la gana que esto no termina nunca

371
00:44:10,989 --> 00:44:15,690
¿vale? bien, si nos fijamos en el diagrama de flujo

372
00:44:16,909 --> 00:44:27,829
veréis que la estructura tiene una salida del bucle hacia el final, pero que no se va a coger nunca.

373
00:44:28,250 --> 00:44:31,630
¿Por qué? Porque la condición es verdadera, por lo cual siempre voy a coger la salida V.

374
00:44:33,150 --> 00:44:35,969
Y no voy a salir nunca por ahí. Esta es una salida que me la puedo ahorrar.

375
00:44:36,250 --> 00:44:44,739
Si yo le pusiera que el bucle mientras se cumpliera, o sea, se ejecutara durante una condición,

376
00:44:44,880 --> 00:44:48,780
hasta que se cumpla, mientras se cumpla una condición, entonces estaríamos poniéndole ahí una condición.

377
00:44:48,780 --> 00:45:00,880
Pues esta es la forma en la que se simulan programación de robots con PCI, ¿vale?

378
00:45:01,739 --> 00:45:05,960
Y la forma en la que hacemos los algoritmos para que luego podamos programarlos.