1
00:00:12,080 --> 00:00:17,000
Bueno, pues vamos a ver la introducción a la programación de robot con unos conceptos básicos.

2
00:00:18,179 --> 00:00:30,679
Empezaremos viendo qué es un robot y para entender qué es un robot tenemos que entender que un robot no es otra cosa que un sistema que recoge información de unos sensores,

3
00:00:30,679 --> 00:00:39,219
procesa la información recogida y después decide si actúa o no sobre ciertos actuadores,

4
00:00:39,219 --> 00:00:44,920
sobre ciertos elementos que sirven para devolver acciones al entorno,

5
00:00:45,200 --> 00:00:46,939
pueden ser luces, motores o lo que sea.

6
00:00:47,899 --> 00:00:53,219
Entonces, los sensores de entrada serían un sensor de distancia, un pulsador,

7
00:00:53,859 --> 00:00:59,619
que es un sensor de presión, o un sensor de luminosidad, un sensor de temperatura,

8
00:00:59,619 --> 00:01:06,599
cualquier cosa que detecte una magnitud del entorno y la pueda introducir a través de un valor a nuestra placa de control.

9
00:01:07,420 --> 00:01:15,060
Tendremos la placa de control, ahí veis, crumble o la placa de arduino que tiene más conexiones de entrada y salida.

10
00:01:15,780 --> 00:01:20,239
Y por último, actuadores, podemos ver que son luces, motores o cosas de este estilo.

11
00:01:22,219 --> 00:01:28,099
Para poder conectar todas estas cosas entre la placa controladora y el propio dispositivo,

12
00:01:28,099 --> 00:01:36,359
vamos a utilizar cables, cables que irán desde los terminales o pines de los sensores o de los actuadores

13
00:01:36,359 --> 00:01:41,079
a los terminales o pines de nuestra placa de control.

14
00:01:41,780 --> 00:01:46,659
La placa de control lleva siempre un procesador que es el que se encarga de recibir esa información

15
00:01:46,659 --> 00:01:52,219
y hacer algo con ella, es decir, procesarla y tomar decisiones, por supuesto.

16
00:01:53,120 --> 00:01:55,760
Y eso es básicamente lo que sería un robot.

17
00:01:55,760 --> 00:02:05,579
Si lo ponemos todo junto, pues al final recogemos información de las entradas, la procesamos en la plaga de control y después actuamos o no sobre los actuadores.

18
00:02:06,599 --> 00:02:13,759
Bien, poniendo esto un poquito en orden, veremos que un programa de robots, lo primero es un programa infinito.

19
00:02:14,800 --> 00:02:23,379
Es decir, es un programa que no termina nunca. Un programa que cuando se termina de ejecutar, volvemos a la primera línea y volvemos a ejecutarlo de forma íntegra.

20
00:02:23,379 --> 00:02:47,780
Y así de forma infinita hasta que apaguemos el robot. Por lo tanto, lo primero que va a hacer un robot va a ser leer sus sensores, los que tenga conectados, va a asignar los valores que ha recibido de esos sensores a ciertas variables, es decir, va a almacenar la información en unas cajitas, en unos espacios donde yo luego podré recuperar esa información.

21
00:02:47,780 --> 00:03:03,240
Es como apuntarlo en un bloc de notas. Básicamente voy a poner una caja, le voy a poner una etiqueta que es el nombre de la caja y dentro voy a poder meter un valor. Pues bien, esos valores que yo recibo de los sensores los meteré en cajitas para luego poder acceder a ellos.

22
00:03:03,240 --> 00:03:09,180
Después accederemos a esos valores, los procesaremos y tomaremos decisiones

23
00:03:09,180 --> 00:03:17,639
Y diremos, bueno, pues en este caso haremos o no ciertas cosas sobre motores, sobre luces o sobre actuadores

24
00:03:17,639 --> 00:03:20,560
Y eso es lo que haremos después de tomar la decisión

25
00:03:20,560 --> 00:03:25,240
Tomaremos decisiones en función de los valores y al final actuaremos si es necesario

26
00:03:25,240 --> 00:03:30,300
Y volvemos a empezar, leemos los sensores, asignamos las lecturas a las variables

27
00:03:30,300 --> 00:03:35,159
procesamos la información tomamos las decisiones y actuamos si es necesario y vuelta a empezar y

28
00:03:35,159 --> 00:03:49,909
así infinitamente hasta que el robot se pare se apague o quitemos las pilas bueno así que en

29
00:03:49,909 --> 00:04:04,069
esencia yo lo que tengo son sensores que son las entradas a mi sistema entradas a mi sistema estos

30
00:04:04,069 --> 00:04:14,550
sensores van a alimentar mi placa microcontroladora de información. Esta placa microcontroladora

31
00:04:14,550 --> 00:04:25,100
va a tomar decisiones en función de esa información y si es necesario lo que va a hacer es activar

32
00:04:25,100 --> 00:04:36,660
estos actuadores que son las salidas del sistema, del robot. Por lo tanto yo tengo aquí en

33
00:04:36,660 --> 00:04:48,790
este robot obligatoriamente que programar. Tengo que hacer un programa que reciba esos

34
00:04:48,790 --> 00:04:57,269
valores, los procese, tome decisiones y actúe en caso de necesidad. Y por supuesto, tanto

35
00:04:57,269 --> 00:05:11,129
los sensores como los actuadores, lo que tendremos será una conexión, conexión eléctrica.

36
00:05:11,269 --> 00:05:18,610
para poder tanto recibir la información de los sensores como poder informar a los actuadores que se activen o no.

37
00:05:19,889 --> 00:05:26,689
Entonces, primero tenemos que saber cómo conectar mis dispositivos de entrada y salida

38
00:05:26,689 --> 00:05:31,990
y luego tenemos que saber cómo programar mi placa de control para tomar esas decisiones.

39
00:05:31,990 --> 00:05:38,449
Y en esto es en lo que nos vamos a centrar en la programación de robots, tanto en la conexión como en la programación.

40
00:05:38,449 --> 00:05:46,449
Bueno, la placa controladora que nosotros vamos a utilizar se llama CRAM y tiene esta pinta.

41
00:05:46,449 --> 00:05:54,449
Básicamente es una placa que vemos que tiene en su centro este procesador que es el que se va a encargar de ejecutar el programa.

42
00:05:54,449 --> 00:06:02,569
el programa. Nosotros el programa lo haremos a través de una aplicación en un PC y con

43
00:06:02,569 --> 00:06:10,389
este puerto USB lo descargaremos el programa para que se ejecute en este procesador. Y

44
00:06:10,389 --> 00:06:15,949
luego la placa tiene conexiones, conexiones que llamaremos terminales. Estos terminales

45
00:06:15,949 --> 00:06:21,370
si os fijáis están con etiquetas, vamos a ver que es cada uno de ellos. Aquí arriba

46
00:06:21,370 --> 00:06:25,689
a la izquierda, estos dos que pone positivo y negativo, serán los que utilizaremos para

47
00:06:25,689 --> 00:06:33,350
conectar las pilas. Esta conexión alimentará de corriente eléctrica mi placa y será la

48
00:06:33,350 --> 00:06:40,009
que utilizaremos para poder ejecutar el programa y tomar las decisiones. Como hemos dicho,

49
00:06:40,850 --> 00:06:46,050
yo tengo que conectar a esta placa tanto sensores como actuadores. Para ello utilizaremos estos

50
00:06:46,050 --> 00:06:52,850
cuatro terminales, A, B, C y D. A través de estos terminales yo recibiré la información

51
00:06:52,850 --> 00:06:59,930
o informaré a los actuadores que se deben de activar, pero si lo que tengo son motores,

52
00:07:00,230 --> 00:07:04,170
si el actuador que yo tengo son motores, vamos a utilizar estas conexiones de aquí abajo

53
00:07:04,170 --> 00:07:10,410
que son específicas para motores. Vemos que tienen un positivo y un negativo y directamente

54
00:07:10,410 --> 00:07:16,730
están etiquetadas por parejas, 1 y 2. Entonces, si yo tengo un motor, lo conectaremos aquí

55
00:07:16,730 --> 00:07:21,290
debajo. Pero si tengo cualquier otro actuador, como puede ser una luz, lo conectaré a través

56
00:07:21,290 --> 00:07:28,170
de estos terminales que son de entrada y salida. Entrada son para los sensores y salida cuando

57
00:07:28,170 --> 00:07:34,589
conecto actuadores. Y esos sensores y actuadores también deben de recibir corriente eléctrica.

58
00:07:34,589 --> 00:07:51,050
Para eso utilizaremos estos dos terminales. Por lo tanto, esta parte de arriba es la parte que tiene que ver con los voltios. Aquí a la izquierda serán los voltios que yo meto a la placa para conectarla y activarla y alimentarla de corriente eléctrica.

59
00:07:51,050 --> 00:07:56,550
y por aquí sacaré la corriente eléctrica que necesito para que los sensores y los actuadores

60
00:07:56,550 --> 00:07:59,610
que yo conecto en estos terminales del centro funcionen.

61
00:08:00,970 --> 00:08:06,189
Pero si lo que tengo son motores, utilizaré directamente estas conexiones.

62
00:08:06,930 --> 00:08:12,990
En resumen, tenemos esto que vemos aquí, un puerto USB que usaremos para programar,

63
00:08:14,329 --> 00:08:19,730
una entrada de corriente eléctrica donde alimentaremos con 4,5 o 5,5 voltios,

64
00:08:19,730 --> 00:08:31,829
la salida de corriente eléctrica que yo utilizaré para los sensores, cuatro terminales que serán donde yo recibiré las señales de esos sensores indicando que está ocurriendo en el entorno

65
00:08:31,829 --> 00:08:40,789
o también las que yo utilizaré para activar los actuadores que no sean motores. ¿Por qué que no sean motores?

66
00:08:40,789 --> 00:08:49,929
Porque si son motores usaré estos puertos de aquí abajo, estas terminales de aquí abajo, que están ya etiquetados como positivo y negativo para conectar motores.

67
00:08:50,610 --> 00:09:00,070
Y además vienen con un LED pequeñito, con una lucecita, que cuando el motor esté activado la luz se va a encender y cuando el motor se desactive esta luz se va a apagar.

68
00:09:00,070 --> 00:09:33,340
Por lo tanto, mi placa de control tiene 12 conexiones. Estas de aquí arriba hemos dicho que es para la entrada de 4,5 voltios y estas es para la salida de 4,5 voltios para sensores y actuadores.

69
00:09:33,340 --> 00:09:37,139
si yo tengo sensores o actuadores

70
00:09:37,139 --> 00:09:40,779
los conectaré utilizando estos puertos de aquí

71
00:09:40,779 --> 00:09:43,960
que hemos etiquetado como A, B, C y D

72
00:09:43,960 --> 00:09:46,600
mientras que estos de aquí arriba

73
00:09:46,600 --> 00:09:48,399
veíamos que estaban como más y menos

74
00:09:48,399 --> 00:09:49,980
puesto que son de corriente eléctrica

75
00:09:49,980 --> 00:09:53,379
y por último, si yo lo que tengo son motores

76
00:09:53,379 --> 00:09:56,500
voy a tener dos conexiones a motores

77
00:09:56,500 --> 00:10:04,090
que están etiquetadas como 1 o 2

78
00:10:04,830 --> 00:10:06,049
Eso es si tengo motores.

79
00:10:06,769 --> 00:10:09,049
Bien, vamos a hacer un programa sencillito.

80
00:10:10,009 --> 00:10:11,309
Imaginaros que yo tengo un botón.

81
00:10:14,500 --> 00:10:21,240
Cuando yo lea en estos puertos, en estos terminales, el valor, ¿yo qué puedo leer?

82
00:10:21,519 --> 00:10:28,740
Puedo leer si hay o no hay corriente eléctrica o qué valor de la corriente eléctrica existe en ese terminal.

83
00:10:28,740 --> 00:10:49,100
Entonces, lo normal es que yo siempre en programación utilice los valores lógicos 0 y 1. En programación siempre se usan 0 o 1. El 0 equivaldría a 0 voltios, el 1 a 4,5 voltios.

84
00:10:49,100 --> 00:11:05,919
Y siempre se corresponden con las características de activado o desactivado, conectado o desconectado, verdadero o falso, positivo o negativo, es decir, siempre van a tener ese carácter dual que me informa de algo que está ocurriendo o no.

85
00:11:05,919 --> 00:11:09,799
¿Vale? Por tanto, imaginaos este botón

86
00:11:09,799 --> 00:11:14,879
Yo el botón lo voy a conectar por un lado a esta conexión que son 4 voltios y medio

87
00:11:14,879 --> 00:11:19,100
Y de por el otro lado le voy a poner conectado en A

88
00:11:19,100 --> 00:11:24,899
Bien, si yo ahora ejecutara un programa cuya primera orden fuera

89
00:11:24,899 --> 00:11:48,399
Ahora, lee el valor de A y ponlo en botón. ¿Qué es lo que quiere decir esto? Pues yo voy a crearme un espacio en esta placa de control.

90
00:11:48,399 --> 00:11:57,779
yo voy a traerme un espacio que es una caja, voy a ponerla aquí, una caja y la voy a etiquetar como botón.

91
00:11:59,019 --> 00:12:04,539
Esta caja inicialmente está vacía, pero yo puedo poner ahí dentro los valores que yo quiera, ¿vale?

92
00:12:04,600 --> 00:12:09,419
Es una caja, un almacén para recordar o para guardar cierta información.

93
00:12:10,220 --> 00:12:13,340
Entonces, ¿yo qué voy a hacer? Pues cuando ejecute esta línea en mi programa,

94
00:12:13,340 --> 00:12:28,500
Aquí el procesador que estaba aquí en medio va a ejecutar este programa y va a decir, mira lo que está ocurriendo en A, en este terminal que hemos llamado A. Y sea lo que sea, lo introduces dentro de la caja que yo he creado que se llama botón.

95
00:12:28,500 --> 00:12:45,820
Muy bien, pues entonces, fijaros, si el botón no está pulsado, este cable está cortado, no está pulsado, por lo tanto no está conectado. Y estos 4,5 voltios no están llegando a A. Por lo tanto, cuando yo lea el valor de A, lo que voy a leer es un cero.

96
00:12:45,820 --> 00:13:06,240
Y ese 0 será el que voy a meter dentro del botón. Esto es cuando no pulso el botón. ¿Pero qué ocurre si yo lo pulso? Cuando yo pulso ese botón, estos 4,5 voltios, ahora está cerrado el circuito y sí que están llegando aquí.

97
00:13:06,240 --> 00:13:20,360
Por lo tanto, lo que yo estaré metiendo dentro de la variable botón será un 1, botón, pulsado. ¿Por qué? Porque un 1 se corresponde con esos 4 voltios y medio.

98
00:13:21,120 --> 00:13:35,700
Entonces, cuando yo estoy ejecutando esta orden, lee el valor de A y ponlo en botón, lo que estoy haciendo es mirar qué ocurre en ese terminal y, sea lo que sea, lo guardo dentro de esta caja, para luego poderlo recordar.

99
00:13:36,240 --> 00:13:47,860
Y ahora vamos a completar nuestro circuito poniendo una cosa más. En D voy a conectar una luz. Aquí voy a conectar un diodo, una lucecita.

100
00:13:47,860 --> 00:13:51,259
lo voy a conectar de esta forma

101
00:13:51,259 --> 00:13:52,659
al negativo

102
00:13:52,659 --> 00:13:54,960
por lo tanto, fijaros

103
00:13:54,960 --> 00:13:56,720
cuando yo active D

104
00:13:56,720 --> 00:13:59,779
cuando yo le diga a través de una línea

105
00:13:59,779 --> 00:14:01,639
de orden de mi programa

106
00:14:01,639 --> 00:14:03,080
activa D

107
00:14:03,080 --> 00:14:04,919
pondré 4 voltios y medio en D

108
00:14:04,919 --> 00:14:06,639
¿y qué ocurrirá con la luz?

109
00:14:07,080 --> 00:14:09,539
que se encenderá, porque tendrá 4 voltios y medio y cero

110
00:14:09,539 --> 00:14:11,759
estará como conectado a una pila

111
00:14:11,759 --> 00:14:12,620
y entonces se encenderá

112
00:14:12,620 --> 00:14:15,179
pero ¿qué pasa si yo le digo que no me active D?

113
00:14:15,580 --> 00:14:16,860
aquí estarán 0 voltios

114
00:14:16,860 --> 00:14:21,039
y por lo tanto no se encendera la luz.

115
00:14:21,399 --> 00:14:24,779
Entonces, fijaros, la segunda línea de mi programa va a ser

116
00:14:24,779 --> 00:14:28,220
lee el valor de A y ponlo en botón.

117
00:14:29,159 --> 00:14:35,399
Si lo que tengo dentro de botón es cero,

118
00:14:36,399 --> 00:14:38,740
¿qué voy a hacer?

119
00:14:38,879 --> 00:14:41,960
Si es cero, pues si no está pulsado el botón,

120
00:14:42,019 --> 00:14:43,600
yo lo que quiero es que la luz no se encienda.

121
00:14:43,600 --> 00:15:15,429
Entonces, desactiva D. Es decir, en D voy a poner 0 voltios. Pero, si botón es 1, entonces activa D. Por lo tanto, a D le voy a poner 4,5 voltios.

122
00:15:15,429 --> 00:15:19,409
¿veis? entonces, ahora

123
00:15:19,409 --> 00:15:23,730
¿qué está haciendo este programa? vamos a leer el valor de A

124
00:15:23,730 --> 00:15:28,009
si el botón no está pulsado, ¿vale? si el botón no está pulsado

125
00:15:28,009 --> 00:15:31,190
desactivamos D, es decir, ponemos aquí 0 voltios y entonces la luz

126
00:15:31,190 --> 00:15:35,409
permanece apagada, y cuando termina el programa de ejecutarse

127
00:15:35,409 --> 00:15:41,879
que hemos dicho que ocurre con un robot, que vuelve al inicio

128
00:15:41,879 --> 00:15:45,580
y lo vuelve a ejecutar, por lo tanto, empezamos

129
00:15:45,580 --> 00:15:51,820
leemos y si es cero desactivamos desactivamos desactivamos hasta cuando hasta que llegue aquí

130
00:15:51,820 --> 00:15:59,980
y haga punto y lo pulse cuando lo pulse que va a ocurrir lo que va a ocurrir es que el valor de la

131
00:15:59,980 --> 00:16:05,679
variable a va a cambiar a uno y yo voy a introducir en ese caso dentro de la variable botón dentro de

132
00:16:05,679 --> 00:16:12,100
esta caja voy a meter el valor 1 si botón es 1 entonces activamos de por lo tanto podemos aquí

133
00:16:12,100 --> 00:16:15,480
cuatro voltios y medio y la luz se enciende. Entonces este robot lo que estaría haciendo

134
00:16:15,480 --> 00:16:20,740
es que cuando yo pulso el botón la luz se enciende y cuando dejo de pulsarlo la luz

135
00:16:20,740 --> 00:16:25,860
se apaga. Tan sencillo como eso. Y con eso habremos construido nuestro primer robot y

136
00:16:25,860 --> 00:16:32,539
habremos construido nuestro primer programa. Podemos hacer otro programa también muy sencillito

137
00:16:32,539 --> 00:16:39,840
para los motores. Por ejemplo, voy a coger otra hoja, la voy a poner aquí debajo, aquí

138
00:16:39,840 --> 00:16:48,279
así, ¿de acuerdo? Y vamos a hacer otro programa. Voy a hacer un programa en donde utilicemos

139
00:16:48,279 --> 00:17:00,919
estos motores. El programa puede decir lo siguiente. Línea 1, activa el motor 1 al

140
00:17:00,919 --> 00:17:23,289
100% hacia adelante. Línea 2, activa el motor 2 al 100% también hacia adelante. Línea

141
00:17:23,289 --> 00:17:42,670
3, espera, 1 segundo. 4, apaga, motor, 1. 5, apaga, motor, 2. Y línea 6, voy a subir

142
00:17:42,670 --> 00:17:55,710
un poquito para verlo bien. Línea 6 sería, espera un segundo. Bueno, vamos a ver qué

143
00:17:55,710 --> 00:18:03,210
hace este programa. Fijaros, yo tengo mi placa con dos motores. Voy a suponer que en estos

144
00:18:03,210 --> 00:18:15,940
motores tengo un par de ruedas, ¿vale? Conectadas. Un par de ruedas. ¿De acuerdo? Entonces, ¿qué

145
00:18:15,940 --> 00:18:20,940
ocurre? Fijaros, el programa hace lo siguiente, activa el motor 1 al 100% hacia delante, activa

146
00:18:20,940 --> 00:18:24,500
el motor 2 al 100% hacia delante. Si los dos motores se mueven en la misma dirección,

147
00:18:25,559 --> 00:18:36,680
lo que tendré es que esta placa junto con los motores y las ruedas avanzarán, van a

148
00:18:36,680 --> 00:18:42,039
porque tengo una rueda aquí, voy a mirarlo desde arriba, otra rueda aquí, y si las dos

149
00:18:42,039 --> 00:18:47,180
ruedas giran hacia delante, el robot avanza. Y eso va a estar avanzando durante un segundo

150
00:18:47,180 --> 00:18:52,420
y al llegar al segundo, ¿qué va a hacer? Se va a parar, ¿vale? Es decir, durante un

151
00:18:52,420 --> 00:19:01,019
segundo y llega aquí y se para el robot, para los dos motores y se para durante un

152
00:19:01,019 --> 00:19:06,440
segundo. ¿Y qué ocurre cuando termina el programa? Hemos dicho que cuando un programa

153
00:19:06,440 --> 00:19:14,859
de un robot termina. Entonces, después de esperar este segundo, volvemos arriba, activamos

154
00:19:14,859 --> 00:19:21,200
el motor 1, activamos el motor 2 y el robot vuelve a avanzar durante otro segundo y vuelve

155
00:19:21,200 --> 00:19:26,160
a pararse. Y el programa simplemente va a hacer eso, va a hacer que el robot avance

156
00:19:26,160 --> 00:19:31,480
durante un segundo y se pare durante un segundo. Avanza durante un segundo y pare durante un

157
00:19:31,480 --> 00:19:36,720
segundo. Avanza durante un segundo y pare durante un segundo. Y así infinitamente.

158
00:19:37,500 --> 00:19:41,119
¿Qué ocurre? Que como no tengo ningún sensor conectado, en este caso,

159
00:19:42,160 --> 00:19:45,759
pues el robot si llega a un obstáculo o a una pared, se estrellará.

160
00:19:47,039 --> 00:19:54,380
Bueno, eso lo arreglamos poniéndole a este robot un sensor de distancia, aquí delante,

161
00:19:54,380 --> 00:19:58,279
y este robot con un sensor de distancia, aquí delante,

162
00:19:59,319 --> 00:20:05,920
si a este programa le añadimos una línea que diga, aquí por ejemplo,

163
00:20:06,720 --> 00:20:20,039
lee distancia. Y después decimos, si distancia es menor que 10 centímetros, para. Y si no,

164
00:20:21,400 --> 00:20:37,779
si la distancia es menor que 10 centímetros, para y espera un segundo. Bien. Fijaros, ¿qué

165
00:20:37,779 --> 00:20:42,460
es lo que he hecho ahora? He cambiado un poquito el programa. Activa el motor 1 al 100% hacia

166
00:20:42,460 --> 00:20:48,930
adelante, activa el motor 2, hacia adelante, bien, voy a ponerlo aquí y el robot avanza.

167
00:20:49,829 --> 00:20:53,430
Y el sensor de distancia mira a ver si hay un obstáculo. Voy a poner un obstáculo,

168
00:20:53,430 --> 00:21:01,509
por ejemplo, aquí. Bien, ¿qué ocurre? Pues que en este momento mido la distancia

169
00:21:01,509 --> 00:21:07,150
y son 50 centímetros, no hay problema, pues seguimos avanzando. ¿Por qué? Porque la

170
00:21:07,150 --> 00:21:14,049
distancia, si la distancia es menor que 10, lo que tengo que hacer es ejecutar este trozo

171
00:21:14,049 --> 00:21:18,269
de código y si no, simplemente espero un segundo y vuelvo arriba. Por lo tanto, vuelvo

172
00:21:18,269 --> 00:21:23,230
a activar los motores que ya están activados, no hace nada, sigue avanzando, ahora estamos

173
00:21:23,230 --> 00:21:29,670
aquí y vuelvo a leer la distancia. ¿Sigue siendo mayor de 10 centímetros? Sigo avanzando,

174
00:21:30,470 --> 00:21:37,309
ya estoy aquí y vuelvo a leer la distancia. ¿Es mayor de 10 centímetros? Sigo avanzando,

175
00:21:37,309 --> 00:21:56,730
Ya estoy aquí y leo la distancia y digo, ahora ya son 9 centímetros. Este obstáculo lo tengo a menos de 10 centímetros, por lo tanto, ¿qué hace el robot? Entra dentro de esta decisión y dice, vale, apaga el motor 1, apaga el motor 2. Los paro, con lo cual ya no me estrelló.

176
00:21:56,730 --> 00:22:04,430
y además lo he compuesto aquí gira, que gira es poner el motor de un lado andando hacia delante

177
00:22:04,430 --> 00:22:08,509
y el motor del otro andando hacia detrás, si yo un motor lo hago girar hacia delante

178
00:22:08,509 --> 00:22:13,130
y otro motor lo hago girar hacia detrás, lo que hace el robot es girar sobre sí mismo

179
00:22:13,130 --> 00:22:24,170
por lo tanto el robot gira, giro el robot y lo pongo mirando y después de eso vuelvo a activar el motor 1

180
00:22:24,170 --> 00:22:30,589
activar el motor 2 y el robot tira para delante y ¿hasta dónde va a avanzar?

181
00:22:30,589 --> 00:22:35,589
hasta que encuentre otro obstáculo. Cuando encuentre otro obstáculo y esté a menos

182
00:22:35,589 --> 00:22:42,829
de 10 centímetros, parará, girará, se pondrá mirando en otra dirección y volverá a avanzar

183
00:22:42,829 --> 00:22:48,869
y así infinitamente. Y así habremos construido un robot que evita los obstáculos. Cualquier

184
00:22:48,869 --> 00:22:53,130
obstáculo que se encuentre este robot lo va a evitar, se va a parar, va a girar y no

185
00:22:53,130 --> 00:22:59,930
va a chocarse contra él. Bueno, pues esto es así de sencillo como nosotros vamos a

186
00:22:59,930 --> 00:23:05,529
trabajar con los robots y esto es un poco la introducción a este tema ahora

187
00:23:05,529 --> 00:23:12,170
bien esto que hemos escrito aquí se llama pseudocódigo

188
00:23:12,490 --> 00:23:15,190
por qué

189
00:23:15,630 --> 00:23:18,190
segundo

190
00:23:18,890 --> 00:23:25,400
porque pues esto se llama pseudocódigo porque yo lo he escrito como yo hablo

191
00:23:25,400 --> 00:23:30,440
activa el motor ponte hacia delante hacia detrás y tal este pseudocódigo

192
00:23:30,440 --> 00:23:36,160
está escrito en lenguaje normal de una persona. Cuando yo esto lo escribo con el lenguaje

193
00:23:36,160 --> 00:23:44,599
de programación específico, entonces lo que estaría haciendo es programar. Por lo

194
00:23:44,599 --> 00:23:50,599
tanto, nosotros podemos escribir un programa en pseudocódigo y después transformarlo

195
00:23:50,599 --> 00:23:55,299
en un programa. En el caso de Cranbell, lo que vamos a utilizar es un programa, un entorno

196
00:23:55,299 --> 00:23:59,960
de programación por bloques, que es muy parecido a Scratch. Y ya veremos que tengo bloques

197
00:23:59,960 --> 00:24:10,339
para cada una de estas órdenes, para poderlas ir poniendo y ir haciendo que la placa tome las decisiones, que ejecute, que lea, que almacene los valores, etc.

198
00:24:11,160 --> 00:24:17,039
Bueno, pues nada más, espero que haya sido de utilidad y nos vemos en la siguiente clase.