Saltar navegación

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

Equivalencias PseInt-Tinkercad Circuits, y Circutios en Puente H - 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 7 de mayo de 2020 por Juan Ramã‼N G.

99 visualizaciones

Más información Transcripción

Descargar la transcripción

Muy bien, vamos a comenzar la clase. Hoy lo que tengo que contaros es el encaje entre la parte de PSINT y la parte de Tinkercad que hemos estado viendo. 00:00:01
Hemos estado viendo por un lado cómo hacer los diagramas de flujo en PSINT, que es el paso previo que nosotros deberíamos hacer siempre que vamos a programar. 00:00:18
después lo que hemos estado haciendo ha sido viendo qué bloques tenemos dentro de tinker 00:00:26
cada circuito para poder simular lo que sería la construcción de un robot y un poco lo que quiero 00:00:32
y es ver cómo enlazan esas dos partes y que quede claro como nosotros desde un circuito diseñado 00:00:40
desde un algoritmo diseñado con PSINT podemos pasar a Tinkercad. Entonces para eso os he preparado 00:00:49
una pequeña presentación que voy a compartir con vosotros y supongo que ahora deberéis de estar 00:00:58
viendo ya el powerpoint y ahora deberéis estar viendo la presentación me podéis confirmar por 00:01:13
favor que estáis viendo la presentación todos por el chat no lo podéis decir perfecto gracias 00:01:25
entonces nada vamos a ver unos conceptos finales ya para redondear un poco lo que son la construcción 00:01:34
de robots. Estamos haciéndolo a un nivel muy básico, es decir, estamos haciendo unos robots caseros, 00:01:42
cosas con algunas piezas muy sencillas y con pocas piezas. Entender que cuando esto se aplica 00:01:49
en un nivel industrial o en un nivel ya de producción corporativa, cuando vamos a las empresas multinacionales 00:01:56
si estas empresas se dedican a construir robots, esto es multiplicado por mil. 00:02:05
Es decir, un robot tiene cientos o miles de sensores y esos miles de sensores tenemos que leerlos todos, 00:02:11
tenemos que almacenar sus valores en variables, tenemos que procesar esas variables y esos valores para tomar decisiones 00:02:22
Y con toda la casuística posible que podemos encontrar de todos esos sensores, ejecutar las decisiones sobre los actuadores. 00:02:28
Entonces, ese proceso, la potencia que nos dan los procesadores, permite hacerlo en un tiempo razonable. 00:02:39
Pero claro, cuantos más sensores tengamos, más información hay que procesar. 00:02:48
Y ahí es donde están todos los avances de la tecnología, de la robótica, sobre todo en la parte de programación. 00:02:52
cómo manejar esos volúmenes grandes de información con tantos sensores, con tantas variables, con tantas casuísticas, con tantas posibles cosas 00:02:58
y cómo tomar decisiones y esas decisiones que sean decisiones coherentes. Porque luego al final todo se reduce a lo mismo, leer la información de los sensores 00:03:09
y tomar decisiones para actuar sobre nuestros actuadores. 00:03:18
Entonces, entendiendo este concepto, quiero que entendáis por qué estamos viendo estas cosas 00:03:23
y por qué estamos analizando los robots desde un punto de vista más teórico. 00:03:29
Lo primero que hay que hacer siempre es construirse un diagrama de flujo 00:03:37
que normalmente es un diagrama de flujo general, un diagrama de flujo en el cual nosotros 00:03:42
vamos a ir definiendo cómo va a actuar de forma general un robot y después cada bloque de ese diagrama de flujo lo dividiremos en subprocesos, en cosas más sencillas 00:03:46
y lo iremos dividiendo en tareas más sencillas y cada tarea la iremos a su vez subdividiendo en tareas más sencillas hasta que lleguemos a el nivel de las tareas 00:03:58
que podemos programar en un lenguaje de programación, cosas como asigna un valor a una variable, 00:04:10
cosas como activa un determinado dispositivo de salida, recoge un valor de un determinado sensor, 00:04:16
cosas que podemos programar directamente. Entonces ese es el reto, empezar desde un diagrama de flujo muy general 00:04:24
y luego irlo complicando, irlo desgranando hasta llegar al nivel de programación. 00:04:31
Os lo digo porque de alguna forma esto es lo que se hace. Cuando yo quiero analizar un sistema, cuando quiero poner sensores y ver cómo funcionan las cosas, muchas veces tengo que entender cómo funciona ese objeto y entonces lo que tengo que hacer es irme ya a un plano todavía más teórico y estudiar el objeto a nivel de física, a nivel de fuerzas, a nivel de pesos, de velocidades, etc. 00:04:37
Y esos análisis, que son teóricos, que son a través de fórmulas, que son donde aplicamos la física, la química, donde aplicamos las matemáticas, donde aplicamos todo lo que estamos aprendiendo en otras asignaturas, luego eso lo tengo que modelar, lo tengo que transformar en algo que yo pueda sensorizar, que yo pueda medir a través de sensores. 00:05:07
Y si yo consigo entender cómo funciona un determinado proceso o un determinado objeto y consigo sensorizarlo, a partir de ahí el resto ya es programación. 00:05:29
Entonces un poco la robótica tiene estos aspectos. Os cuento esto porque quiero que si alguno quiere profundizar más en todos estos temas de robótica, sepa un poco por dónde van los tiros. 00:05:41
Cuando vimos hablar del Big Data, cuando vimos hablar de la inteligencia artificial, de las redes neuronales y de todas estas cosas, muchas veces todas esas que no son otra cosa que formas de programar, formas de hacer programas que manejen mucha cantidad de información y tomen decisiones teniendo en cuenta muchas variables y muchas alternativas, aplicarlos a esto que estamos haciendo nosotros. 00:05:53
a la sensorización a todos esos valores de esos sensores manejarlos entenderlos interpretarlos 00:06:22
y después actuar sobre los actuadores correspondientes que normalmente son motores 00:06:30
luces o cosas así de acuerdo y con esto ya con estos principios con estos con estos con estas 00:06:35
cosas básicas ya vamos a poder hacer pues desde un robot tonto como el que estamos haciendo que 00:06:43
cuando encuentro un objeto se para hasta un satélite artificial hasta una nave que vaya 00:06:48
a la luna es que podemos hacer lo que nos dé la gana porque ya es aplicar lo mismo pero 00:06:53
utilizando esos principios hacer cosas más complejas vale entonces como introducción sirva 00:06:58
esto de ánimo y de motivación para que si os gusta pues profundicéis y vamos a ver hoy tres 00:07:07
cosas voy a centrar en tres aspectos vale tres aspectos que son primero voy a intentar haceros 00:07:15
ver la equivalencia entre ps int los algoritmos que hemos visto ese pseudo código el escribir en 00:07:21
lenguaje natural pues cuando se ocurre esto hago esto y si no hago lo otro simplemente una cosa 00:07:29
que podemos escribir nosotros en un folio un pseudo código y un diagrama de flujo con una 00:07:34
serie de tareas en orden y una serie de estructuras de bucles de decisiones de bifurcaciones etcétera 00:07:39
que podemos modelar y cómo transportarlo a luego un programa en bloques como podemos utilizar en 00:07:47
tinker cat circuits vale el programa en bloques de tinker cat circuits tiene una última ventaja 00:07:54
que os voy a contar hoy y es que yo puedo ese programa transformarlo en código código es el 00:08:00
código de programación y volcarlo en una tarjeta real para que haga exactamente lo que yo estoy 00:08:06
viendo en el modelo en el modelo de pantalla entonces cuando yo hago una simulación con 00:08:12
tinker cat circuits realmente el siguiente paso y último que es lo que no vamos a poder hacer 00:08:17
nosotros porque no estamos en clase pero hubiéramos hecho en caso de haber estado en clase es luego 00:08:23
una placa de verdad un motor de verdad un led de verdad una protoboard de verdad montar el circuito 00:08:28
coger el programa que yo he hecho con la simulación en Tinkercad 00:08:35
transformarlo en código y volcárselo a la placa y ver que funciona 00:08:39
y ver que hace lo que se supone que tiene que hacer 00:08:43
entonces, bueno, el primer aspecto va a ser coger esas equivalencias entre PSI 00:08:46
y los bloques de Tinkercad, luego voy a coger algunos circuitos de ejemplo 00:08:51
y voy a resolver el reto que os propuse 00:08:55
y por último voy a daros un último apunte sobre los motores 00:08:58
de corriente continua y los puentes H, que también deberíais haber hecho un pequeño trabajo de investigación sobre los puentes H y me lo deberíais haber mandado. 00:09:03
¿De acuerdo? Bueno, pues entonces sin más pasamos al primer aspecto que es las equivalencias entre PSINT y Tinkercad Circuits. 00:09:13
Bien, PSINT ya hemos dado muchas clases, ya hemos visto cómo funciona, hemos hecho muchos ejercicios, muchos ejemplos. 00:09:21
Veamos al final cómo hacemos, por ejemplo, la lectura de un sensor en PSINT. 00:09:27
La lectura de un sensor, que es el primer paso de un robot, leer los sensores y asignar esos valores en ciertas variables, 00:09:34
lo simulábamos con ese diagrama de flujo. 00:09:41
En PSINT lo que hacíamos era poner por pantalla, leer el sensor de ultrasonidos, por ejemplo, 00:09:45
y luego quedábamos esperando para que el usuario introdujera el valor de ese sensor 00:09:51
y lo almacenábamos en una variable que en este caso hemos llamado distancia. 00:09:58
En este caso lo hemos llamado distancia. 00:10:03
Bien, entonces, ¿qué es lo que tenemos en Tinkercad? 00:10:06
Este bloque, evidentemente todas las órdenes anteriores y las órdenes posteriores me las quito, 00:10:11
Y el bloque de recoger esa información del sensor y almacenarlo dentro de una variable, en Tinkercad lo tenemos que hacer primero creando las variables. 00:10:16
Para eso tenemos una opción dentro de las diferentes opciones que nos dan los bloques de Tinkercad, que es la de las variables. 00:10:29
Y ahí tenemos un botón de crear variable donde yo puedo crear una variable. Puedo crear una variable que se llame distancia, una variable que se llame sensor. 00:10:39
le puedo poner el nombre que me dé la gana. Y ya sabéis que una variable no deja de ser una caja 00:10:46
donde yo meto información, una caja vacía. Es como un cajón con una etiqueta que pone distancia 00:10:50
y ese cajón yo puedo abrirlo y poner información ahí dentro o puedo abrirlo y ver qué información hay ahí dentro. 00:10:58
Es así de fácil. Entonces tenemos las variables, que es lo primero que tenemos que definir. 00:11:04
Y después, ¿cómo recogemos la información para almacenarla en la variable? 00:11:09
Tenemos en la parte de entradas, podemos leer por ejemplo el estado en el que se encuentra un pin digital o un pin analógico de nuestra tarjeta microcontroladora y podemos ver si el pin digital 0, el 1, el 2 o el 3, podemos elegir el número, está en alta o en baja, es decir, está a 5 voltios o está a 0 voltios. 00:11:13
También podemos leer pasadores analógicos que ya sabéis que son donde yo conecto los sensores que me devuelven información 00:11:37
Pero esa información siempre va a estar entre 0 y 1024, es decir, es un número entre 0 y 1024 00:11:45
Entonces, si yo estoy mirando temperaturas, pues desde la mínima temperatura que yo puedo medir hasta la máxima 00:11:52
Voy a coger y lo voy a poner con números de 0 a 1024 00:11:59
Si yo estoy midiendo distancias, desde la mínima distancia que yo puedo medir hasta la máxima distancia que me llega a mi rango, un medidor de distancias no puede medir hasta el infinito, no puede medir hasta el sol o hasta la luna, es decir, a lo mejor alcanza a 2 metros o a 3 metros, pues hasta el límite de su rango va a coger y va a poner esa numeración de 0 a 1024. 00:12:02
Y entonces, si estamos midiendo distancias y a mí me devuelve un número, lo que me está diciendo es en qué posición dentro de ese rango me encuentro, ¿vale? Sea lo que sea lo que esté midiendo. 00:12:23
Sensores analógicos, y los leemos con la orden leer pasador analógico. Estas órdenes se meten, como veis, tienen forma redondeada dentro de la posición del definir. 00:12:35
Por tanto, cuando yo, también tenemos algunos específicos, por ejemplo el de distancia de ultrasonico o el de temperatura, que son algunos que necesitan más información y tenemos órdenes específicas para ellos. 00:12:47
Por ejemplo, si yo quiero coger y asignar a alguna variable de distancia la lectura de un sensor ultrasonico, que tenemos con el trigger en un pin y el eco en otro pin, y lo quiero medir en centímetros, pues lo que tendríamos sería la orden de aquí abajo. 00:13:00
sería un bloque en el cual yo asignó a la variable distancia que la he definido el valor de leer el 00:13:16
sensor de distancia del pin 7 en el eco 4 por ejemplo unidades en centímetros si yo lo que 00:13:27
estoy simplemente es mirando si un botón está pulsado no os cojo leo el pasador digital número 00:13:32
5 y lo asignó en la variable así es como yo recojo la información de mis sensores y la almacena en 00:13:37
variables, en Tinkercad. Entonces, esto es lo primero. ¿Cómo son los bloques de lectura? Son asignaciones a variables de órdenes de entrada de lectura 00:13:42
de pines digitales o analógicos. ¿Cómo tomamos las decisiones? Bueno, preguntas hasta aquí. ¿Alguna pregunta con respecto al tema de cómo se leen los 00:13:55
sensores yo creo que a estas alturas más o menos ya todo el mundo lo tenía claro pero bueno por si 00:14:07
acaso quería quería quería verlo entonces preguntas alguna cosa no veo nada por el chat si no pues me 00:14:11
levantáis la mano vale y yo os doy paso me lo ponéis por el chat y yo os contesto vale pues 00:14:27
continuamos entonces de acuerdo entonces lo siguiente una vez que hemos leído los sensores 00:14:34
si hemos asignado en las variables esos valores, tenemos que tomar decisiones. 00:14:41
Y aquí es donde teníamos las estructuras de repetición, los bucles, las bifurcaciones, las decisiones. 00:14:46
Entonces, por ejemplo, una decisión que es esta parte, si se cumple la condición hago las acciones de la derecha 00:14:53
y si no se cumple hago las acciones de la izquierda. 00:15:02
Y luego ya continuamos con nuestras acciones comunes. 00:15:06
Pues eso se haría con un bloque del tipo si, con una condición dentro de ese hexágono, entonces y hacemos el primer bloque de tareas, es decir, lo que metamos aquí dentro. 00:15:09
Y si no se cumple, haríamos el segundo bloque. Por lo tanto, las acciones si se cumple, que serían las del verdadero, serían las que estarían aquí dentro de la primera sección. 00:15:20
Y las acciones que hay que hacer si no se cumple la condición, hay que meterlas dentro del segundo espacio. 00:15:31
y estas decisiones las tomamos a través de bloques que tienen forma de hexágono 00:15:36
y esto lo tenemos dentro de matemáticas, dentro de la parte de matemáticas 00:15:42
entonces yo tengo aquí unas condiciones de comparación menor, menor o igual, mayor, mayor o igual, distinto o igual 00:15:47
y esto yo puedo comparar valores concretos como en este caso 1,1 o también dentro de estas estructuras redondas 00:15:55
puedo meter variables o puedo meter otras cosas que tengan esa forma. También tengo una combinación 00:16:04
de varias decisiones, es decir, de varias condiciones. Si yo digo que se tiene que cumplir algo y además 00:16:11
se tiene que cumplir otra cosa a la vez, entonces tendría que utilizar una estructura de este tipo 00:16:18
donde yo ya tengo una combinación de dos condiciones. La primera condición, que sigue siendo hexagonal, 00:16:23
será de esa forma y la segunda será también de esta forma, donde habrá una comparación, donde habrá una igualdad o lo que sea. 00:16:30
Y cuando yo pregunte si una variable tiene un determinado valor o si es mayor o si es menor o qué pasa con ella, 00:16:38
entonces, si se cumple esa condición, entraré al primer espacio de acciones a ejecutar y si no, entraré al segundo. 00:16:45
Y así es como funcionan las bifurcaciones, las decisiones. 00:16:51
¿Cómo funcionan los bucles? Las estructuras de repetir mientras y las estructuras de repetir hasta. 00:16:56
En este caso, la que tenemos aquí a la izquierda es una de repetir mientras. 00:17:02
Mientras se cumpla esta condición, voy a ejecutar las acciones. 00:17:06
Si os fijáis, os acordáis que estas acciones puede que no se ejecuten nunca si inicialmente no se cumple la condición. 00:17:08
Es decir, yo compruebo la condición, por eso es un bucle mientras. 00:17:16
Mientras se mantenga esta condición, mientras se cumpla, yo ejecuto. 00:17:19
Y si no se cumple desde el principio no ejecuto nunca. Tenemos un bloque dentro de Tinkercad que es el repetir mientras. 00:17:24
Y aquí tenemos la condición que se ha de cumplir. Mientras que se cumpla la condición, que tiene la misma estructura que antes, los hexágonos. 00:17:33
Entonces mientras que se cumpla esta condición yo voy a ejecutar un bloque de código. 00:17:40
¿Y cómo es la estructura de repetir hasta? Pues sería la misma estructura que teníamos en nuestro PSINT, pero ahora la condición se evalúa al final. 00:17:44
Por lo tanto, el conjunto de acciones se va a ejecutar al menos una vez. Esa es la diferencia. 00:17:54
Entonces estas acciones se van a repetir hasta que se cumpla una condición. En este caso tenemos el mismo bloque que antes, pero aquí desplegamos y podemos elegir hasta. 00:18:00
Por lo tanto, estas órdenes que metamos aquí debajo, aquí en el hueco, se van a ejecutar una vez y al final de su ejecución se va a evaluar esta condición que pongamos aquí. 00:18:10
Y cuando se evalúe la condición, si se sigue cumpliendo, repetimos y si no, se sale. 00:18:22
Y aquí lo que hacemos es primero evaluar la condición y una vez que evaluemos la condición que está dentro del hexágono, si se cumple, entro y ejecuto y si no se cumple, no ejecuto nada. 00:18:26
Entonces esas serían las estructuras 00:18:37
Repetir mientras se repetirá esta dentro de Tinkercad 00:18:40
Son las mismas estructuras que veíamos en PSA 00:18:42
Pero las tenemos ahora en forma de bloque 00:18:45
Y después tenemos otra estructura 00:18:47
Que es la de la repetición 00:18:52
La del bucle de repetición 00:18:53
Un número concreto de veces 00:18:55
En este caso en Tinkercad tenemos dos opciones 00:18:56
Tenemos una que nos hace directamente 00:19:00
Una repetición de un número de veces 00:19:03
Sin más, lo que meta ahí dentro se va a repetir en bucle durante 10 vueltas y luego seguimos viaje. 00:19:05
O si no, tenemos, como veíamos dentro de PSINT, la opción de definir una variable que iba a ir pasando desde un valor inicial hasta un valor final con un ritmo concreto. 00:19:13
Por ejemplo, podemos ir desde 1 hasta 10 de 1 en 1. 00:19:26
bueno pues si la variable la llamo y por ejemplo vale y quiero ir desde un valor inicial hasta un 00:19:28
valor final de a un ritmo concreto a un paso concreto pues lo que vamos a hacer es utilizar 00:19:35
la otra estructura que utiliza esta forma más extendida no es sólo repetir 10 veces sino que 00:19:41
ahora me va a decir me permite ejecutarlo hacia arriba o hacia abajo y me va a decir para la 00:19:48
variable que yo le he indicado y desde el inicio hasta el fin y el paso al que quiero ir. Entonces, contar hacia arriba la variable y desde 1 hasta 10, 00:19:54
de 1 en 1 sería como leeríamos esto. De 1 en 1 este sería el paso, el ritmo. Y entonces aquí todo lo que se ejecute aquí dentro se va a ir ejecutando 00:20:06
hasta que la variable y haya pasado por los valores 1, 2, 3, 4, hasta 10 de 1 en 1, contando desde el 1 hasta el 10 hacia arriba. 00:20:16
Y además esa variable la podemos utilizar como un contador de vueltas dentro del propio bucle, con lo cual si yo quiero saber en qué vuelta estoy 00:20:27
no tengo más que acudir a la variable y y ver qué valor tiene. Si y vale 7 es que estoy en la séptima iteración del bucle. 00:20:35
vale él ahí va a almacenar es un contador de vueltas cual iba a almacenar el valor de la 00:20:43
vuelta en la que me encuentro y lo puedo utilizar de acuerdo dos opciones una repetir un número de 00:20:48
veces sin ninguna variable que vaya acumulando en la vuelta en la que me encuentro y otro es 00:20:54
el que tenemos exactamente igual en pese in que sería con una variable desde un valor inicial 00:21:00
hasta un valor final y con un paso con un ritmo y por último ya hemos visto como leemos los 00:21:07
los sensores y almacenamos sus valores en variables. Ya hemos visto cómo tomar decisiones 00:21:15
o cómo hacer esas estructuras de control de repetición para poder manejar la información 00:21:22
y llegar a conclusiones y ahora en el momento en el que tengamos que tomar las decisiones 00:21:27
las tomamos y decidimos actuar o no. Si tenemos que actuar en algún actuador, si tenemos 00:21:31
que realizar acciones sobre los actuadores, entonces vamos a utilizar las órdenes que 00:21:37
veíamos en PSINT que hacíamos 00:21:43
directamente poniendo un texto en pantalla 00:21:45
diciendo lo que hacíamos. Vale, pues 00:21:47
acción a realizar sobre el actuador, arrancar 00:21:49
un motor, encender un LED, parar 00:21:51
un motor, parar un LED. ¿Cómo 00:21:53
vamos a hacer eso ahora nosotros en Tinkercad? 00:21:55
Bueno, pues como lo que tenemos es una placa donde 00:21:57
yo tengo conectado en ciertos pines 00:21:59
los actuadores, lo que vamos a 00:22:00
tener es esa estructura 00:22:03
como poner un 00:22:05
pin digital concreto 00:22:07
o activado o 00:22:09
no activado, de forma que 00:22:11
activo el actuador o no lo activo si lo pongo en alta meto 5 voltios por ese 00:22:12
cable y entonces lo que está allí conectado se arranca y si lo pongo en 00:22:18
baja no meto un voltaje y entonces lo que está allí conectado es como abrir un 00:22:22
interruptor se para vale luego tengo algunos que son específicos para ciertos 00:22:26
actuadores por ejemplo si tengo un servomotor puedo girar ese servomotor el 00:22:31
servomotor es un es un motor que gira entre 0 y 180 grados y yo le puedo 00:22:36
definir ya no sólo el pin en el que lo tengo sino cuántos grados lo quiero girar o si quiero 00:22:40
utilizar el altavoz puedo ponerle un tono concreto en hercios y durante cuánto tiempo quiero que esté 00:22:46
sonando o puedo utilizar el monitor serie para sacar textos vale como si fuera a imprimir por 00:22:51
pantalla entonces aparte de las que son específicas de algunos de algunos actuadores lo normal es 00:22:57
utilizar este que es el que nos activa un pin donde yo tengo un actuador o no nos lo activa 00:23:04
vale entonces siempre que yo tenga que realizar una acción sobre un actuador voy a utilizar estas 00:23:11
estructuras ya tengo todos los bloques ya tengo todas las piezas ya solamente tengo que montar 00:23:16
el castillo vale tengo todos los los ladrillos entonces vamos a intentar poner todo esto de 00:23:21
una forma más más clara preguntas que tengáis hasta ahora con estas estructuras básicamente 00:23:28
son las estructuras que habíamos visto en pseudocódigo y en diagramas de flujo pero 00:23:34
viendo cómo son sus equivalentes dentro de tinker que tenemos las mismas estructuras pero con forma 00:23:40
de bloques preguntas que tengáis a ver no entendiste lo de las piezas rosas qué piezas 00:23:46
rosas a ver voy a buscar las piezas rosas cuáles son las piezas rosas te va estas las variables 00:23:59
estas variables vale vamos por partes primero vamos con las variables vale os voy a compartir 00:24:27
la parte de la presentación vale os voy a compartir mi navegador y voy a hacer algún 00:24:39
ejemplo directamente en Tinkercad. Entonces compartimos el navegador. 00:24:47
Ahora tendréis que estar viendo mi navegador. Si entramos en Tinkercad, vamos a circuitos, 00:24:56
como siempre creamos un nuevo circuito. Muy bien y ahora lo que voy a hacer es ponerme mi plaquita. 00:25:07
voy a ponerme, a ver, perdonad, mi placa, ahí está. Y entonces cuando yo me voy a código, bueno este código que aparece lo quito 00:25:20
porque siempre es un código estándar que aparece siempre y no me interesa. Vale, cuando yo me pongo a programar 00:25:37
imaginaros que yo tengo aquí un sensor conectado al pin 8, ¿vale? Yo tengo un botón o tengo un sensor de lo que sea. 00:25:43
bien lo primero que tengo que hacer es definir las variables entonces al principio yo no tengo 00:25:52
variables y cuando las creo voy a poner una variable que se va a llamar juanra se puede 00:25:57
llamar como me dé la gana vale cuando yo defino una variable que no deja de ser un cajón donde 00:26:02
yo pongo la etiqueta y donde yo puedo meter y sacar cosas vale esos valores ya me aparece 00:26:08
tanto la variable como las órdenes de asignarle un valor a la variable concreta entonces si yo 00:26:13
quiero por ejemplo imaginaros que lo que quiero es si tengo conectado vamos a suponer que tengo 00:26:20
en el pin 8 conectado un dispositivo de entrada vale un sensor entonces quiero que cuando el 00:26:25
sensor active ese pin 8 yo lea la información y lo almacene en juanra o si no lo activa lea esa 00:26:35
información y lo almacena en juanra entonces yo lo que voy a hacer es definir la variable 00:26:45
juanra voy a cogerme este bloque y este bloque que es definir la variable lo que voy a hacer 00:26:50
es en los bloques de entrada decir quiero leer el pasador digital número 8 entonces lo que yo 00:26:56
conecte al pin 8 que la placa no sabe lo que es solamente va a ir al pin 8 y va a decir estás 00:27:04
activado a 5 voltios o no estás activado a 0 voltios si está activado a 5 voltios a juanra 00:27:11
le va a poner high y si está desactivado a 0 voltios le va a poner low y ese valor lo va a 00:27:17
almacenar y ya está no va a hacer más y lo va a dejar dentro de la variable y cuando luego yo 00:27:24
quiera ver qué ha pasado con ese sensor que estaba ahí conectado iré a la variable y miraré qué valor 00:27:30
tiene y en función del valor que tiene la variable decidiré vale tiene más sentido vale vale entonces 00:27:36
esos son las variables vale y esos son vuelvo a la presentación perdón vuelvo a la presentación 00:27:50
a ver un segundito que voy a ir a la a la transparencia que tengo que ir vale está 00:28:00
entonces esas son las variables yo las creo y me crea directamente ya el definir y el cambiar y yo 00:28:07
luego cuando las quiero definir cuando quiero utilizarlas lo que hago es asignarle pues una 00:28:15
orden de entrada o leer un pasado digital como acabamos de hacer un pasado tecnológico el 00:28:19
ultrasonico lo que sea y al final me queda un bloque de esta forma vale y ese es el bloque 00:28:23
director vale a ver a ver a ver no pasa nada david vale los últimos dos de azul 00:28:28
ya no lo has entendido áfrica cuáles cuáles cuáles dime cuáles 00:28:37
los últimos dos de azul vale los actuadores 00:28:45
estos áfrica es esto lo que lo que no entiendes el de reproducir a de 00:28:54
reproducir perdón imprimir vale o sea esto de aquí vale esto simplemente vuelvo al navegador 00:29:03
vale imaginaros que yo tengo en mi navegador a ver un segundito vale tengo cuadritos que tengo 00:29:11
por aquí mucha movida vale voy a conectar por ejemplo una luz voy a conectar un este de sonido 00:29:23
yo conecto este sonido, el positivo lo conecto a un pin 00:29:30
a un pin, al 9 00:29:34
pin digital y el negativo lo conecto a ground 00:29:38
ya tengo mi dispositivo de salida, ahora yo quiero utilizar 00:29:42
este altavoz, si os fijáis, para el altavoz 00:29:46
a ver un segundito, lo estáis viendo 00:29:50
ahora el navegador o no lo estáis viendo? 00:29:56
¿Estáis viendo el navegador ahora o no? 00:29:58
Sí, vale 00:30:04
Entonces, si os fijáis 00:30:05
Cuando 00:30:07
Cuando 00:30:08
Yo active el pin 9 00:30:10
Lo que voy a hacer es activar el zumbador 00:30:13
Activar el altavoz 00:30:15
Y cuando lo ponga a cero 00:30:17
Se va a desactivar, pero yo tengo 00:30:19
Una orden específica 00:30:21
Esto lo voy a quitar 00:30:23
¿Vale? Que es 00:30:24
Reproducir en el altavoz 00:30:26
que está en un pin concreto, un tono y durante un tiempo, entonces yo puedo coger y decirle si esto está en el pin 9, reproducir en el altavoz que está en el pasador 9, 00:30:30
en el 9 es donde yo tengo conectado mi altavoz, un tono, el tono 120, durante un segundo, si esto lo ejecuto, directamente esto va a sonar, ahora está sonando, 00:30:42
por mis cascos yo lo estoy oyendo vale si le pones 60 hoy es otro tono otra otro otro son 00:30:54
otro sonido más grave ahora yo lo estoy oyendo también por mis cascos vale si lo hacéis en casa 00:31:03
va a sonar y vais a oír el pitido dentro en el pc o en el en el ordenador vale entonces si yo 00:31:10
quiero utilizar el altavoz tengo una orden es una orden específica para reproducir algo concreto en 00:31:17
ese altavoz también el girar el servo si yo tengo un servo motor lo puedo girar un número de grados 00:31:24
vale o puedo imprimir por el monitor serie si os fijáis aquí en el monitor serie vamos a voy 00:31:29
a eliminar este bloque voy a eliminar este bloque vale y yo lo que voy a hacer es voy a hacer un 00:31:37
bucle ya que estoy pues venga voy a contar vale y voy a contar hasta hacia arriba una variable que 00:31:43
se va a llamar y vale y entonces yo dentro de las variables cojo y lo que voy a hacer es imprimir en 00:31:51
el monitor sería la variable y luego le voy a decir que se espere que se espere medio segundo 00:31:56
vale 0.5 segundos de acuerdo entonces si yo ejecuto esto fíjate lo que ocurre en el monitor 00:32:03
serie que lo tengo aquí abajo vale esto es como una pantalla que no realmente esto tendría que 00:32:11
conectarle algo a la placa no os lo quiero explicar pero realmente tendría que conectarle 00:32:16
para verlo pero yo sí puedo decirle a través de software que me lo enseñe entonces el monitor 00:32:20
serie yo puedo sacar información fijaros que yo aquí veis 1 2 3 4 5 6 7 8 9 10 vale cada medio 00:32:28
segundo me está poniendo voy a hacerle que espere más voy a hacer lo que espere dos segundos entonces 00:32:35
ahora empezará a vale perdón está esperar tiene que estar aquí dentro porque si no me saca todo 00:32:41
del tirón 0,5 segundos vale 5.5 no 0.5 vale entonces ahora veis 1 2 3 4 va imprime la y está 00:32:47
haciendo un bucle hasta 10 y luego vuelve a empezar porque esto es un bucle infinito esto está 00:33:02
haciéndolo vale es un mientras verdadero cosa esto no con lo cual el bucle va contando hacia arriba 00:33:06
desde 1 hasta 10 en la variable y luego ya esa variable y la puedo utilizar para por ejemplo 00:33:12
imprimir en el monitor serie esa sería una salida la salida de ponme en el monitor serie el valor 00:33:16
de esa variable si yo estoy leyendo una distancia también le puedo decir que me diga cuánto vale en 00:33:21
el monitor serie el valor de esa variable y puedo comprobar qué valor tiene un ldr o lo que sea vale 00:33:26
entonces eso serían las que si estoy ahora en google pues no sé por qué lo dice sería no sé 00:33:34
vale entonces áfrica estaba claro entonces vale está claro entonces cómo funcionan esos dos ahora 00:33:49
estaréis viendo la presentación espero vale entonces este sabes ya cómo funciona esto 00:34:01
simplemente son órdenes específicas de salida vale vale entonces perfecto aquí yo puedo ya 00:34:07
os digo activar o desactivar pines con lo cual si tengo una luz directamente la enciende o si tengo 00:34:26
un sumador directamente lo activa empieza a zumbar pero también tengo algunas cosas específicas bueno 00:34:30
bien vamos con algunos ejemplos vale ahora estáis viendo vale estáis viendo la pantalla no vale 00:34:36
quiero que veamos algunos ejemplos para entender cómo funciona el primer ejemplo es el sensor de 00:34:44
aparcamiento que ya hemos visto vale en algún caso entonces nuestro algoritmo del sensor de 00:34:50
apagamiento era leer la variable leer el sensor de distancia y meterlo dentro de la variable 00:34:55
distancia vale yo cogí una variable que definía como distancia y le asignaba el valor que leíamos 00:35:01
de la información del sensor de distancia y luego si la distancia es mayor que 10 lo que hago es 00:35:07
que simplemente apagó el sonido y apagó el led tengo tanto un zumbador que está que emite un 00:35:14
sonido como un led y entonces yo los apagó porque tengo más distancia de la que de la que es 00:35:19
peligrosa espero 100 milisegundos y repito el bucle vale que ocurre que cuando yo voy haciendo marcha 00:35:25
atrás y voy aparcando llega un momento lo que la distancia el sensor de distancia lee esa distancia 00:35:33
menos de 10 centímetros y entonces se viene por el falso porque la distancia no es mayor y entonces 00:35:38
es pita y enciende el led y hasta se queda ahí hasta cuando nos alejamos es muy sencillo el 00:35:42
montaje sería algo parecido a esto vale vemos que tenemos ya tres bloques el sonido el led 00:35:49
el sensor de distancia y estos tres bloques yo los voy a poner dentro de mi circuito un 00:36:00
led que ya sabemos cómo se pone un zumbador como el que acabamos de ver también sé cómo se pone y 00:36:09
un sensor de distancia que también sabemos cómo se pone y cómo se conecta y ya está entonces qué 00:36:16
hacemos pues lo que hacemos es utilizar una orden de lectura del sensor ultrasonico y vamos a 00:36:22
almacenarlo en la variable de distancia que previamente habremos creado dentro de las 00:36:30
variables, habremos creado una variable de distancia y me habría salido ya el bloque 00:36:34
definir distancia en y dentro del círculo le meto 00:36:38
en la lectura, por lo tanto leemos el sensor ultrasonico que tengo 00:36:42
con el trigger en el 7, si fijáis el trigger está en el 7 00:36:46
el eco lo tengo al 4, el eco lo tengo al 4 en unidades 00:36:50
centímetros, vale, entonces después tomamos la decisión, si la distancia es mayor de 10 00:36:54
¿qué hacíamos? nada, pues ponemos el pin 13 00:36:58
que es donde está mi led a baja y ponemos el pin 12 que es donde está mi zumbador a baja apagamos 00:37:02
el sonido apagamos el led y está esperamos 100 milisegundos y volvemos que ocurre cuando la 00:37:10
distancia se hace menos de 10 pues cuando la distancia se hace menos de 10 va a venir a la 00:37:15
parte del sino y vamos a poner el pin 13 en alta y el pin 12 en alta y va a empezar el zumbador y 00:37:20
va a empezar el led a encenderse y ya está y va a estar zumbando y con el led encendido de aviso 00:37:26
hasta que la distancia vuelva a ser mayor que 10 y ya hemos terminado vale ya estaría hecho el 00:37:32
sensor de aparcamiento entonces esto es un pequeño vídeo que se grabado de cómo funciona en ticket 00:37:38
cad vale este es el circuito que utilizamos tenemos el sensor indican la distancia en esta 00:37:44
parte y cuando el objeto lo muevo se mueve la distancia pero cuando me acerco por debajo de 00:37:52
10 centímetros veis que se enciende y zumba vale si nos alejamos evidentemente se apaga veis que 00:37:58
funciona vale bien bueno pues entonces vemos que el sensor de aparcamiento funciona y este 00:38:10
es el simulador ahora podríamos este sensor de aparcamiento coger ese código y volcarlo a una 00:38:17
placa de verdad que hayamos hecho este montaje con cables y con aparatos y podríamos ponerlo 00:38:22
para que nos avise cuando estamos más cerca de un objeto de esos 10 centímetros 00:38:28
bueno como hacemos el reto que os había planteado el coche que evitaba los obstáculos versión 1.0 00:38:34
bueno es la versión 1.0 porque realmente no lo evita lo que hace es que cuando llega a menor 00:38:42
distancia de un valor se para bueno pues es lo mismo realmente que el sensor de aparcamientos 00:38:46
Si os fijáis tenemos el sensor de ultrasonidos, metemos la variable distancia, la distancia es menor de 20 y si la distancia es menor de 20 centímetros paramos el motor y activamos el LED diciendo que hay un objeto aquí que me está estorbando y me paro. 00:38:51
Y si la distancia es mayor que 20, esta condición es falsa, por lo tanto, activamos el motor, con lo cual el robot sigue para adelante y apagamos el LED, por lo que ya no hay peligro. 00:39:07
Esperamos 6 milisegundos y vuelta y vuelta y vuelta. Este es el algoritmo del robot evita obstáculos que habíamos planteado el reto. 00:39:20
esto sería el código, el código en pseudocódigo sería el mientras verdadero es el bucle infinito de cualquier robot 00:39:26
y luego leemos el sensor de ultrasonico, leemos la distancia, si la distancia es menor que 20 para el motor y activa el led 00:39:34
y si no, activa el motor, apaga el led y ya está, y esperamos 00:39:39
con lo cual ese pseudocódigo si lo ejecutamos va a estar pidiéndonos la distancia continuamente 00:39:43
nosotros se la metemos y cuando la distancia sea menor de 20 nos va a poner para el motor y activa el led 00:39:48
y va a volver a leer la distancia 00:39:53
bien, vemos que tenemos un bloque, sensor de ultrasonidos, otro bloque, motor y otro bloque LED 00:39:55
y además una variable que es distancia 00:40:02
esto es lo que nosotros tenemos que identificar antes de pasar a construir el objeto real, el proyecto real 00:40:04
tres bloques de Tinkercad, el sensor, el motor y el LED y una variable, distancia 00:40:09
pues nos vamos a nuestro Tinkercad, los tres bloques que ya hemos estudiado 00:40:17
cómo se conecta cada uno, los conectamos y ponemos nuestro sensor de ultrasonidos, nuestro motor y nuestro LED. 00:40:23
Con un montaje y en este caso hemos pinchado el motor al 12, el LED al 11, el trigger al 3 y el eco al 4. 00:40:31
Nos lo apuntamos, el motor al 12, el LED al 11, el trigger al 3, el eco al 4. 00:40:44
Y con esa información nos vamos a programar. 00:40:51
Como ya sabemos cómo se lee el sensor de ultrasonidos, que es lo primero que tenemos que hacer, 00:40:54
y cómo se asigna ese valor a una variable, luego la condición, sabemos también cómo se hace 00:40:58
porque conocemos los bloques de condición, los de bifurcación, y las órdenes de encender el motor 00:41:03
y de encender el LED también las conocemos y las de pararlo, con lo cual lo que hacemos simplemente 00:41:09
es transcribir literalmente lo que tenemos en nuestro diagrama de flujo en un programa, en este caso a través de bloques. 00:41:13
Primero usamos el bloque de leer el sensor ultrasonico que tengo en el desencadenador, el trigger en el 3, el eco en el 4, 00:41:21
en unidades centímetros y eso lo meto en la variable distancia que la he creado previamente. 00:41:28
Y luego, si la distancia es menor de 20, que es la condición que he puesto aquí, si es verdadero, ¿qué hago? 00:41:33
paro el motor y paro el led 00:41:39
el motor lo tengo en el 12 00:41:42
y el led lo tengo en el 11, por lo tanto 00:41:44
perdón, paro el motor 00:41:45
y activo el led 00:41:48
paro el motor y activo el led, que es lo que tengo que hacer 00:41:49
si la distancia es menor que 20 00:41:52
entonces desactivo el motor 00:41:54
y activo el led 00:41:56
y si 00:41:57
la distancia es mayor de 20, entonces desactivo 00:41:59
el led 00:42:02
y activo el motor, es decir 00:42:03
cuando no hay nada, el coche avanza 00:42:06
y el led está apagado 00:42:08
pero cuando encuentra un objeto a menos de 20 centímetros, el coche se para y enciende el LED. 00:42:09
Espera 100 milisegundos y ya está. Ya estaría hecho el programa. 00:42:15
Entonces, al final, resumiendo, tenemos nuestro algoritmo, que es lo primero que tenemos que hacer. 00:42:19
Tenemos que transformar ese algoritmo en un proyecto identificando los bloques que necesito. 00:42:26
Tenemos que ver qué pines son los que he utilizado para cada uno de los objetos 00:42:33
y luego transcribir el diagrama de flujo directamente a bloques utilizando la analogía que acabamos de ver a principio de clase. 00:42:36
¿Lo tenéis claro? ¿Alguna pregunta? 00:42:44
Esa es un poco la estructura de cómo se haría. 00:42:49
Abro el chat a ver si tenéis alguna pregunta. 00:42:56
O sea que tenemos que hacerlo igual que el tuyo. 00:43:01
Bueno, no tenéis que hacerlo igual, podéis utilizar otros pines, podéis hacer otras cosas, 00:43:03
pero realmente esto, lo que yo quiero es que lo entendáis, no que cojáis y copiéis exactamente lo que yo hago. 00:43:07
Quiero que hagáis una cosa mucho más complicada, que es pensar. 00:43:15
Pensar, eso es lo que quiero que hagáis. 00:43:22
Quiero que cojáis las piezas individuales y las mezcléis para hacer algo diferente. 00:43:24
Entonces, que si era para hoy, claro que era para hoy. 00:43:29
el proyecto era para hoy, de hecho hoy 00:43:35
una cosa, antes de que os vayáis de clase 00:43:37
os voy a 00:43:39
tengo una buena noticia y es que 00:43:40
esta es la última clase que voy a dar y tengo 00:43:42
otra buena noticia y es que ya tengo las notas 00:43:45
entonces ahora os voy a decir 00:43:47
las notas 00:43:48
y os voy a decir que va a pasar a partir de ahora 00:43:51
en cuanto acabe, os lo cuento 00:43:52
me falta lo del puente H y ya 00:43:54
os paso a decir lo de las notas 00:43:56
entonces, lo que quiero es que 00:43:59
penséis, lo que quiero es que tengáis esas piezas 00:44:01
básicas, como funciona un motor 00:44:03
como funciona un LED, como funciona un sensor 00:44:05
como funciona un botón 00:44:07
y luego las pueda mezclar 00:44:08
utilizando estas estructuras que son estructuras muy básicas 00:44:10
¿vale? 00:44:13
entonces, eso es lo que 00:44:14
quería, que vosotros resolvierais 00:44:17
algo 00:44:19
que yo no os haya dado 00:44:20
de forma original, de forma 00:44:22
creativa, de forma 00:44:24
¿vale? 00:44:26
ayer al hacer el robot, el bloque 00:44:29
de leer el sensor de ultrasonidos ponía 00:44:31
que se podía poner el trigger y el eco en el mismo pasador se puede hacer eso sí sí porque 00:44:32
hay un tipo de sensores que tienen solo tres patillas vale entonces si utilizamos el sensor 00:44:37
que tiene tres patillas trigger y eco van por la misma vale pero en el sensor de cuatro patillas 00:44:45
que es el que yo utilizo siempre porque es el que encontramos en cualquier tienda y es el que 00:44:51
tenemos en el labor del taller de robótica y es el que hubiéramos utilizado si hubiéramos 00:44:55
construido esto de verdad es el de cuatro patillas vale entonces estos sensores simplemente pueden 00:45:00
ser con las dos patillas comunes o con las dos patillas separadas entonces si puede ser puede 00:45:08
ser que vaya por la misma pero es otro sensor el que utiliza eso vale albert recibo tus mensajes 00:45:14
si los recibo ya te he visto bueno continuamos entonces este es el proceso del proceso creativo 00:45:22
parte de una idea parte de hacer un algoritmo con un diagrama de flujo una serie de órdenes 00:45:35
identificar qué cosas necesito me voy a la tienda las compro vale o voy al taller y las cojo si 00:45:41
tengo un montón y las junto las conecto y después cojo ese algoritmo y lo transformó en un programa 00:45:48
que ejecute esas órdenes para hacer lo que yo quiero que haga de acuerdo tan sencillo como eso 00:45:56
o tan complicado si se hace muchas veces ya os digo que normalmente se es bastante fácil hay 00:46:02
que saber cómo funciona cada pieza y ya está bueno entonces vamos al último apartado que es el puente 00:46:10
qué es el puente h bueno pues sabemos nosotros estamos utilizando motores verdad los motores 00:46:18
tienen esta pinta los motores de verdad que utilizamos en robótica en los modelos de 00:46:25
robótica de estos que hacemos en el taller pues utilizamos este tipo de motores que son para y 00:46:30
son iguales que los que hemos utilizado por ejemplo al principio curso para el de la puerta 00:46:35
corredera lo único que es un motor que tiene otro formato un formato especial para poderle 00:46:38
enganchar una rueda vale pero es lo mismo al final es un motor y entonces este motor como 00:46:43
lo conectamos pues lo conectamos a una pila a una batería y cuando cierro el interruptor el 00:46:50
motor gira qué pasa que si yo quiero que el motor gire en la dirección contraria os acordáis de la 00:46:55
puerta corredera vale yo lo que tengo que hacer es conectar la pila al revés donde el positivo con 00:46:59
esto el negativo donde el negativo con esto el positivo y entonces el motor lo que hace es girar 00:47:05
al revés pero claro si yo tengo un circuito hecho con mi tinker card tengo un robot construido yo 00:47:08
puedo activar y desactivar este motor pero como hago para que vaya hacia atrás si tendría que 00:47:18
cambiar los cables tendría que conectarle cables en otra posición y no voy a hacer que cada vez que 00:47:23
el robot tenga que cambiar me hace me da que acercar a él a cambiarle un cable entonces 00:47:30
para resolver vale esto que si no podemos cambiar los cables de posición como resolvemos el hecho 00:47:34
de que el motor vaya hacia delante o hacia atrás hacia los dos lados es para lo que se ha inventado 00:47:42
el puente h el puente h no tiene no es nada más que esto que veis aquí vale tenemos la fuente de 00:47:47
tensión y antes de conectar el motor lo que tengo es en lugar de un interno de un de un interruptor 00:47:54
tengo cuatro, S1, S2, S3 y S4. Entonces, si yo cierro S1 y S4, fijaros que lo que va a ocurrir es que la corriente eléctrica viene desde la batería, 00:48:01
pasa por este, porque este de aquí está abierto, el S3 está abierto, pasa por el S1, que estaría cerrado, el S2 está abierto, por lo tanto, 00:48:14
atraviesa el motor de izquierda a derecha y cruza por el S4 para llegar hasta la pila. El circuito estaría cerrado, el motor funcionaría 00:48:22
y la corriente eléctrica iría de izquierda a derecha. 00:48:29
Pero ¿qué pasa si yo quiero que el motor gire al revés? 00:48:32
Pues abro S1 y S4 y cierro S3 y S2. 00:48:36
Entonces la corriente eléctrica que sigue saliendo de la misma pila por el mismo lado 00:48:41
viene, ahora ya no entra por S1 que está abierto, ahora se viene y entra por S3 que está cerrado. 00:48:45
S4 está abierto, no puede avanzar, con lo cual atraviesa el motor que viene ahora de derecha a izquierda, 00:48:50
al revés que antes. 00:48:56
y si os fijáis ese 2 que estaba cerrado viene y termina el circuito con lo cual la corriente pasa 00:48:57
por el motor de derecha a izquierda si cierro ese 1 y ese 4 la corriente atraviesa el motor de 00:49:03
izquierda a derecha si el paso la corriente por ese 3 y ese 2 el motor la corriente necesita 00:49:09
atraviesa el motor de derecha izquierda y ese día giro contrario de acuerdo es un puente h no tiene 00:49:18
nada más normalmente claro los interruptores no son interruptores de estos que tenemos en 00:49:24
la pared o interruptores de los que tenemos en el taller son transistores y yo los manejo a 00:49:29
través de las señales que utilizo en mi placa de arduino yo a través de las señales de arduino 00:49:34
le voy a decir si quiero que cierre ese 1 y ese 4 o si quiero que cierre ese 2 y ese 3 y entonces 00:49:41
estos circuitos tienen esta pinta normalmente lo vamos a comprar este es un puente h para dos 00:49:47
motores cada motor lo conectaría en las bornas verdes aquí es donde yo conectaría mi motor y 00:49:53
aquí mi otro motor dos motores vale por ejemplo rueda derecha rueda izquierda si tengo un coche 00:50:01
con dos ruedas entonces esas dos ruedas ahora yo les puedo decir que vayan hacia adelante que vayan 00:50:06
hacia atrás que separen o que hagan cosas como se lo digo bueno pues aquí en estos conectores yo voy 00:50:11
a poner en los dos del centro ground y vcc que es tensión le voy a poner cinco voltios y cero 00:50:17
conectado cinco voltios siempre y cero siempre y luego en los dos de este lado estos dos pines 00:50:25
los voy a conectar a dos pines de la placa de arduino que yo voy a activar o desactivar en 00:50:31
función de lo que quiero que haga el motor que está en este lado y los otros dos pines que son 00:50:36
aquellos que están en el otro extremo los voy a conectar a otros dos pines de mi placa arduino 00:50:41
y según los active o los desactive, le voy a ir indicando que quiero que haga el motor que está conectado en este otro lado. 00:50:47
Entonces yo ahora poniendo o quitando, activando o desactivando esos pines, puedo irle diciendo a esta placa que el motor de la derecha vaya hacia adelante 00:50:53
o que el motor de la derecha vaya hacia detrás o que el motor de la derecha pare o que el motor de la derecha no haga nada y se vaya sobre su propia inercia. 00:51:05
entonces eso lo voy a hacer a través de esto de estos dos pines que yo le puedo poner pues en 00:51:15
desactivado desactivado o desactivado activado o también activado desactivado o los dos activados 00:51:22
con lo cual tengo cuatro posibles órdenes que yo le admito que yo le puedo pasar a la placa y esto 00:51:28
de aquí este chip de aquí es el que tiene los transistores para hacer que la corriente eléctrica 00:51:34
a estos dos pines de que son los que van al motor lleguen positivo y negativo o cambiadas negativo 00:51:43
y positivo de acuerdo los interruptores vamos a llamarlos que son realmente transistores están 00:51:50
aquí dentro entonces las órdenes que llegan por aquí entran a este chip este chip hace el cambio 00:51:56
de los interruptores que corresponden en el puente h y activa o desactiva las tensiones en los dos 00:52:03
bornes que van a mi motor por lo tanto al motor le va a llegar lo que yo le estoy indicando tiene 00:52:09
sentido lo que acabo de decir más o menos entendéis cómo funciona un puente h me lo podéis decir por 00:52:15
el chat si entendéis cómo funciona un puente h si vale entonces el puente h básicamente es lo que me 00:52:25
sirve para que en un proyecto de robótica con un motor yo pueda decirle que vaya hacia delante o 00:52:30
que vaya hacia atrás y lo voy a hacer conectando una plaquita intermedia que es esta vale que 00:52:37
normalmente se llaman drivers de motor vale son drivers motor drivers en inglés vale drivers para 00:52:43
motores son drivers que permiten que permiten indicar que el motor vaya hacia delante hacia 00:52:49
atrás sin tener que cambiarle la polaridad de los cables bien esto es un poco lo que lo que 00:52:56
teníamos que haber hecho para hoy los puentes h los retos y todo esto vale entonces 00:53:03
Entonces, el puente H, por cierto, antes de terminar, voy a salir de la presentación ya y voy a dejar de compartir la presentación y voy a compartir de nuevo mi navegador, ¿vale? 00:53:10
Ahora deberíais estar viendo mi navegador, ¿vale? Entonces, los puentes H, nosotros tenemos un circuito integrado dentro de los dispositivos. 00:53:25
dentro de los dispositivos nosotros tenemos circuitos integrados que son puentes h vale 00:53:44
entonces yo tengo por aquí un ejemplito que lo he copiado de por ahí no lo he hecho yo vale de cómo 00:53:53
funcionan los puentes h normalmente ese driver de ese driver de motores ese driver de puente h 00:54:00
a ver si lo tengo, vale es que tengo más páginas, ya decía yo, vale, esto sería, no, cuál es, cuál es, cuál es, este, vale, entonces este utiliza un puente H, a ver, aquí lo tenemos, vale, esto sería un puente H, el L293D es un chip que es un puente H, 00:54:08
Si os fijáis, yo tengo un motor conectado a este pin a la salida 3 y a la salida 4, que sería esta, y tengo otro motor conectado a las que están enfrente, a la salida 1 y a la salida 2. 00:54:42
y luego tengo las entradas de señal y las entradas de potencia. 00:54:58
Entonces las señales serían señales que vienen a estos pines, al 5 y al 6, al 10 y al 9, 00:55:05
son los dos pines de señal que yo voy a utilizar para cada uno de los motores 00:55:13
y luego tengo potencia, potencia para un motor y potencia para otro motor 00:55:16
que lo estoy sacando de una pila de 9 voltios para que vaya más rápido. 00:55:21
entonces en el código, en este caso, bueno el código está en formato de código 00:55:24
no está en formato de bloques, pero yo lo que voy a hacer es mandarle determinadas órdenes 00:55:29
para que el motor, en este caso, pues si os fijáis gira uno 00:55:33
que está aquí girando y si yo le voy poniendo, le voy pulsando en determinadas configuraciones 00:55:38
pues estos motores van hacia delante, van hacia detrás, es decir 00:55:47
Al final puedo articular alguna forma de meterle las órdenes para que avancen o vayan hacia atrás. Al final es lo mismo que hemos visto, pero con formato de chip integrado. 00:55:50
Ahora por ejemplo se ha arrancado este, este de aquí se arranca y se para, este de aquí ahora se arranca y se para y este va a continuo. 00:56:03
Al final lo que podemos hacer es hacer que esos motores vayan hacia delante o hacia atrás también, cambiando las señales que yo pongo en los pines 5 y 6 para un motor y 9 y 10 para el otro. 00:56:14
Y así es como los controlo. 00:56:28
Entonces, ¿qué pasa? Que ahora ya podemos hacer un robot que vaya hacia delante. 00:56:29
¿Os acordáis del reto de Semana Santa? 00:56:34
Un robot que vaya hacia delante y vaya midiendo distancias. 00:56:36
en el momento en el que detecte que la distancia es menor que una cantidad concreta 00:56:39
15 centímetros o 20 centímetros por ejemplo 00:56:45
¿Qué vamos a hacer? Parar motores 00:56:47
vamos a hacer que uno de los dos motores vaya hacia atrás 00:56:50
durante un tiempo concreto 00:56:54
moviéndose a una velocidad 00:56:56
y una vez que hayamos esperado ese tiempo y tengamos el robot reubicado 00:56:59
otra vez pondremos los motores a andar hacia adelante 00:57:04
Este reto que ya lo hicimos en Semana Santa, ¿vale? Es el reto final que yo tengo para vosotros en este curso. 00:57:07
Entonces, ¿qué es lo que quiero? Quiero que investiguéis, ¿vale? Cómo funciona este chip, os lo apuntáis, por favor, chip L293D. 00:57:15
y lo tenéis si os vais aquí a componentes todos vale pues en uno de los chips que estaban por 00:57:26
aquí al final lo tenéis aquí están los chips si encuentro este el controlador de motor de puente 00:57:35
h l 293 de vale el último de acuerdo también tenemos un controlador de motor simple o sea 00:57:45
si os fijáis también tenemos el controlador con la forma con la forma que os he enseñado de placa 00:57:53
con los pines aquí una serie de pines una serie de estos son drivers más complejos este es más 00:57:58
sencillito y por eso quiero que utilicéis este el l 293 de vale entonces si queréis vale ahora 00:58:05
os voy a dar las notas si queréis podéis hacer el reto para subir nota de acuerdo los que os 00:58:14
conformes con la nota que tenéis pues punto final se acabó el curso y los que hayáis suspendido 00:58:22
tendremos un examen de recuperación vale que ya os diré las instrucciones a vosotros concretamente 00:58:28
para que os conectéis o sea que hay que buscar cómo funciona el l exactamente en internet si 00:58:35
tú vas y buscas tinker cad el tinker cad puente h ejemplos vale vas a tener un montón de ejemplos 00:58:42
pero también podéis mirar cómo funciona este chip el l 293 de intentar hacer las conexiones de 00:58:49
acuerdo es un reto complicado ya lo sé si habéis conseguido seguirme hasta este punto si habéis 00:58:56
conseguido saber cómo se conectan las cosas cómo se hacen los algoritmos cómo se hacen los programas 00:59:02
para que vale activar o desactivar los pines esto nos va a resultar demasiado complicado vale pero 00:59:07
un reto interesante y era el reto final de este curso que yo tenía para luego construir un coche 00:59:13
como el que veíamos en el vídeo inicial no sé si os acordáis cuando empezamos con este tema que 00:59:20
es un coche que avanza cuando llega a un objeto se para se gira y sigue avanzando en otra dirección 00:59:25
vale entonces se hace con estas piezas y se hace con esta con estas con esta con estos bloques que 00:59:31
hemos estado viendo de acuerdo y lo único que nos faltaba era la pieza del puente h que es lo que 00:59:38
yo necesito para hacer que el motor vaya hacia adelante y hacia atrás de acuerdo visto alguna 00:59:42
duda hay que hacer algo en tinker card claro hay que y hacer un coche que tenga los dos motores 00:59:49
que vayan hacia adelante y un sensor de distancia y cuando la distancia yo se la ponga por debajo 01:00:03
de 20 los motores tienen que pararse uno de ellos tiene que ir hacia atrás durante un segundo 01:00:07
pongamos o medio segundo el tiempo que decidamos el tiempo que queráis porque luego eso hasta que 01:00:14
no lo pruebas luego no lo podríamos ajustar pues durante medio segundo por ejemplo un segundo se 01:00:18
para y vuelven a avanzar otra vez hacia delante los las dos ruedas con lo cual así el coche lo 01:00:24
que estaría haciendo es evitar obstáculos vale eso sería el reto entonces el reto es para subir nota 01:00:29
los que ya habéis aprobado vale y para los que no habéis aprobado pues os tendréis que poner en 01:00:37
en vez de hacer el reto ponemos a estudiar la primera y la segunda evaluaciones vale 01:00:44
para las recuperaciones ahora os digo las notas y os digo cómo queda la foto final 01:00:47
de acuerdo alguna duda alguna pregunta bueno voy a parar ya la grabación 01:00:54
Valoración:
  • 1
  • 2
  • 3
  • 4
  • 5
Eres el primero. Inicia sesión para valorar el vídeo.
Idioma/s:
es
Materias:
Tecnologías de la Información
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Educación Secundaria Obligatoria
    • Ordinaria
      • Primer Ciclo
        • Primer Curso
        • Segundo Curso
      • Segundo Ciclo
        • Tercer Curso
        • Cuarto Curso
        • Diversificacion Curricular 1
        • Diversificacion Curricular 2
  • Bachillerato
    • Primer Curso
    • Segundo Curso
Autor/es:
JUAN RAMÓN GARCÍA MONTES
Subido por:
Juan Ramã‼N G.
Licencia:
Reconocimiento - No comercial - Sin obra derivada
Visualizaciones:
99
Fecha:
7 de mayo de 2020 - 18:50
Visibilidad:
Público
Centro:
IES ANTONIO GAUDI
Duración:
1h′ 01′ 05″
Relación de aspecto:
1.78:1
Resolución:
1866x1050 píxeles
Tamaño:
197.99 MBytes

Del mismo autor…

Ver más del mismo autor

Comentarios

Para publicar comentarios debes entrar con tu nombre de usuario de EducaMadrid.

Comentarios

Este vídeo todavía no tiene comentarios. Sé el primero en comentar.


EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid