Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

4º ESO - TPR-PT. Programación de Robots con PseInt y Ejemplo de Robot Evita-Obstáculos. - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 1 de mayo de 2021 por Juan Ramã‼N G.

109 visualizaciones

Explicación de cómo simularemos la programación de Robots con PseInt y construcción de un ejemplo práctico haciendo el algoritmo de un Robot Evita-Obstáculos.

Más información Transcripción

Descargar la transcripción

Vamos a simular cómo hacer algoritmos y programas usando PSI, ¿vale? 00:00:22
Es una simulación porque evidentemente PSI no le podemos conectar sensores, ni motores, ni luces, ¿vale? 00:00:31
Entonces tenemos que simularlo. ¿Cómo lo vamos a simular? 00:00:41
Pues lo vamos a simular a través de los mensajes que intercambiamos con el usuario, ¿vale? 00:00:45
Entonces, la simulación la haremos a través del intercambio de mensajes con el usuario, ¿vale? 00:00:50
Entonces, por ejemplo, supongamos que yo vengo en mi robot, quiero poner un sensor de distancia, ¿vale? 00:01:21
un sensor de distancia 00:01:37
que estará conectado 00:01:40
a mi 00:01:45
esto es sensor 00:01:45
de distancia 00:01:50
y esta es la microcontroladora 00:01:52
vale 00:01:55
yo desde la placa de control 00:01:57
puedo decir 00:02:01
tengo un comando 00:02:04
que es leer distancia 00:02:05
vale 00:02:08
sería leer distancia 00:02:12
y aquí 00:02:16
esto lo guardo 00:02:16
a distancia en una valla, ¿vale? 00:02:19
Yo en la microcontroladora 00:02:31
y el resultado en centímetros lo va a 00:02:33
guardar en... Esto sería un robot, un robot 00:02:51
¿Cómo lo haría? Pues lo metemos en un aparato electrónico 00:03:03
léete 00:03:08
¿Vale? En este caso 00:03:15
ya sé que es el sensor de distancia 00:03:18
pero lo que voy a hacer es leer 00:03:20
el pin 7 00:03:21
que el que lo ha programado 00:03:26
sabe que ahí lo que me está ofreciendo 00:03:29
es una distancia, porque 00:03:31
es el que lo ha conectado, ¿vale? 00:03:32
dice vale mira que te encuentras en el pin 7 00:03:39
en el pin 7 yo lo que tengo es la distancia que me está dando el medidor de distancia 00:03:44
y esa lectura la almaceno en distancia, eso es lo que haría otro robot 00:03:51
de acuerdo, por ejemplo si en el pin 9 tengo un motor 00:03:55
tengo un motorcito vale pues yo lo que voy a hacer es 00:04:02
activa el pin número 9 00:04:11
y entonces vamos a poner 4 voltios y medio que tiene, que están numerados 00:04:19
y va a estar activando o no activando la conexión donde están los actuadores 00:04:44
¿Vale? Bien, ¿cómo simulamos esto? 00:04:50
Esto sería el caso real, ¿vale? Esto sería el caso real 00:04:54
¿Cómo simulamos esto con PSI de distancia? 00:04:59
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. 00:05:09
Con este bloque, en pantalla, le va a aparecer al usuario que está aquí y yo, que hago el sensor de distancia. 00:05:38
Y lo meto con un le y lo almaceno de la manera misma. 00:05:55
Y a partir de aquí ya puedo seguir haciendo el programa. 00:06:02
Cuando tengo un sensor conectado a un plan de robots, yo lo que haré es leer directamente 00:06:05
el PSI, que es un programa de simulación de pseudocódigo. 00:06:20
Yo lo que voy a hacer es preguntarle al usuario para ir a distancia. 00:06:27
Este par de bloques sustituiría a este, el pin 7. 00:06:37
Y como no hago una activación de un pin, pues pues fácil. 00:06:43
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... 00:06:50
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. 00:08:14
y una salida 00:08:40
bueno 00:09:01
esa es la primera parte 00:09:05
ahora 00:09:07
¿cómo es un programa de robots? 00:09:08
no sé si ya os lo he explicado 00:09:14
¿cómo sería un programa de robots? 00:09:15
un robot 00:09:20
un programa de robots tiene la siguiente estructura 00:09:21
que es la segunda que tengo que simular 00:09:30
con PSI 00:09:45
¿cómo es un programa de 00:09:46
control de robots? 00:09:49
Como es el programa de estructura interna 00:09:51
O el programa que controla un robot 00:10:04
Bueno, siempre tiene la misma forma 00:10:06
¿Vale? 00:10:09
Un robot siempre hace las cosas de la misma forma 00:10:10
Y es de la siguiente 00:10:14
Lo primero que tenemos que hacer es 00:10:15
Leer los sensores 00:10:19
¿Vale? 00:10:25
Yo en mi robot tendría una serie de sensores 00:10:29
yo antes de hacer nada tengo que saber que ocurre a mi alrededor y yo tengo que tener esa información 00:10:31
¿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 00:10:50
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 00:11:05
Vale, voy a los sensores, les pregunto, dame tu medición de lo que sea, y eso lo guardo en una variable. 00:11:29
Bien, ya tenemos la información de lo que ocurre alrededor. 00:11:47
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, 00:12:00
a lo mejor la distancia la tengo que transformar en unidades o tengo que sumar dos cosas, 00:12:17
O tengo que hacer algún cálculo, o tengo que compensar algo, y después de procesarla, tomar decisiones. 00:12:22
Ok, ¿y cómo tomamos decisiones? Pues sabiendo lo que está pasando, estoy suficientemente cerca de la pared como para tener... 00:12:55
Decidiré activar o no activar. Activar, activar, activar o no activar. 00:13:08
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, 00:13:43
los sensores y veo que ha pasado. Vuelvo a agregar información, lo vuelvo a almacenar y hago lo que tenga que hacer. 00:14:25
Y en ese proceso de mirar lo que ocurre, guardar la información, procesarla, decidir y activar o... ¿Entendéis? 00:14:44
Cuando yo lo sigo todo en PSI, ¿qué tendremos? Lo primero es cómo hacemos que un programa no termine nunca. 00:15:03
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, 00:15:24
Mientras sea verdadero, pues haces lo que tengas que hacer. 00:16:00
Claro, como yo le estoy diciendo directamente que la condición es... 00:16:11
Entonces, este mientras de verdadero va a hacer que no salgamos del bucle mientras. 00:16:20
¿Ves ahí? Voy a simular el bucle infinito, ¿de acuerdo? Con un bucle mientras. 00:16:24
Pero el bucle mientras, era mientras se cumple una condición, ejecuta algo. 00:16:36
¿Qué ocurre? Que cada vuelta yo vuelvo a grabar algo. 00:16:42
Siempre va a ser verdadero. 00:16:58
Por lo tanto, mientras que sea verdadero, ejecute esto, pero va a ser verdadero siempre. 00:17:00
Se debe decir. 00:17:05
Mientras que va a dar error. 00:17:09
Bien. 00:17:11
Esa es la forma de circular. 00:17:12
Esto me va a poner una salida. 00:17:16
Luego, ¿cómo leemos los sensores? 00:17:20
Pues con el comando leer. 00:17:24
Ya lo hemos visto. 00:17:26
con el comando leer 00:17:27
¿de acuerdo? 00:17:30
yo pregunto al usuario 00:17:33
yo lo mismo antes 00:17:35
y leo la variable 00:17:40
con lo cual, tanto 00:17:43
el leer los sensores 00:17:45
como el almacenar la información 00:17:47
se hace 00:17:49
con el comando leer 00:17:51
yo hago un escribir 00:17:53
primera información 00:17:55
y almacenar 00:17:57
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, 00:17:59
Entonces, por ejemplo, imagina que has tenido otro bosque. Pues yo pido la distancia. La almaceno en la misma variante que se medís. 00:18:36
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. 00:18:47
Entonces lo evito. Y si es que no, sigue avanzando. ¿Entendéis? La decisión se toma siempre con honor. 00:19:11
con una condición del tipo si la condición entonces 00:19:19
unas acciones y si no otras acciones y si la condición 00:19:31
en sí y si no 00:19:44
si no 00:19:48
y luego 00:19:53
y aquí 00:20:01
aparte del sí entonces 00:20:06
vale ya no son nuevas decisiones y ahora en función de que salga por una 00:20:11
pata o por la otra aquí activo o desactivo autores que lo 00:20:15
voy a hacer con el escribir es como yo voy a simular 00:20:20
la salida de un motor una luz que se enciende o se apaga, voy a escribir por pantalla y se encienden las luces 00:20:27
entonces de esta forma este programa de robots 00:20:35
yo lo voy a simular primero lo tengo que meter dentro de un buquete un mientras truco 00:20:40
y eso no va a ser lo importante 00:20:47
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, 00:20:50
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 00:21:24
decidir, vamos a ver, qué piezas de hardware es el que lo forma, qué piezas tengo, qué 00:22:40
piezas necesito, qué sensores necesito para un robot evitando obstáculos. Si yo quiero 00:22:53
un robot que vaya avanzando, el objetivo del robot evitando obstáculos, la definición 00:23:04
es, quiero un robot que avance de frente, siempre y cuando no haya un obstáculo, cuando 00:23:09
se encuentre con un obstáculo, antes de chocarse, debe parar, girar sobre sí mismo, un ángulo 00:23:17
del que sea, cambiar de dirección y volver a avanzar hacia delante. ¿Vale? Yo voy avanzando, 00:23:25
cuando llego a una pared, paro, sin chocarme, giro y avanzo en otra dirección. Y ya está. 00:23:32
¿Vale? Esa es la idea. ¿Entendéis? ¿Vale? ¿Qué sensores necesitaría? Bueno, de distancia. 00:23:38
desde distancia y que actuadores tengo las ruedas que son dos motores uno para cada rueda 00:23:45
dos motores y algo más nada más si queremos añadir una lucecita para que cuando se pare 00:24:11
pero inicialmente solamente me faltan dos motores 00:24:24
es decir, necesito un sensor de distancia y dos motores 00:24:29
vale, ya tengo claro mi hardware, lo que es mi robot 00:24:33
el robot, lo que es mi cárcel de arriba, tendría una base 00:24:37
y delante 00:24:41
tendrá 00:24:49
el sensor de distancia 00:24:52
¿vale? 00:24:55
y el robot, de lo que se trata es de que vaya bajando 00:24:56
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 00:25:00
que vamos a programar que estará por ahí. Ya tenemos el robot montado. Perfecto. Lo veis, ¿no? Está listo el detalle. Bien. 00:25:26
Vamos a hacer el programita. Arrancamos, que es lo primero que has controlado en el control. 00:25:39
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 00:25:48
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. 00:26:39
que es el nombre de una variable 00:26:56
eso es una variable 00:27:01
por lo tanto ya hemos simulado 00:27:04
ya hemos simulado 00:27:13
la orden de la placa de control 00:27:16
al sensor dentro del disk 00:27:19
ya hemos cubierto las dos primeras cosas 00:27:25
voy a hacer lo siguiente 00:27:28
procesar la información 00:27:30
ahora vamos a tomar la decisión 00:27:32
¿cómo la tomamos? 00:27:39
con un rompito. ¿Y qué es? ¿Cuál es la pregunta? Voy a preguntar si la distancia 00:27:41
es menor de 3 centímetros. ¿Salida no? Salida sí. Vale. Si yo estoy aquí y no tengo nada 00:27:52
de 3 centímetros por lado, si ya están en marcha, pues seguir poniéndolos. Pues motor, 00:28:08
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? 00:28:19
¿Y qué pasa si por el contrario sí que me encuentro que estoy más cerca de 3 centímetros de un objeto? 00:28:44
Bueno, pues lo primero que tengo que hacer es parar los motores. 00:29:13
Escribir, parar, con lo cual escribir para los motores. 00:29:19
pues eso quiere decir que si yo la distancia es menor de tres centímetros, tengo que mandar la orden a los motores. 00:29:35
Y después, ¿cómo hacemos que el brazo gire? 00:29:42
Está claro que si yo activo los dos motores hacia delante, entonces va a girar. 00:29:48
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? 00:29:54
¿Cómo? Pero en vez de activarlo hacia delante, que avance, como tengo los dos parados, 00:30:03
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. 00:30:21
Cierro. Si yo estoy así, llevo un reparo. Si la rueda de la derecha me ha hecho hacia atrás, va a hacer esto. 00:30:50
¿Y cuánto tiempo lo voy a tener así? Bueno, lo vamos a darle, por ejemplo, un segundo. 00:31:00
con lo cual, una espera de un segundo. Eso quiere decir que yo activo la rueda y cojo un cronómetro, ¿vale? 00:31:04
Y después voy a apagarla, ¿vale? Escribir, muy bien, ¿vale? Fijaros lo que he hecho. 00:31:27
Cuando termino de activar o desactivar mis actuadores, ¿qué tengo que hacer? Cerrar el ciclo. 00:32:14
Esto, esta vuelva, es la que yo voy a simular para el Wildtour, con el viento, es verdad. 00:32:21
¿Veis o no lo que estoy haciendo? ¿Por qué no he activado aquí los motores hacia delante? 00:32:33
Mirad, una cuestión. ¿Por qué no he activado aquí los motores hacia delante? 00:32:38
Porque yo, a lo mejor no he girado suficiente y al girar no me encuentro con otro objeto. 00:32:46
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. 00:32:57
pero si al mirar me encuentro con que la distancia sigue siendo menos de 3 centímetros, volverá 00:33:24
le echará el motor para atrás otra vez y pues girará más 00:33:35
y ya se acerca la balanza 00:33:38
entonces vamos a ver si este programa funciona 00:33:42
voy a hacer dos cosas 00:33:46
voy a poner aquí un tabique 00:33:48
este sería un tabique 00:33:52
y luego aquí le voy a poner un tabique así 00:33:54
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. 00:34:11
si mido 80 cm 00:34:34
y comparo con 3 00:34:38
es menor que 3 00:34:39
no, salgo corriendo 00:34:40
y que es lo que hago 00:34:43
motor 1, motor 2 00:34:45
he hecho 00:34:47
vale, voy a tocar los dos hacia adelante 00:34:48
ahora, el robot 00:34:50
aquí 00:34:53
me falta una cosita 00:34:55
que es 00:34:58
porque si no va a ir muy rápido 00:35:01
voy a estar saturando el robot 00:35:02
voy a hacerle una pequeña espera 00:35:06
por ejemplo 00:35:07
100 milisegundos 00:35:11
¿por qué espero 100 milisegundos? 00:35:13
100 milisegundos 00:35:21
¿cuántos son 100 milisegundos en segundos? 00:35:22
0,1 00:35:27
una décima de segundo ¿vale? 00:35:28
entonces fijaros 00:35:30
yo voy a esperar una décima de segundo 00:35:31
una décima de segundo para mí no es nada 00:35:34
pero para otro robot 00:35:35
está haciendo miles de millones de operaciones 00:35:38
o sea, es muchísimo tiempo 00:35:40
esperamos un segundo 00:35:46
perdón, una decima de segundo 00:35:51
y bueno, cuando vuelvo a medir 00:35:54
sigue siendo más de 3 centímetros 00:36:03
vuelvo a salir por el no 00:36:06
y sigo avanzando 00:36:07
vuelvo a medir, sigue siendo más de 3 00:36:09
avanza, es el tracero 00:36:11
llega un momento en el que el robot 00:36:13
se encuentra aquí 00:36:15
después de avanzar un rato, ya no nos va a ir 00:36:16
¿vale? 00:36:23
y entonces en ese momento cierro el bucle 00:36:23
¿cuánto vale la distancia? 00:36:27
2 centímetros 00:36:30
cuidado que tengo un objeto delante 00:36:31
y es muy cerdo 00:36:33
entonces 00:36:35
leer la distancia me da un 2 00:36:36
¿la distancia es menos que 3 centímetros? 00:36:39
sí 00:36:42
para los motores 00:36:43
con lo cual me despeño 00:36:44
ya lo he separado 00:36:46
ya lo he hecho 00:36:47
el motor 2 lo pongo hacia atrás 00:36:49
que es este 00:36:53
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í. 00:36:53
y he hecho esto a costa para meterlo aquí en una pequeña jaula 00:37:41
Bueno, ahora aquí el robot, ¿qué hacemos? lo mismo que antes 00:37:47
¿es menor que 3 cm? sí, para poner motores 00:37:52
motor 2 atrás, gira y entonces al girar se lo va a colocar así 00:37:56
pero sería más cara que haría 00:38:03
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? 00:38:11
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. 00:38:33
entonces lo hago yo aquí 00:38:44
para que veáis como funciona 00:38:52
este ejemplo primero lo voy a hacer yo 00:38:54
y luego el próximo día pues ya haremos 00:38:56
algún otro ejemplo de otro robot que haga otra cosa 00:38:59
¿vale? 00:39:01
bien 00:39:03
no tardo nada en hacerlo con lo cual 00:39:03
ya veréis que es muy rápido 00:39:09
algoritmo, fin de algoritmo, voy a poner aquí 00:39:10
robot 00:39:15
evita obstáculos 00:39:15
¿vale? 00:39:19
mirad, lo primero, lo importante, fijaros aquí 00:39:21
en la pizarra 00:39:23
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. 00:39:24
¿Vale? Mientras sea verdadero 00:39:42
Esto, espera, no, perdón 00:39:45
Tengo que poner verdadero porque está en español 00:39:47
¿Vale? Ahí me sale 00:39:49
Efectivamente, ahí está 00:39:51
Mientras verdadero, a cero 00:39:52
Con lo cual no va a salir de núcleo ya nunca 00:39:55
Y ahora 00:39:57
¿Qué es lo que tengo que hacer? 00:39:59
Bueno, pues lo primero que tengo que hacer es leer los sensores 00:40:00
Por lo tanto escribimos 00:40:03
Introduce distancia 00:40:05
dos puntos de espacio 00:40:11
comillas 00:40:13
leemos la distancia 00:40:15
dist 00:40:18
después 00:40:21
directamente me doy al bucle sí entonces 00:40:24
¿cuál es la expresión lógica? 00:40:26
distancia es menor 00:40:29
voy a volverla un poquito más 00:40:31
de 10 centímetros para no juntarnos tanto 00:40:33
¿vale? distancia es menor que 10 00:40:35
si la distancia es menor que 10 00:40:37
entonces 00:40:39
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, 00:40:40
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. 00:41:14
Vale, y si no, ¿qué es lo que tengo que hacer? Escribir arranca motor 1 adelante y arranca motor 2 hacia adelante. 00:41:31
Vale, ya estaría 00:42:06
¿Vale? Y aquí al final del sí 00:42:09
Detrás 00:42:12
Tengo que poner una, esperar 00:42:13
Esperar 00:42:15
Voy a ponerlo otro segundo, venga 00:42:19
Para que no, vale, puedo ponerle milisegundos 00:42:21
Pero le voy a poner un segundo 00:42:23
O cero como un segundo, me da igual, ¿vale? 00:42:24
Esperar un segundo 00:42:27
Venga, perfecto 00:42:28
Vamos a ejecutarlo 00:42:31
Ya sería el programa completo 00:42:33
Hemos copiado lo que tenemos en el organigrama 00:42:35
Venga 00:42:37
¿Vale? Ah, me dice que falta una humedad 00:42:37
¿Dónde? En la línea 8 00:42:41
Ah, vale 00:42:42
Vale, me faltaba el segundo 00:42:44
Para que lo hiciera bien 00:42:59
Venga, ya lo tengo aquí 00:43:01
Venga, introduce la distancia 00:43:03
Vamos a ponerle 50 centímetros 00:43:04
Motor 1 adelante, motor 2 hacia adelante 00:43:07
Espera el segundo que le hemos dicho 00:43:09
Introduce la distancia 00:43:11
Ya estamos a 30 00:43:12
¿Vale? Seguimos hacia adelante 00:43:14
Ahora estamos a 20 00:43:16
Seguimos hacia delante 00:43:17
Vamos a 16 centímetros 00:43:19
Seguimos hacia delante 00:43:21
11 centímetros 00:43:23
Seguimos hacia delante 00:43:25
Y ya me he acercado suficiente 00:43:26
Ahora estamos a 8 centímetros 00:43:27
Para el motor 2 00:43:29
O sea, perdona, parar los motores 00:43:31
Motor 2 hacia atrás 00:43:33
Luego lo para y luego me vuelve a pedir un producto a la distancia 00:43:34
Ha hecho todo el proceso del giro 00:43:38
¿Vale? 00:43:40
¿Cuánto mide la distancia ahora? 00:43:41
Pues ahora ya mide 34 centímetros 00:43:43
Pues otra vez hacia delante 00:43:45
le va a estar continuamente preguntándole al sensor de distancia 00:43:46
cuánto mide y va a estar tomando decisiones en función de la medida 00:43:51
y en función de que esté muy cerca, uno del objeto 00:43:55
me va a hacer una acción u otra, y así le hemos hecho un robot 00:43:59
fijaros que es fácil, y no termina nunca, os dais cuenta de que esto no termina nunca 00:44:03
lo puedo tirar así toda la vida, yo le puedo poner el número que me dé la gana que esto no termina nunca 00:44:06
¿vale? bien, si nos fijamos en el diagrama de flujo 00:44:10
veréis que la estructura tiene una salida del bucle hacia el final, pero que no se va a coger nunca. 00:44:16
¿Por qué? Porque la condición es verdadera, por lo cual siempre voy a coger la salida V. 00:44:28
Y no voy a salir nunca por ahí. Esta es una salida que me la puedo ahorrar. 00:44:33
Si yo le pusiera que el bucle mientras se cumpliera, o sea, se ejecutara durante una condición, 00:44:36
hasta que se cumpla, mientras se cumpla una condición, entonces estaríamos poniéndole ahí una condición. 00:44:44
Pues esta es la forma en la que se simulan programación de robots con PCI, ¿vale? 00:44:48
Y la forma en la que hacemos los algoritmos para que luego podamos programarlos. 00:45:01
Valoración:
  • 1
  • 2
  • 3
  • 4
  • 5
Eres el primero. Inicia sesión para valorar el vídeo.
Idioma/s:
es
Autor/es:
JUAN RAMÓN GARCÍA MONTES
Subido por:
Juan Ramã‼N G.
Licencia:
Reconocimiento - No comercial - Sin obra derivada
Visualizaciones:
109
Fecha:
1 de mayo de 2021 - 22:00
Visibilidad:
Público
Centro:
IES ANTONIO GAUDI
Duración:
45′ 18″
Relación de aspecto:
1.78:1
Resolución:
1366x768 píxeles
Tamaño:
413.59 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid