Saltar navegación

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

Programación de algoritmos para robots con PseInt - 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 21 de septiembre de 2024 por Juan Ramã‼N G.

30 visualizaciones

Más información Transcripción

Descargar la transcripción

Hola a todos y bienvenidos a mi canal, soy Juanra García y esto es TecnoJuanra777. 00:00:04
En el vídeo de hoy vamos a estar revisando cómo construir los algoritmos que nos van a permitir 00:00:10
luego programar a nuestros robots para que hagan lo que nosotros queramos. 00:00:16
Así que sin más, empezamos. 00:00:21
La presentación que voy a usar hoy se titula Programación de algoritmos para robots usando PSINT. 00:00:53
y las cosas que vamos a estar revisando son las siguientes. 00:00:58
Lo primero, repasaremos algunos conceptos básicos. 00:01:05
Después, repasaremos los algoritmos para robots y veremos algunas cosas concretas acerca de ellos. 00:01:10
Analizaremos el proceso de construcción de estos algoritmos y el proceso que llevan los robots para ejecutarlos paso a paso. 00:01:17
Y por último, veremos un ejemplo completo de algoritmo que llamaremos robot. 00:01:24
Bueno, lo primero, vamos a repasar algunos conceptos básicos y para ver lo primero es saber qué es un robot. 00:01:31
¿Qué es un robot? Ya hemos visto, porque lo hemos estudiado en vídeos anteriores, que un robot está compuesto por unos sensores. 00:01:41
Unos sensores que van a estar captando la información del entorno y van a estar transformando esa información en valores. 00:01:47
Esos valores se los van a entregar al cerebro que va a procesar esa información y en función de toda la información recogida 00:01:55
va a decidir qué hacer con los diferentes dispositivos de salida que tiene conectados, que son los actuadores. 00:02:05
Por poner algunos ejemplos, ejemplos que vamos a utilizar en nuestros robots cotidianos, pues en el caso de los sensores de entrada podemos tener sensores de distancia, como el HC-SR04, las LDRs o sensores de luminosidad que van a detectar cuando hay luz y cuando no, y los pulsadores que nos van a permitir también cambiar el funcionamiento de nuestro robot o indicarle ciertas cosas a través de las pulsaciones del propio pulsador. 00:02:13
Estos sensores van a captar esa información y se la van a entregar a el cerebro 00:02:41
que puede ser una crumble, ya hemos visto, puede ser un arduino 00:02:49
y estos van a procesar esos datos y van a tomar decisiones 00:02:52
Esas decisiones van a hacer que actúen sobre los diferentes dispositivos de salida 00:02:57
que puede ser luces, motores u otras cosas 00:03:03
Por supuesto, para conectar todo esto hacen falta cables 00:03:07
cables que conecten nuestros sensores a los pines de entrada-salida de las tarjetas de control 00:03:10
y también cables que conecten los pines de entrada-salida a los actuadores. 00:03:16
Así que, si lo ponemos todo junto, lo que vamos a tener al final es un robot. 00:03:22
En este caso, estáis viendo un robot. Os lo voy a enseñar en primera persona. 00:03:28
Así que voy a hacer switch a la cámara. 00:03:34
bien ahí estoy bueno pues aquí podéis ver el robot que se estaba enseñando por delante tiene 00:03:37
el sensor de distancia tiene una crumble que la podéis ver aquí verdad y luego tiene un par 00:03:48
de motores un par de motorcitos que son los dispositivos de salida no tiene más solamente 00:03:55
tiene un dispositivo de entrada que en este caso sería nuestro sensor de distancia un cerebro que 00:04:01
va a tomar las decisiones y los motores que son los actuadores bien también tengo aquí otro un 00:04:08
poquitín más complejo que en este caso se trata de un robot también veis aquí que tiene un 00:04:14
dispositivo de entrada que es el es el sensor de distancia tiene la tarjeta de control aquí 00:04:21
arriba la podéis ver perfectamente esta tarjeta de control y aquí tenemos un sensor de bluetooth 00:04:29
que nos va a permitir controlar este dispositivo, este coche, con un móvil. 00:04:38
Por la parte de abajo, en este caso, tenemos los dos motores. Ahí los podéis ver. 00:04:43
Bien, bueno, pues entonces ya veis que todo, por supuesto, está conectado a través de cables, ¿vale? 00:04:48
Que conectan nuestros dispositivos de entrada. Aquí tenemos un sensor Bluetooth, tenemos el sensor de distancia 00:04:54
y conectan esos sensores con nuestra tarjeta de control 00:05:01
y esa tarjeta de control luego también lo van a conectar con los dispositivos de salida 00:05:06
que en este caso solo son los motores. 00:05:10
Vuelvo a cambiar a la presentación y continuamos. 00:05:13
Por lo tanto, ya vemos que tenemos sensores, una tarjeta de control y actuadores 00:05:16
y todo junto unido por cables funcionan como un robot. 00:05:23
En segundo lugar, ahora vamos a pasar a ver cómo son los algoritmos para los robots. 00:05:27
Son algoritmos, ya hemos visto cómo se construye un algoritmo, pero vamos a ver específicamente cómo vamos a simular a través de un algoritmo el funcionamiento de un programa de control de robots. 00:05:45
Bien, lo primero que tenemos que tener en cuenta es que un robot ejecuta un programa infinito. 00:05:57
¿Y qué quiere decir esto? Pues muy sencillo. Quiere decir que un robot va a estar leyendo la información de los sensores, va a coger la información de los sensores y va a almacenar esos valores en variables 00:06:03
para poderlos recuperar a posteriori y poder procesar la información. Al procesar la información va a tener todos los datos para poder tomar las decisiones que tenga que tomar 00:06:15
y tomando las decisiones lo que va a hacer es actuar sobre los dispositivos de salida. 00:06:28
Y cuando termine de hacer esto, volverá a leer los sensores, volverá a ver sus valores, 00:06:34
asignarlos a variables, procesará la información, tomará decisiones y actuará si es necesario. 00:06:39
Y volverá a leer los sensores y volverá a asignar las lecturas a las variables 00:06:45
y volverá a procesar la información y a tomar decisiones y así sucesivamente de forma infinita. 00:06:48
Por lo tanto, va a estar continuamente en este bucle. 00:06:54
Y entonces la pregunta que nos hacemos es, ¿cómo podemos simular entonces un algoritmo infinito usando PSINT, que es la herramienta que nosotros utilizamos para simular los algoritmos? 00:06:58
Bueno, pues ya vimos que había una estructura que era la estructura mientras. 00:07:11
Mientras que sucede una condición, vamos a hacer un determinado proceso. 00:07:16
aquí lo vemos, mientras suceda la condición, si la condición que estamos evaluando es verdadera, 00:07:21
ejecutamos el proceso y el flujo vuelve arriba, con lo cual volvemos a evaluar la condición, 00:07:29
si vuelve a ser verdadera volvemos a ejecutar y volvemos arriba y así nos permanecemos en este bucle 00:07:38
mientras que la condición sea verdadera, cuando la condición deje de ser verdadera será falsa 00:07:44
y continuaremos por la otra rama saliendo del bucle. 00:07:50
Para construir un algoritmo infinito lo que tenemos que hacer es que tenemos que introducir una condición que siempre sea verdadera. 00:07:54
Por lo tanto, el programa entrará en este bucle, el algoritmo entrará en este bucle y se quedará eternamente en este bucle 00:08:00
porque la condición siempre va a ser verdadera. 00:08:07
Y en PSINT tenemos una estructura que es verdadero, un comando que es verdadero. 00:08:10
Entonces nosotros vamos a hacer la estructura mientras verdadero, hacer. Este verdadero es algo que va a devolver siempre el valor verdadero, 00:08:19
nunca va a devolver otro valor que sea diferente, es decir, nunca va a devolver falso. Y como es un mientras verdadero, este bucle va a estar eternamente ejecutándose. 00:08:28
Por lo tanto, lo primero que tenemos que tener en cuenta es que un algoritmo en PSINT va a tener una estructura mientras y esa mientras va a evaluar no una condición, sino un comando que es verdadero, que va a devolver siempre verdadero. 00:08:39
Dentro de este bucle infinito, que va a estar siempre ejecutándose, es donde tendremos que leer los sensores, procesar la información, tomar las decisiones y actuar y volver arriba, etc. 00:08:58
Y ahí vamos a estar en el bucle. Si ponemos esto en forma de algoritmo, pues lo que tiene es esta pinta. El algoritmo robot, por lo tanto, va a entrar en el bucle, la condición que va a evaluar es verdadero, con lo cual siempre va a salir por la rama V de verdadero y va a ejecutar estas acciones, leer sensores, procesar información, tomar decisiones y actuar. 00:09:06
Y a partir de aquí vuelve arriba, vuelve a entrar en el bucle y va a quedarse en este bucle eternamente. ¿Por qué? Porque como la condición de salida siempre va a dar verdadero, 00:09:26
nunca tomará el camino del falso que es el que me permitiría salir del bucle. Esta es la forma de simular un algoritmo de un programa de control robótico con PSEINT. 00:09:39
Bien, vamos a analizar ahora el proceso paso a paso. Este proceso de leer, asignar las lecturas a los valores, procesar la información, tomar decisiones y actuar, lo vamos a ir analizando pasito a pasito. 00:09:51
Y vamos a empezar por los dos primeros, porque realmente leer los sensores y asignar esas lecturas a variables es una sola acción. Normalmente, cuando nosotros programamos en código, lo que vamos a hacer es una estructura similar a lo que vemos aquí. 00:10:07
el valor de una variable, el nombre de la variable, por ejemplo, u, va a ser igual y lo que voy a hacer es lanzar una ejecución de un comando 00:10:21
que sea el que provoque la lectura de un sensor concreto. Entonces yo provocaré la lectura del sensor, el sensor me devolverá un valor 00:10:34
y ese valor lo voy a asignar a la variable. Eso será cuando escribamos en código. Pero ¿cómo hacemos esto? 00:10:43
cuando estamos en PSINT. Ya sabemos que en PSINT no tenemos sensores, no tenemos nada. 00:10:49
La única forma de introducir información a los algoritmos es a través de la interacción con el usuario. 00:10:54
Y esa interacción sucede a través del comando leer. 00:11:00
Entonces nosotros vamos a utilizar el comando leer para introducir la información correspondiente a los sensores. 00:11:05
Claro, cuando yo le pongo un leer, leer un sensor concreto en una variable, 00:11:13
Claro, a mí me aparece un prompt y yo no sé qué es lo que tengo que introducir. Por lo tanto, tenemos que mezclar para simular esta lectura en PSINT. 00:11:18
Lo que tengo que hacer es primero escribirle al usuario qué sensor es el que quiero leer y luego voy a quedar esperando el dato correspondiente de la lectura de ese sensor. 00:11:27
Y será el usuario el que introduzca el valor. Y de esa forma lo simularemos. Vamos a verlo un poco más concreto. 00:11:38
si escribimos leer sensor de ultrasonidos y luego con el comando leer u quedo esperando a que el usuario introduzca un valor 00:11:44
cuando yo le meta un valor numérico lo que voy a asignar a la variable u es el valor que introduce el usuario 00:11:54
que será para el programa lo que el sensor de ultrasonidos le ha devuelto 00:12:01
por ejemplo imaginemos que el sensor de ultrasonidos que es un sensor de distancia me devuelve 30 centímetros 00:12:06
Pues cuando yo me ponga leer el sensor de ultrasonidos y me quede esperando una respuesta, yo le pondré 30. 00:12:12
Y eso querrá decir que el sensor de ultrasonidos ha devuelto 30 centímetros. 00:12:19
Después diré leer LDR, que es el de la luz, y le pondré un valor entre 1 y 1024, que es lo que devuelve el LDR. 00:12:23
Y después le diré leer botón, y entonces el botón devuelve a 0 o 1, porque es pulsado o sin pulsar. 00:12:31
Y esos valores los iré metiendo dentro de las tres variables u, l y b. Después, como ya tengo almacenado lo que me ha devuelto cada sensor en una variable, 00:12:38
esos valores los podré reutilizar invocando el nombre de las variables. Hay una forma también en PSINT de hacer esto de una sola vez, 00:12:48
que es poner en una frase, leer los sensores ultrasonidos LDR y botón, y luego a la hora de hacer leer podemos separar las tres variables con una coma 00:12:56
y entonces me va a ir preguntando cíclicamente por cada una de ellas. 00:13:05
A mí me gusta más la primera porque queda más claro lo que estoy introduciendo en cada caso. 00:13:09
En el segundo caso me va a poner la frase y luego va a aparecer un prompt de respuesta. 00:13:13
Vamos a introducir un valor, me va a volver a aparecer un prompt de respuesta, 00:13:18
le voy a introducir otro valor, pero no voy a saber exactamente si no leo la frase de arriba bien 00:13:20
qué es lo que estoy metiendo. 00:13:26
Vamos a ver un ejemplo. 00:13:28
Ese sería el código. 00:13:30
El código sería escribir el sensor de ultrasonidos 00:13:31
y luego escribir esa frase y leer el U, después escribimos leer LDR y leemos L y después escribimos leer botón y leemos B. 00:13:34
Lo que nos va a salir por la pantalla de PSINT es lo que tenemos en el cuadro de abajo. 00:13:44
Pues ejecución iniciada, leer sensor de ultrasonidos, que es la frase que escribimos y después se me queda esperando un valor. 00:13:49
Yo le he puesto 120, que son 120 centímetros, un metro veinte al objeto más cercano. 00:13:54
Después leemos el LDR, yo le he puesto un 57, estamos prácticamente de noche y además lee el botón y le vamos a poner un 0 que quiere decir que el botón no está pulsado. 00:14:01
Con lo cual en la variable U tendremos almacenado el valor 120, en la variable L tendremos el valor 57 y en la variable B habremos almacenado el valor 0. 00:14:10
Y luego podremos utilizar estas variables para procesar esa información y tomar decisiones. 00:14:23
¿Qué estructuras usamos ahora para procesar esa información? Ya tenemos la información recogida, ya la hemos almacenado en unas variables, ya sabemos los sensores que han detectado en mi entorno y esa información la he almacenado en las variables. 00:14:28
Pues para procesarla vamos a utilizar las estructuras normales de PSINT para hacer cualquier tipo de proceso. 00:14:46
Asignar, pues vamos a hacer cosas con las variables y vamos a devolver valores en esa misma variable o en otras, 00:14:54
o vamos a hacer bucles mientras, bucles repetir o bucles para, lo que necesitemos para procesar la información. 00:15:01
Por ejemplo, si yo tengo un sensor de ultrasonidos que me devuelve el valor de la distancia en milímetros 00:15:08
y yo necesito procesar esa información en centímetros, pues tendré primero que pasar el valor que ha leído el sensor de milímetros a centímetros 00:15:14
para luego poder trabajar con esa información. Y eso sería una de las partes del proceso que yo haré internamente dentro del robot 00:15:24
con las variables que tengo con los valores de los sensores. 00:15:32
Y después de procesar la información, pues ya sabemos que lo que hay que hacer es tomar decisiones. 00:15:37
Ya sabemos la información que tenemos, la hemos procesado y ahora toca sacar conclusiones y para sacar conclusiones solo podemos hacerlo a través de la bifurcación sí. 00:15:41
La bifurcación sí lo que va a hacer es hacer una condición sobre las variables y esa condición la va a evaluar y en función de que se cumpla o no se cumpla la condición 00:15:54
me va a ir por una rama o por otra bifurcando mis caminos del algoritmo en dos opciones. 00:16:05
De esa forma yo tomaré decisiones y podré actuar sobre diferentes opciones o podré actuar o no actuar o podré hacer o no hacer o lo que sea. 00:16:13
Por tanto, tomar decisiones va a ser siempre una bifurcación sí 00:16:22
Y por último, una vez que hemos tomado la decisión 00:16:27
Hemos elegido ya qué camino es el que tomamos 00:16:30
El de la derecha o el de la izquierda, el del verdadero o el del falso 00:16:32
Necesitamos actuar, solo si es necesario 00:16:35
Claro, habrá caminos que sea no hagas nada 00:16:38
Y habrá otros que sea actúa 00:16:40
Entonces estos caminos de actuar 00:16:43
Lo que vamos a hacer nosotros es simularlos 00:16:45
a través del comando escribir. El comando escribir, en este caso, pues vamos a decir escribir gira el motor 1 al 75%, 00:16:50
le estaremos informando, es una salida del algoritmo hacia el usuario. Le va a decir al usuario gira el motor 1 al 75% 00:16:59
y eso va a ser una acción que luego cuando veamos robots ya veremos cómo se hace para que el motor 1 gire al 75%. 00:17:08
Entonces, esa es la forma en la que nosotros vamos a devolver las salidas hacia los actuadores. 00:17:16
Vamos a ver un ejemplo, un ejemplo completo de un algoritmo que llamaremos robot. 00:17:23
Y para hacerlo, lo primero que tenemos que saber es qué queremos hacer. 00:17:30
Bueno, pues tenemos un robot que tiene conectado un sensor de distancia por ultrasonidos y dos diodos LED, uno rojo y otro verde. 00:17:33
Por lo tanto tenemos un sensor de entrada y dos dispositivos de salida, un LED rojo y un LED verde. 00:17:41
Queremos construir un programa para que se comporte de la siguiente forma. 00:17:48
Cuando la distancia medida por el sensor, el sensor de distancia, sea menor de 10 centímetros, 00:17:52
debe encender el LED rojo para indicar peligro por cercanía de un objeto. 00:17:57
Y en el caso de que la distancia medida por el sensor no sea menor de 10 centímetros, 00:18:02
lo que debe es encender el LED verde para indicar que no hay nada cerca. 00:18:07
Así pues, cuando nosotros utilicemos este dispositivo va a estar midiendo la distancia a través del sensor de ultrasonidos 00:18:12
y cuando esa distancia sea menor de 10 centímetros nos va a encender una luz roja diciendo cuidado que hay un objeto cerca 00:18:19
y sin embargo cuando esa distancia no sea menor de 10 centímetros, es decir, cuando no haya un objeto a menos de 10 centímetros 00:18:25
entonces va a encender la luz verde y nos va a decir, todo bien, todo correcto, no hay riesgo. 00:18:33
Bien, ¿cómo sería entonces el ejemplo de este algoritmo? 00:18:39
Bueno, pues si quieres puedes dar la pausa e intentar hacerlo tú, ¿vale? 00:18:43
Y yo ahora te lo explico. 00:18:47
Bien, el algoritmo sería como este. 00:18:53
Primero tenemos, ya sabemos que en PSINT siempre empieza por algoritmo con un nombre 00:18:57
y termina con fin de algoritmo. Esa es la estructura del esqueleto básico de PSINT. 00:19:04
Dentro ya hemos visto que lo que necesitamos es hacer un bucle mientras. 00:19:09
Este bucle mientras lo que va a estar haciendo es que el programa entre en este ciclo y no salga nunca. 00:19:13
¿Por qué? Porque le hemos puesto como condición a evaluar verdadero. 00:19:21
Por lo tanto siempre se va a cumplir y por lo tanto siempre va a entrar, nunca saldrá. 00:19:25
Bien, entonces, primera cosa, el esqueleto. Segundo, el bucle infinito. Y una vez que estamos en el bucle infinito, dentro tenemos que poner las acciones a ejecutar. 00:19:31
Lo primero, vamos a leer el sensor de ultrasonidos. Entonces escribimos al usuario leer el sensor de ultrasonidos en centímetros. 00:19:42
Y entonces nos vamos a ir a un comando leer y este comando leer nos va a esperar a que el usuario nos introduzca el valor del sensor. 00:19:50
Bueno, pues yo le pondré un valor y aquí está la decisión. 00:20:00
No tengo que evaluar nada, no tengo que hacer ningún proceso intermedio 00:20:03
porque ya directamente estoy pidiendo la información en centímetros. 00:20:07
Insisto, si lo pidiera en milímetros y yo la condición sea que la distancia sea menor de 10 centímetros, 00:20:11
el valor en milímetros tendría que dividirlo por 10, con lo cual aquí en medio habría una línea de proceso 00:20:17
en el cual la variable u sería igual a la variable u dividido por 10. 00:20:23
Es decir, a la variable u le asignaría su propio valor dividido por 10. 00:20:28
Y después ya podría evaluarlo aquí, en esta condición. 00:20:33
Bien, entonces tomo la decisión, si la variable u es menor de 10, es decir, si la distancia es menor de 10 centímetros, 00:20:37
entonces ¿qué hacemos? Encendemos el LED rojo. 00:20:43
Y si no es menor que 10, entonces encendemos el LED verde. 00:20:47
Y ya hemos terminado. 00:20:51
Ahora ¿qué hacemos? Volvemos a cerrar el ciclo, volvemos a leer el sensor de ultrasonidos, 00:20:52
volvemos a pedirle al usuario que me meta la nueva medición, introducemos la nueva medición 00:20:57
y en función de eso decidimos qué hacer y así nos quedamos en este bucle de forma infinita 00:21:03
y el robot funcionaría exactamente como buscamos. 00:21:07
Bien, este sería el diagrama de flujo de este algoritmo. 00:21:11
Vemos, empieza el algoritmo robot, aquí estaría la estructura, ¿veis? 00:21:17
la estructura del bucle infinito con la condición verdadero, que es un bucle mientras, 00:21:21
y la salida falso es la que no se va a utilizar nunca, que es la que nos llevaría al fin del algoritmo. 00:21:29
Por lo tanto, el algoritmo nunca se termina. 00:21:33
Y entrando en el bucle, leemos el sensor de ultrasonidos, introducimos ese valor en la U, 00:21:36
comprobamos si la U es menor que 10 centímetros, si no es menor que 10 centímetros, LED verde, 00:21:42
Si es menor que 10 centímetros, led rojo. Y después cerramos el ciclo y volvemos arriba. Y terminamos nuestro algoritmo. Por lo tanto, este algoritmo estaría accediendo a los sensores, leyendo su información, procesando la información, comprobando si cumple un determinado parámetro, tomando decisiones en función de esa evaluación y actuando sobre los dispositivos de salida o actuadores. 00:21:46
Y terminando el ciclo, volvemos a hacer esto. Y así eternamente. Así que, nada, ya sabemos cómo hacerlo. Esto es todo. Me gustaría que ahora hicierais algunos ejemplos y para eso os voy a proponer un reto. 00:22:14
¿De acuerdo? Un reto, como estamos en Semana Santa, pues lo he llamado el reto Semana Santa 2020. 00:22:32
Bien, ¿cuál es el reto? Vamos a construir un algoritmo, un algoritmo para controlar ese robot que veis ahí, 00:22:41
que es uno de los que os he enseñado antes, que sería un robot móvil que estaría andando o moviéndose 00:22:47
y tomará decisiones en función de lo que mida su sensor de ultrasonidos situado en la parte frontal. 00:22:54
Bien, ¿cómo quiero que se comporte este robot? Pues vamos a hacer que este robot, que tiene forma de coche, que tiene un sensor de distancia por ultrasonidos, que nos va a dar la distancia en milímetros, ¿vale? 00:23:02
Entonces este sensor de ultrasonido, vamos a considerar que la distancia que nos está ofreciendo es en milímetros, está conectado a nuestro cerebro y luego también nuestro cerebro está conectado a dos motores que vamos a llamar motor 1, que es el de la izquierda, y motor 2, el de la derecha. 00:23:16
Los motores, además, cuando yo actúe sobre ellos, pues le puedo indicar que vaya hacia adelante, 00:23:36
le puedo indicar al motor que vaya hacia detrás o le puedo indicar que pueda pararse. 00:23:43
Y adicionalmente puedo elegir a qué velocidad quiero que gire ese motor. 00:23:49
Y la velocidad se la daré en porcentaje entre el 0 y el 100%. 00:23:53
Entonces, una orden correcta para ese motor, por ejemplo, sería mueve el motor 1 hacia adelante al 75%. 00:23:57
Otra orden correcta sería para el motor 2. 00:24:05
Otra orden correcta sería mueve el motor 2 hacia atrás al 100%, por ejemplo. 00:24:09
Esas son órdenes correctas, órdenes válidas sobre los motores. 00:24:18
Entonces, ¿en qué consiste el reto? 00:24:23
Pues tenemos que diseñar un algoritmo para que pudiéramos, en el caso hipotético que lo hiciéramos en el futuro, construir un programa que haga que este robot se comporte de la siguiente forma. 00:24:25
Primero, el coche ha de avanzar de frente siempre a la máxima velocidad. Va a estar avanzando hacia adelante. 00:24:36
Va a estar midiendo la distancia y cuando esa distancia que esté midiendo sea menor de 10 centímetros, entonces debe parar para no chocar contra el objeto que tenga delante. 00:24:43
Una vez que pare, deberá echar marcha atrás, pero al echar marcha atrás tiene que hacer un giro para cambiar su dirección. 00:24:59
Entonces, echará marcha atrás haciendo un giro y una vez que ha echado marcha atrás haciendo un giro, volverá a arrancar hacia adelante midiendo la distancia frontal para que no haya objetos que le estorben. 00:25:08
Hay dos cosas que quiero contaros. Una, si las dos ruedas se mueven a la misma velocidad, el objeto, en este caso el coche, va en línea recta, hacia adelante o hacia atrás. 00:25:23
Pero si una rueda se mueve más rápido que la otra, o una rueda está parada y solo mueve una de las ruedas, entonces el coche gira. 00:25:32
Esa es una de las cosas que hay que tener en cuenta para poder resolver este reto exitosamente. 00:25:42
La segunda, hay un comando que podemos utilizar que se llama el comando espera. 00:25:46
Y este comando, le vamos a dar el comando seguido de un número y entonces lo que va a hacer es que durante ese tiempo el cerebro no va a hacer nada, por lo tanto el coche va a seguir haciendo lo que está haciendo. 00:25:52
Si yo le he dicho mueve los dos motores hacia adelante al 100% y le digo espera un segundo, pues entonces el coche va a estar durante un segundo avanzando hacia adelante sin hacer nada. 00:26:07
vale si después de ese espera uno le digo para los motores entonces el coche lo que va a hacer 00:26:19
es avanzar durante un segundo parar el motor y quedarse quieto entonces como esto es un 00:26:28
un bucle infinito y cíclico necesitamos a veces dar pequeñas pausas a nuestro programa para dar 00:26:35
tiempo a que el robot vaya haciendo cosas por ejemplo imaginaros que yo quiero chequear la 00:26:45
distancia que tengo delante evidentemente si no tengo nada ahora si en la distancia que yo he 00:26:51
medido ahora mismo es de 30 centímetros al objeto más cercano si yo lo mido en velocidad de ejecución 00:26:56
de este programa que pueden ser cientos o miles de veces por segundo de una milésima de segundo 00:27:05
a la siguiente la distancia apenas va a haber cambiado por lo tanto esas decisiones no me 00:27:11
implican un cambio muy brusco en las condiciones yo qué voy a hacer voy a leer voy a hacer que 00:27:16
cada ciclo del programa se ejecute por ejemplo cada medio segundo yo voy a mirar la distancia 00:27:23
al objeto si no avanzó hacia adelante y espero durante medio segundo y después volveré a medir 00:27:30
la distancia pero no voy a estarla midiendo continuamente porque si no me vuelvo loco y 00:27:37
y además puedo saturar el cerebro 00:27:40
en la CPU 00:27:42
entonces, lo que vamos a hacer es eso 00:27:43
vamos a utilizar el comando espera 00:27:46
ahí tenéis un ejemplo, si yo le digo espera 1 00:27:48
eso quiere decir que el robot espere durante 00:27:50
un segundo, pero no quiere decir 00:27:52
que pare todo, sino que esté haciendo 00:27:54
lo que esté haciendo, las cosas siguen funcionando 00:27:56
es decir, si yo tengo un motor funcionando 00:27:58
el motor durante ese segundo sigue funcionando 00:28:00
si yo he encendido 00:28:02
una luz, durante ese segundo la luz 00:28:04
sigue encendida 00:28:06
y de hecho las luces, si yo las enciendo 00:28:07
permanecen encendidas hasta que no le digo que las apague de acuerdo es decir yo tengo que hacer una 00:28:10
orden que sea deja de hacer algo sino el robot eternamente va a estar haciendo lo que yo le digo 00:28:16
que haga bien pues con estas pistas ahí tenéis un enlace a un vídeo un vídeo de instagram donde veis 00:28:22
exactamente qué quiero que haga, qué quiero que haga el robot. 00:28:31
Os lo pongo aquí y aquí os fijáis. Bueno, pues ya lo habéis visto, veis que el robot va hacia adelante, 00:28:39
cuando llega a un objeto que tiene menos de 10 centímetros, se para, echa hacia atrás haciendo un pequeño giro 00:29:11
y vuelve a avanzar. ¿De acuerdo? Pues ese es el reto. Quiero que me escribáis el algoritmo 00:29:17
y cuando lo tengáis, pues ya sabéis, me lo ponéis en los comentarios, me lo enviáis y hacéis que me llegue 00:29:23
para que lo pueda hacer. Muchas gracias. Así que sin más, me despido. Hasta la próxima. 00:29:31
En el próximo vídeo seguiremos aprendiendo cosas sobre programación, algoritmos y robots. 00:29:42
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 - Compartir igual
Visualizaciones:
30
Fecha:
21 de septiembre de 2024 - 14:40
Visibilidad:
Público
Centro:
EST ADMI D.G. DE INFRAESTRUCTURAS Y SERVICIOS
Duración:
30′
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1680x1050 píxeles
Tamaño:
116.79 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid