1
00:00:01,840 --> 00:00:18,039
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.

2
00:00:18,280 --> 00:00:26,059
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.

3
00:00:26,059 --> 00:00:32,420
después lo que hemos estado haciendo ha sido viendo qué bloques tenemos dentro de tinker

4
00:00:32,420 --> 00:00:40,179
cada circuito para poder simular lo que sería la construcción de un robot y un poco lo que quiero

5
00:00:40,179 --> 00:00:49,159
y es ver cómo enlazan esas dos partes y que quede claro como nosotros desde un circuito diseñado

6
00:00:49,159 --> 00:00:58,359
desde un algoritmo diseñado con PSINT podemos pasar a Tinkercad. Entonces para eso os he preparado

7
00:00:58,359 --> 00:01:13,140
una pequeña presentación que voy a compartir con vosotros y supongo que ahora deberéis de estar

8
00:01:13,140 --> 00:01:25,280
viendo ya el powerpoint y ahora deberéis estar viendo la presentación me podéis confirmar por

9
00:01:25,280 --> 00:01:34,920
favor que estáis viendo la presentación todos por el chat no lo podéis decir perfecto gracias

10
00:01:34,920 --> 00:01:42,439
entonces nada vamos a ver unos conceptos finales ya para redondear un poco lo que son la construcción

11
00:01:42,439 --> 00:01:48,920
de robots. Estamos haciéndolo a un nivel muy básico, es decir, estamos haciendo unos robots caseros,

12
00:01:49,260 --> 00:01:56,920
cosas con algunas piezas muy sencillas y con pocas piezas. Entender que cuando esto se aplica

13
00:01:56,920 --> 00:02:05,680
en un nivel industrial o en un nivel ya de producción corporativa, cuando vamos a las empresas multinacionales

14
00:02:05,680 --> 00:02:11,300
si estas empresas se dedican a construir robots, esto es multiplicado por mil.

15
00:02:11,300 --> 00:02:21,479
Es decir, un robot tiene cientos o miles de sensores y esos miles de sensores tenemos que leerlos todos,

16
00:02:22,099 --> 00:02:28,979
tenemos que almacenar sus valores en variables, tenemos que procesar esas variables y esos valores para tomar decisiones

17
00:02:28,979 --> 00:02:39,139
Y con toda la casuística posible que podemos encontrar de todos esos sensores, ejecutar las decisiones sobre los actuadores.

18
00:02:39,360 --> 00:02:47,939
Entonces, ese proceso, la potencia que nos dan los procesadores, permite hacerlo en un tiempo razonable.

19
00:02:48,560 --> 00:02:52,000
Pero claro, cuantos más sensores tengamos, más información hay que procesar.

20
00:02:52,180 --> 00:02:58,960
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.

21
00:02:58,979 --> 00:03:09,379
cómo manejar esos volúmenes grandes de información con tantos sensores, con tantas variables, con tantas casuísticas, con tantas posibles cosas

22
00:03:09,379 --> 00:03:18,259
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

23
00:03:18,259 --> 00:03:22,439
y tomar decisiones para actuar sobre nuestros actuadores.

24
00:03:23,099 --> 00:03:29,599
Entonces, entendiendo este concepto, quiero que entendáis por qué estamos viendo estas cosas

25
00:03:29,599 --> 00:03:36,840
y por qué estamos analizando los robots desde un punto de vista más teórico.

26
00:03:37,840 --> 00:03:41,439
Lo primero que hay que hacer siempre es construirse un diagrama de flujo

27
00:03:42,020 --> 00:03:46,599
que normalmente es un diagrama de flujo general, un diagrama de flujo en el cual nosotros

28
00:03:46,599 --> 00:03:58,960
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

29
00:03:58,960 --> 00:04:10,639
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

30
00:04:10,639 --> 00:04:15,819
que podemos programar en un lenguaje de programación, cosas como asigna un valor a una variable,

31
00:04:16,819 --> 00:04:24,660
cosas como activa un determinado dispositivo de salida, recoge un valor de un determinado sensor,

32
00:04:24,660 --> 00:04:31,879
cosas que podemos programar directamente. Entonces ese es el reto, empezar desde un diagrama de flujo muy general

33
00:04:31,879 --> 00:04:37,199
y luego irlo complicando, irlo desgranando hasta llegar al nivel de programación.

34
00:04:37,199 --> 00:05:06,779
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.

35
00:05:07,199 --> 00:05:29,600
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.

36
00:05:29,600 --> 00:05:41,100
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.

37
00:05:41,980 --> 00:05:53,680
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.

38
00:05:53,680 --> 00:06:22,839
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.

39
00:06:22,839 --> 00:06:30,379
a la sensorización a todos esos valores de esos sensores manejarlos entenderlos interpretarlos

40
00:06:30,379 --> 00:06:35,000
y después actuar sobre los actuadores correspondientes que normalmente son motores

41
00:06:35,000 --> 00:06:43,519
luces o cosas así de acuerdo y con esto ya con estos principios con estos con estos con estas

42
00:06:43,519 --> 00:06:48,879
cosas básicas ya vamos a poder hacer pues desde un robot tonto como el que estamos haciendo que

43
00:06:48,879 --> 00:06:53,259
cuando encuentro un objeto se para hasta un satélite artificial hasta una nave que vaya

44
00:06:53,259 --> 00:06:58,720
a la luna es que podemos hacer lo que nos dé la gana porque ya es aplicar lo mismo pero

45
00:06:58,720 --> 00:07:07,180
utilizando esos principios hacer cosas más complejas vale entonces como introducción sirva

46
00:07:07,180 --> 00:07:15,120
esto de ánimo y de motivación para que si os gusta pues profundicéis y vamos a ver hoy tres

47
00:07:15,120 --> 00:07:21,660
cosas voy a centrar en tres aspectos vale tres aspectos que son primero voy a intentar haceros

48
00:07:21,660 --> 00:07:29,100
ver la equivalencia entre ps int los algoritmos que hemos visto ese pseudo código el escribir en

49
00:07:29,100 --> 00:07:34,259
lenguaje natural pues cuando se ocurre esto hago esto y si no hago lo otro simplemente una cosa

50
00:07:34,259 --> 00:07:39,779
que podemos escribir nosotros en un folio un pseudo código y un diagrama de flujo con una

51
00:07:39,779 --> 00:07:47,339
serie de tareas en orden y una serie de estructuras de bucles de decisiones de bifurcaciones etcétera

52
00:07:47,339 --> 00:07:54,100
que podemos modelar y cómo transportarlo a luego un programa en bloques como podemos utilizar en

53
00:07:54,100 --> 00:08:00,120
tinker cat circuits vale el programa en bloques de tinker cat circuits tiene una última ventaja

54
00:08:00,120 --> 00:08:06,660
que os voy a contar hoy y es que yo puedo ese programa transformarlo en código código es el

55
00:08:06,660 --> 00:08:12,600
código de programación y volcarlo en una tarjeta real para que haga exactamente lo que yo estoy

56
00:08:12,600 --> 00:08:17,819
viendo en el modelo en el modelo de pantalla entonces cuando yo hago una simulación con

57
00:08:17,819 --> 00:08:23,220
tinker cat circuits realmente el siguiente paso y último que es lo que no vamos a poder hacer

58
00:08:23,220 --> 00:08:28,980
nosotros porque no estamos en clase pero hubiéramos hecho en caso de haber estado en clase es luego

59
00:08:28,980 --> 00:08:35,519
una placa de verdad un motor de verdad un led de verdad una protoboard de verdad montar el circuito

60
00:08:35,519 --> 00:08:39,879
coger el programa que yo he hecho con la simulación en Tinkercad

61
00:08:39,879 --> 00:08:43,659
transformarlo en código y volcárselo a la placa y ver que funciona

62
00:08:43,659 --> 00:08:46,679
y ver que hace lo que se supone que tiene que hacer

63
00:08:46,679 --> 00:08:51,399
entonces, bueno, el primer aspecto va a ser coger esas equivalencias entre PSI

64
00:08:51,399 --> 00:08:55,419
y los bloques de Tinkercad, luego voy a coger algunos circuitos de ejemplo

65
00:08:55,419 --> 00:08:58,799
y voy a resolver el reto que os propuse

66
00:08:58,799 --> 00:09:03,500
y por último voy a daros un último apunte sobre los motores

67
00:09:03,500 --> 00:09:13,179
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.

68
00:09:13,620 --> 00:09:20,500
¿De acuerdo? Bueno, pues entonces sin más pasamos al primer aspecto que es las equivalencias entre PSINT y Tinkercad Circuits.

69
00:09:21,279 --> 00:09:27,200
Bien, PSINT ya hemos dado muchas clases, ya hemos visto cómo funciona, hemos hecho muchos ejercicios, muchos ejemplos.

70
00:09:27,200 --> 00:09:34,080
Veamos al final cómo hacemos, por ejemplo, la lectura de un sensor en PSINT.

71
00:09:34,639 --> 00:09:40,960
La lectura de un sensor, que es el primer paso de un robot, leer los sensores y asignar esos valores en ciertas variables,

72
00:09:41,860 --> 00:09:45,179
lo simulábamos con ese diagrama de flujo.

73
00:09:45,379 --> 00:09:51,419
En PSINT lo que hacíamos era poner por pantalla, leer el sensor de ultrasonidos, por ejemplo,

74
00:09:51,419 --> 00:09:58,360
y luego quedábamos esperando para que el usuario introdujera el valor de ese sensor

75
00:09:58,360 --> 00:10:03,039
y lo almacenábamos en una variable que en este caso hemos llamado distancia.

76
00:10:03,460 --> 00:10:05,659
En este caso lo hemos llamado distancia.

77
00:10:06,539 --> 00:10:11,179
Bien, entonces, ¿qué es lo que tenemos en Tinkercad?

78
00:10:11,340 --> 00:10:16,799
Este bloque, evidentemente todas las órdenes anteriores y las órdenes posteriores me las quito,

79
00:10:16,799 --> 00:10:29,639
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.

80
00:10:29,899 --> 00:10:39,519
Para eso tenemos una opción dentro de las diferentes opciones que nos dan los bloques de Tinkercad, que es la de las variables.

81
00:10:39,519 --> 00:10:46,259
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.

82
00:10:46,259 --> 00:10:50,700
le puedo poner el nombre que me dé la gana. Y ya sabéis que una variable no deja de ser una caja

83
00:10:50,700 --> 00:10:58,700
donde yo meto información, una caja vacía. Es como un cajón con una etiqueta que pone distancia

84
00:10:58,700 --> 00:11:04,259
y ese cajón yo puedo abrirlo y poner información ahí dentro o puedo abrirlo y ver qué información hay ahí dentro.

85
00:11:04,779 --> 00:11:09,039
Es así de fácil. Entonces tenemos las variables, que es lo primero que tenemos que definir.

86
00:11:09,379 --> 00:11:13,500
Y después, ¿cómo recogemos la información para almacenarla en la variable?

87
00:11:13,500 --> 00:11:37,299
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.

88
00:11:37,299 --> 00:11:45,779
También podemos leer pasadores analógicos que ya sabéis que son donde yo conecto los sensores que me devuelven información

89
00:11:45,779 --> 00:11:52,259
Pero esa información siempre va a estar entre 0 y 1024, es decir, es un número entre 0 y 1024

90
00:11:52,259 --> 00:11:59,120
Entonces, si yo estoy mirando temperaturas, pues desde la mínima temperatura que yo puedo medir hasta la máxima

91
00:11:59,120 --> 00:12:02,639
Voy a coger y lo voy a poner con números de 0 a 1024

92
00:12:02,639 --> 00:12:23,559
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.

93
00:12:23,559 --> 00:12:34,960
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.

94
00:12:35,980 --> 00:12:47,799
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.

95
00:12:47,799 --> 00:13:00,000
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.

96
00:13:00,360 --> 00:13:16,659
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.

97
00:13:16,659 --> 00:13:27,080
sería un bloque en el cual yo asignó a la variable distancia que la he definido el valor de leer el

98
00:13:27,080 --> 00:13:32,059
sensor de distancia del pin 7 en el eco 4 por ejemplo unidades en centímetros si yo lo que

99
00:13:32,059 --> 00:13:37,039
estoy simplemente es mirando si un botón está pulsado no os cojo leo el pasador digital número

100
00:13:37,039 --> 00:13:42,740
5 y lo asignó en la variable así es como yo recojo la información de mis sensores y la almacena en

101
00:13:42,740 --> 00:13:55,600
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

102
00:13:55,600 --> 00:14:07,879
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

103
00:14:07,879 --> 00:14:11,759
sensores yo creo que a estas alturas más o menos ya todo el mundo lo tenía claro pero bueno por si

104
00:14:11,759 --> 00:14:27,679
acaso quería quería quería verlo entonces preguntas alguna cosa no veo nada por el chat si no pues me

105
00:14:27,679 --> 00:14:34,840
levantáis la mano vale y yo os doy paso me lo ponéis por el chat y yo os contesto vale pues

106
00:14:34,840 --> 00:14:41,559
continuamos entonces de acuerdo entonces lo siguiente una vez que hemos leído los sensores

107
00:14:41,559 --> 00:14:45,440
si hemos asignado en las variables esos valores, tenemos que tomar decisiones.

108
00:14:46,039 --> 00:14:53,179
Y aquí es donde teníamos las estructuras de repetición, los bucles, las bifurcaciones, las decisiones.

109
00:14:53,299 --> 00:15:02,000
Entonces, por ejemplo, una decisión que es esta parte, si se cumple la condición hago las acciones de la derecha

110
00:15:02,000 --> 00:15:05,100
y si no se cumple hago las acciones de la izquierda.

111
00:15:06,100 --> 00:15:09,019
Y luego ya continuamos con nuestras acciones comunes.

112
00:15:09,019 --> 00:15:20,100
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.

113
00:15:20,259 --> 00:15:30,259
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.

114
00:15:31,059 --> 00:15:36,820
Y las acciones que hay que hacer si no se cumple la condición, hay que meterlas dentro del segundo espacio.

115
00:15:36,820 --> 00:15:42,879
y estas decisiones las tomamos a través de bloques que tienen forma de hexágono

116
00:15:42,879 --> 00:15:47,220
y esto lo tenemos dentro de matemáticas, dentro de la parte de matemáticas

117
00:15:47,220 --> 00:15:55,879
entonces yo tengo aquí unas condiciones de comparación menor, menor o igual, mayor, mayor o igual, distinto o igual

118
00:15:55,879 --> 00:16:04,220
y esto yo puedo comparar valores concretos como en este caso 1,1 o también dentro de estas estructuras redondas

119
00:16:04,220 --> 00:16:11,700
puedo meter variables o puedo meter otras cosas que tengan esa forma. También tengo una combinación

120
00:16:11,700 --> 00:16:18,659
de varias decisiones, es decir, de varias condiciones. Si yo digo que se tiene que cumplir algo y además

121
00:16:18,659 --> 00:16:23,120
se tiene que cumplir otra cosa a la vez, entonces tendría que utilizar una estructura de este tipo

122
00:16:23,120 --> 00:16:30,179
donde yo ya tengo una combinación de dos condiciones. La primera condición, que sigue siendo hexagonal,

123
00:16:30,179 --> 00:16:38,360
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.

124
00:16:38,759 --> 00:16:43,820
Y cuando yo pregunte si una variable tiene un determinado valor o si es mayor o si es menor o qué pasa con ella,

125
00:16:45,000 --> 00:16:51,200
entonces, si se cumple esa condición, entraré al primer espacio de acciones a ejecutar y si no, entraré al segundo.

126
00:16:51,480 --> 00:16:56,039
Y así es como funcionan las bifurcaciones, las decisiones.

127
00:16:56,039 --> 00:17:01,460
¿Cómo funcionan los bucles? Las estructuras de repetir mientras y las estructuras de repetir hasta.

128
00:17:02,279 --> 00:17:05,579
En este caso, la que tenemos aquí a la izquierda es una de repetir mientras.

129
00:17:06,059 --> 00:17:08,819
Mientras se cumpla esta condición, voy a ejecutar las acciones.

130
00:17:08,819 --> 00:17:15,940
Si os fijáis, os acordáis que estas acciones puede que no se ejecuten nunca si inicialmente no se cumple la condición.

131
00:17:16,339 --> 00:17:19,460
Es decir, yo compruebo la condición, por eso es un bucle mientras.

132
00:17:19,940 --> 00:17:24,460
Mientras se mantenga esta condición, mientras se cumpla, yo ejecuto.

133
00:17:24,460 --> 00:17:32,339
Y si no se cumple desde el principio no ejecuto nunca. Tenemos un bloque dentro de Tinkercad que es el repetir mientras.

134
00:17:33,500 --> 00:17:40,359
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.

135
00:17:40,799 --> 00:17:44,859
Entonces mientras que se cumpla esta condición yo voy a ejecutar un bloque de código.

136
00:17:44,859 --> 00:17:54,359
¿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.

137
00:17:54,539 --> 00:18:00,200
Por lo tanto, el conjunto de acciones se va a ejecutar al menos una vez. Esa es la diferencia.

138
00:18:00,920 --> 00:18:10,319
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.

139
00:18:10,319 --> 00:18:22,240
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í.

140
00:18:22,460 --> 00:18:26,200
Y cuando se evalúe la condición, si se sigue cumpliendo, repetimos y si no, se sale.

141
00:18:26,859 --> 00:18:37,599
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.

142
00:18:37,599 --> 00:18:40,319
Entonces esas serían las estructuras

143
00:18:40,319 --> 00:18:42,640
Repetir mientras se repetirá esta dentro de Tinkercad

144
00:18:42,640 --> 00:18:45,539
Son las mismas estructuras que veíamos en PSA

145
00:18:45,539 --> 00:18:47,960
Pero las tenemos ahora en forma de bloque

146
00:18:47,960 --> 00:18:52,140
Y después tenemos otra estructura

147
00:18:52,140 --> 00:18:53,359
Que es la de la repetición

148
00:18:53,359 --> 00:18:55,140
La del bucle de repetición

149
00:18:55,140 --> 00:18:56,480
Un número concreto de veces

150
00:18:56,480 --> 00:19:00,039
En este caso en Tinkercad tenemos dos opciones

151
00:19:00,039 --> 00:19:03,220
Tenemos una que nos hace directamente

152
00:19:03,220 --> 00:19:05,099
Una repetición de un número de veces

153
00:19:05,099 --> 00:19:13,079
Sin más, lo que meta ahí dentro se va a repetir en bucle durante 10 vueltas y luego seguimos viaje.

154
00:19:13,779 --> 00:19:26,180
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.

155
00:19:26,319 --> 00:19:28,940
Por ejemplo, podemos ir desde 1 hasta 10 de 1 en 1.

156
00:19:28,940 --> 00:19:35,440
bueno pues si la variable la llamo y por ejemplo vale y quiero ir desde un valor inicial hasta un

157
00:19:35,440 --> 00:19:41,440
valor final de a un ritmo concreto a un paso concreto pues lo que vamos a hacer es utilizar

158
00:19:41,440 --> 00:19:48,299
la otra estructura que utiliza esta forma más extendida no es sólo repetir 10 veces sino que

159
00:19:48,299 --> 00:19:54,779
ahora me va a decir me permite ejecutarlo hacia arriba o hacia abajo y me va a decir para la

160
00:19:54,779 --> 00:20:06,720
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,

161
00:20:06,799 --> 00:20:16,940
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

162
00:20:16,940 --> 00:20:26,440
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.

163
00:20:27,440 --> 00:20:35,660
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

164
00:20:35,660 --> 00:20:43,400
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.

165
00:20:43,400 --> 00:20:48,960
vale él ahí va a almacenar es un contador de vueltas cual iba a almacenar el valor de la

166
00:20:48,960 --> 00:20:54,559
vuelta en la que me encuentro y lo puedo utilizar de acuerdo dos opciones una repetir un número de

167
00:20:54,559 --> 00:21:00,779
veces sin ninguna variable que vaya acumulando en la vuelta en la que me encuentro y otro es

168
00:21:00,779 --> 00:21:07,099
el que tenemos exactamente igual en pese in que sería con una variable desde un valor inicial

169
00:21:07,099 --> 00:21:15,079
hasta un valor final y con un paso con un ritmo y por último ya hemos visto como leemos los

170
00:21:15,079 --> 00:21:22,099
los sensores y almacenamos sus valores en variables. Ya hemos visto cómo tomar decisiones

171
00:21:22,099 --> 00:21:27,019
o cómo hacer esas estructuras de control de repetición para poder manejar la información

172
00:21:27,019 --> 00:21:31,640
y llegar a conclusiones y ahora en el momento en el que tengamos que tomar las decisiones

173
00:21:31,640 --> 00:21:37,420
las tomamos y decidimos actuar o no. Si tenemos que actuar en algún actuador, si tenemos

174
00:21:37,420 --> 00:21:43,359
que realizar acciones sobre los actuadores, entonces vamos a utilizar las órdenes que

175
00:21:43,359 --> 00:21:45,400
veíamos en PSINT que hacíamos

176
00:21:45,400 --> 00:21:47,259
directamente poniendo un texto en pantalla

177
00:21:47,259 --> 00:21:49,220
diciendo lo que hacíamos. Vale, pues

178
00:21:49,220 --> 00:21:51,500
acción a realizar sobre el actuador, arrancar

179
00:21:51,500 --> 00:21:53,279
un motor, encender un LED, parar

180
00:21:53,279 --> 00:21:55,240
un motor, parar un LED. ¿Cómo

181
00:21:55,240 --> 00:21:57,279
vamos a hacer eso ahora nosotros en Tinkercad?

182
00:21:57,380 --> 00:21:59,180
Bueno, pues como lo que tenemos es una placa donde

183
00:21:59,180 --> 00:22:00,839
yo tengo conectado en ciertos pines

184
00:22:00,839 --> 00:22:03,240
los actuadores, lo que vamos a

185
00:22:03,240 --> 00:22:05,220
tener es esa estructura

186
00:22:05,220 --> 00:22:07,259
como poner un

187
00:22:07,259 --> 00:22:09,319
pin digital concreto

188
00:22:09,319 --> 00:22:11,220
o activado o

189
00:22:11,220 --> 00:22:12,980
no activado, de forma que

190
00:22:12,980 --> 00:22:18,859
activo el actuador o no lo activo si lo pongo en alta meto 5 voltios por ese

191
00:22:18,859 --> 00:22:22,579
cable y entonces lo que está allí conectado se arranca y si lo pongo en

192
00:22:22,579 --> 00:22:26,539
baja no meto un voltaje y entonces lo que está allí conectado es como abrir un

193
00:22:26,539 --> 00:22:31,539
interruptor se para vale luego tengo algunos que son específicos para ciertos

194
00:22:31,539 --> 00:22:36,319
actuadores por ejemplo si tengo un servomotor puedo girar ese servomotor el

195
00:22:36,319 --> 00:22:40,599
servomotor es un es un motor que gira entre 0 y 180 grados y yo le puedo

196
00:22:40,599 --> 00:22:46,220
definir ya no sólo el pin en el que lo tengo sino cuántos grados lo quiero girar o si quiero

197
00:22:46,220 --> 00:22:51,279
utilizar el altavoz puedo ponerle un tono concreto en hercios y durante cuánto tiempo quiero que esté

198
00:22:51,279 --> 00:22:57,240
sonando o puedo utilizar el monitor serie para sacar textos vale como si fuera a imprimir por

199
00:22:57,240 --> 00:23:04,779
pantalla entonces aparte de las que son específicas de algunos de algunos actuadores lo normal es

200
00:23:04,779 --> 00:23:11,019
utilizar este que es el que nos activa un pin donde yo tengo un actuador o no nos lo activa

201
00:23:11,019 --> 00:23:16,720
vale entonces siempre que yo tenga que realizar una acción sobre un actuador voy a utilizar estas

202
00:23:16,720 --> 00:23:21,460
estructuras ya tengo todos los bloques ya tengo todas las piezas ya solamente tengo que montar

203
00:23:21,460 --> 00:23:28,539
el castillo vale tengo todos los los ladrillos entonces vamos a intentar poner todo esto de

204
00:23:28,539 --> 00:23:34,000
una forma más más clara preguntas que tengáis hasta ahora con estas estructuras básicamente

205
00:23:34,000 --> 00:23:40,420
son las estructuras que habíamos visto en pseudocódigo y en diagramas de flujo pero

206
00:23:40,420 --> 00:23:46,400
viendo cómo son sus equivalentes dentro de tinker que tenemos las mismas estructuras pero con forma

207
00:23:46,400 --> 00:23:59,690
de bloques preguntas que tengáis a ver no entendiste lo de las piezas rosas qué piezas

208
00:23:59,690 --> 00:24:27,380
rosas a ver voy a buscar las piezas rosas cuáles son las piezas rosas te va estas las variables

209
00:24:27,380 --> 00:24:39,950
estas variables vale vamos por partes primero vamos con las variables vale os voy a compartir

210
00:24:39,950 --> 00:24:47,650
la parte de la presentación vale os voy a compartir mi navegador y voy a hacer algún

211
00:24:47,650 --> 00:24:54,369
ejemplo directamente en Tinkercad. Entonces compartimos el navegador.

212
00:24:56,329 --> 00:25:07,849
Ahora tendréis que estar viendo mi navegador. Si entramos en Tinkercad, vamos a circuitos,

213
00:25:07,849 --> 00:25:20,779
como siempre creamos un nuevo circuito. Muy bien y ahora lo que voy a hacer es ponerme mi plaquita.

214
00:25:20,779 --> 00:25:37,059
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

215
00:25:37,059 --> 00:25:43,740
porque siempre es un código estándar que aparece siempre y no me interesa. Vale, cuando yo me pongo a programar

216
00:25:43,740 --> 00:25:52,059
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.

217
00:25:52,059 --> 00:25:57,460
bien lo primero que tengo que hacer es definir las variables entonces al principio yo no tengo

218
00:25:57,460 --> 00:26:02,559
variables y cuando las creo voy a poner una variable que se va a llamar juanra se puede

219
00:26:02,559 --> 00:26:08,440
llamar como me dé la gana vale cuando yo defino una variable que no deja de ser un cajón donde

220
00:26:08,440 --> 00:26:13,819
yo pongo la etiqueta y donde yo puedo meter y sacar cosas vale esos valores ya me aparece

221
00:26:13,819 --> 00:26:20,660
tanto la variable como las órdenes de asignarle un valor a la variable concreta entonces si yo

222
00:26:20,660 --> 00:26:25,900
quiero por ejemplo imaginaros que lo que quiero es si tengo conectado vamos a suponer que tengo

223
00:26:25,900 --> 00:26:35,339
en el pin 8 conectado un dispositivo de entrada vale un sensor entonces quiero que cuando el

224
00:26:35,339 --> 00:26:45,500
sensor active ese pin 8 yo lea la información y lo almacene en juanra o si no lo activa lea esa

225
00:26:45,500 --> 00:26:50,299
información y lo almacena en juanra entonces yo lo que voy a hacer es definir la variable

226
00:26:50,299 --> 00:26:56,660
juanra voy a cogerme este bloque y este bloque que es definir la variable lo que voy a hacer

227
00:26:56,660 --> 00:27:04,740
es en los bloques de entrada decir quiero leer el pasador digital número 8 entonces lo que yo

228
00:27:04,740 --> 00:27:11,019
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

229
00:27:11,019 --> 00:27:17,440
activado a 5 voltios o no estás activado a 0 voltios si está activado a 5 voltios a juanra

230
00:27:17,440 --> 00:27:24,700
le va a poner high y si está desactivado a 0 voltios le va a poner low y ese valor lo va a

231
00:27:24,700 --> 00:27:30,740
almacenar y ya está no va a hacer más y lo va a dejar dentro de la variable y cuando luego yo

232
00:27:30,740 --> 00:27:36,880
quiera ver qué ha pasado con ese sensor que estaba ahí conectado iré a la variable y miraré qué valor

233
00:27:36,880 --> 00:27:50,640
tiene y en función del valor que tiene la variable decidiré vale tiene más sentido vale vale entonces

234
00:27:50,640 --> 00:28:00,380
esos son las variables vale y esos son vuelvo a la presentación perdón vuelvo a la presentación

235
00:28:00,380 --> 00:28:07,920
a ver un segundito que voy a ir a la a la transparencia que tengo que ir vale está

236
00:28:07,920 --> 00:28:15,059
entonces esas son las variables yo las creo y me crea directamente ya el definir y el cambiar y yo

237
00:28:15,059 --> 00:28:19,299
luego cuando las quiero definir cuando quiero utilizarlas lo que hago es asignarle pues una

238
00:28:19,299 --> 00:28:23,339
orden de entrada o leer un pasado digital como acabamos de hacer un pasado tecnológico el

239
00:28:23,339 --> 00:28:28,200
ultrasonico lo que sea y al final me queda un bloque de esta forma vale y ese es el bloque

240
00:28:28,200 --> 00:28:37,980
director vale a ver a ver a ver no pasa nada david vale los últimos dos de azul

241
00:28:37,980 --> 00:28:44,980
ya no lo has entendido áfrica cuáles cuáles cuáles dime cuáles

242
00:28:45,420 --> 00:28:54,849
los últimos dos de azul vale los actuadores

243
00:28:54,849 --> 00:29:03,680
estos áfrica es esto lo que lo que no entiendes el de reproducir a de

244
00:29:03,680 --> 00:29:11,839
reproducir perdón imprimir vale o sea esto de aquí vale esto simplemente vuelvo al navegador

245
00:29:11,839 --> 00:29:23,240
vale imaginaros que yo tengo en mi navegador a ver un segundito vale tengo cuadritos que tengo

246
00:29:23,240 --> 00:29:30,400
por aquí mucha movida vale voy a conectar por ejemplo una luz voy a conectar un este de sonido

247
00:29:30,400 --> 00:29:34,400
yo conecto este sonido, el positivo lo conecto a un pin

248
00:29:34,400 --> 00:29:38,119
a un pin, al 9

249
00:29:38,119 --> 00:29:42,019
pin digital y el negativo lo conecto a ground

250
00:29:42,019 --> 00:29:46,279
ya tengo mi dispositivo de salida, ahora yo quiero utilizar

251
00:29:46,279 --> 00:29:50,259
este altavoz, si os fijáis, para el altavoz

252
00:29:50,259 --> 00:29:56,690
a ver un segundito, lo estáis viendo

253
00:29:56,690 --> 00:29:58,910
ahora el navegador o no lo estáis viendo?

254
00:29:58,910 --> 00:30:03,690
¿Estáis viendo el navegador ahora o no?

255
00:30:04,650 --> 00:30:05,390
Sí, vale

256
00:30:05,390 --> 00:30:07,690
Entonces, si os fijáis

257
00:30:07,690 --> 00:30:08,869
Cuando

258
00:30:08,869 --> 00:30:10,670
Cuando

259
00:30:10,670 --> 00:30:13,910
Yo active el pin 9

260
00:30:13,910 --> 00:30:15,990
Lo que voy a hacer es activar el zumbador

261
00:30:15,990 --> 00:30:17,970
Activar el altavoz

262
00:30:17,970 --> 00:30:19,509
Y cuando lo ponga a cero

263
00:30:19,509 --> 00:30:21,170
Se va a desactivar, pero yo tengo

264
00:30:21,170 --> 00:30:23,430
Una orden específica

265
00:30:23,430 --> 00:30:24,250
Esto lo voy a quitar

266
00:30:24,250 --> 00:30:26,569
¿Vale? Que es

267
00:30:26,569 --> 00:30:30,029
Reproducir en el altavoz

268
00:30:30,029 --> 00:30:42,250
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,

269
00:30:42,490 --> 00:30:54,410
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,

270
00:30:54,410 --> 00:31:03,890
por mis cascos yo lo estoy oyendo vale si le pones 60 hoy es otro tono otra otro otro son

271
00:31:03,890 --> 00:31:10,250
otro sonido más grave ahora yo lo estoy oyendo también por mis cascos vale si lo hacéis en casa

272
00:31:10,250 --> 00:31:17,849
va a sonar y vais a oír el pitido dentro en el pc o en el en el ordenador vale entonces si yo

273
00:31:17,849 --> 00:31:24,349
quiero utilizar el altavoz tengo una orden es una orden específica para reproducir algo concreto en

274
00:31:24,349 --> 00:31:29,329
ese altavoz también el girar el servo si yo tengo un servo motor lo puedo girar un número de grados

275
00:31:29,329 --> 00:31:37,609
vale o puedo imprimir por el monitor serie si os fijáis aquí en el monitor serie vamos a voy

276
00:31:37,609 --> 00:31:43,670
a eliminar este bloque voy a eliminar este bloque vale y yo lo que voy a hacer es voy a hacer un

277
00:31:43,670 --> 00:31:51,349
bucle ya que estoy pues venga voy a contar vale y voy a contar hasta hacia arriba una variable que

278
00:31:51,349 --> 00:31:56,269
se va a llamar y vale y entonces yo dentro de las variables cojo y lo que voy a hacer es imprimir en

279
00:31:56,269 --> 00:32:03,329
el monitor sería la variable y luego le voy a decir que se espere que se espere medio segundo

280
00:32:03,329 --> 00:32:11,819
vale 0.5 segundos de acuerdo entonces si yo ejecuto esto fíjate lo que ocurre en el monitor

281
00:32:11,819 --> 00:32:16,480
serie que lo tengo aquí abajo vale esto es como una pantalla que no realmente esto tendría que

282
00:32:16,480 --> 00:32:20,319
conectarle algo a la placa no os lo quiero explicar pero realmente tendría que conectarle

283
00:32:20,319 --> 00:32:28,539
para verlo pero yo sí puedo decirle a través de software que me lo enseñe entonces el monitor

284
00:32:28,539 --> 00:32:35,819
serie yo puedo sacar información fijaros que yo aquí veis 1 2 3 4 5 6 7 8 9 10 vale cada medio

285
00:32:35,819 --> 00:32:41,019
segundo me está poniendo voy a hacerle que espere más voy a hacer lo que espere dos segundos entonces

286
00:32:41,019 --> 00:32:47,740
ahora empezará a vale perdón está esperar tiene que estar aquí dentro porque si no me saca todo

287
00:32:47,740 --> 00:33:02,259
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á

288
00:33:02,259 --> 00:33:06,460
haciendo un bucle hasta 10 y luego vuelve a empezar porque esto es un bucle infinito esto está

289
00:33:06,460 --> 00:33:12,220
haciéndolo vale es un mientras verdadero cosa esto no con lo cual el bucle va contando hacia arriba

290
00:33:12,220 --> 00:33:16,599
desde 1 hasta 10 en la variable y luego ya esa variable y la puedo utilizar para por ejemplo

291
00:33:16,599 --> 00:33:21,759
imprimir en el monitor serie esa sería una salida la salida de ponme en el monitor serie el valor

292
00:33:21,759 --> 00:33:26,740
de esa variable si yo estoy leyendo una distancia también le puedo decir que me diga cuánto vale en

293
00:33:26,740 --> 00:33:34,180
el monitor serie el valor de esa variable y puedo comprobar qué valor tiene un ldr o lo que sea vale

294
00:33:34,180 --> 00:33:49,170
entonces eso serían las que si estoy ahora en google pues no sé por qué lo dice sería no sé

295
00:33:49,170 --> 00:34:01,650
vale entonces áfrica estaba claro entonces vale está claro entonces cómo funcionan esos dos ahora

296
00:34:01,650 --> 00:34:07,609
estaréis viendo la presentación espero vale entonces este sabes ya cómo funciona esto

297
00:34:07,609 --> 00:34:26,070
simplemente son órdenes específicas de salida vale vale entonces perfecto aquí yo puedo ya

298
00:34:26,070 --> 00:34:30,889
os digo activar o desactivar pines con lo cual si tengo una luz directamente la enciende o si tengo

299
00:34:30,889 --> 00:34:36,070
un sumador directamente lo activa empieza a zumbar pero también tengo algunas cosas específicas bueno

300
00:34:36,070 --> 00:34:42,349
bien vamos con algunos ejemplos vale ahora estáis viendo vale estáis viendo la pantalla no vale

301
00:34:44,469 --> 00:34:50,210
quiero que veamos algunos ejemplos para entender cómo funciona el primer ejemplo es el sensor de

302
00:34:50,210 --> 00:34:55,190
aparcamiento que ya hemos visto vale en algún caso entonces nuestro algoritmo del sensor de

303
00:34:55,190 --> 00:35:01,670
apagamiento era leer la variable leer el sensor de distancia y meterlo dentro de la variable

304
00:35:01,670 --> 00:35:07,909
distancia vale yo cogí una variable que definía como distancia y le asignaba el valor que leíamos

305
00:35:07,909 --> 00:35:14,090
de la información del sensor de distancia y luego si la distancia es mayor que 10 lo que hago es

306
00:35:14,090 --> 00:35:19,610
que simplemente apagó el sonido y apagó el led tengo tanto un zumbador que está que emite un

307
00:35:19,610 --> 00:35:25,610
sonido como un led y entonces yo los apagó porque tengo más distancia de la que de la que es

308
00:35:25,610 --> 00:35:33,230
peligrosa espero 100 milisegundos y repito el bucle vale que ocurre que cuando yo voy haciendo marcha

309
00:35:33,230 --> 00:35:38,110
atrás y voy aparcando llega un momento lo que la distancia el sensor de distancia lee esa distancia

310
00:35:38,110 --> 00:35:42,769
menos de 10 centímetros y entonces se viene por el falso porque la distancia no es mayor y entonces

311
00:35:42,769 --> 00:35:49,530
es pita y enciende el led y hasta se queda ahí hasta cuando nos alejamos es muy sencillo el

312
00:35:49,530 --> 00:35:58,489
montaje sería algo parecido a esto vale vemos que tenemos ya tres bloques el sonido el led

313
00:36:00,409 --> 00:36:09,090
el sensor de distancia y estos tres bloques yo los voy a poner dentro de mi circuito un

314
00:36:09,090 --> 00:36:16,050
led que ya sabemos cómo se pone un zumbador como el que acabamos de ver también sé cómo se pone y

315
00:36:16,050 --> 00:36:22,690
un sensor de distancia que también sabemos cómo se pone y cómo se conecta y ya está entonces qué

316
00:36:22,690 --> 00:36:30,530
hacemos pues lo que hacemos es utilizar una orden de lectura del sensor ultrasonico y vamos a

317
00:36:30,530 --> 00:36:34,650
almacenarlo en la variable de distancia que previamente habremos creado dentro de las

318
00:36:34,650 --> 00:36:38,250
variables, habremos creado una variable de distancia y me habría salido ya el bloque

319
00:36:38,250 --> 00:36:42,489
definir distancia en y dentro del círculo le meto

320
00:36:42,489 --> 00:36:46,630
en la lectura, por lo tanto leemos el sensor ultrasonico que tengo

321
00:36:46,630 --> 00:36:50,469
con el trigger en el 7, si fijáis el trigger está en el 7

322
00:36:50,469 --> 00:36:54,590
el eco lo tengo al 4, el eco lo tengo al 4 en unidades

323
00:36:54,590 --> 00:36:58,510
centímetros, vale, entonces después tomamos la decisión, si la distancia es mayor de 10

324
00:36:58,510 --> 00:37:02,329
¿qué hacíamos? nada, pues ponemos el pin 13

325
00:37:02,329 --> 00:37:10,269
que es donde está mi led a baja y ponemos el pin 12 que es donde está mi zumbador a baja apagamos

326
00:37:10,269 --> 00:37:15,969
el sonido apagamos el led y está esperamos 100 milisegundos y volvemos que ocurre cuando la

327
00:37:15,969 --> 00:37:20,710
distancia se hace menos de 10 pues cuando la distancia se hace menos de 10 va a venir a la

328
00:37:20,710 --> 00:37:26,570
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

329
00:37:26,570 --> 00:37:32,190
va a empezar el led a encenderse y ya está y va a estar zumbando y con el led encendido de aviso

330
00:37:32,190 --> 00:37:38,130
hasta que la distancia vuelva a ser mayor que 10 y ya hemos terminado vale ya estaría hecho el

331
00:37:38,130 --> 00:37:44,329
sensor de aparcamiento entonces esto es un pequeño vídeo que se grabado de cómo funciona en ticket

332
00:37:44,329 --> 00:37:52,170
cad vale este es el circuito que utilizamos tenemos el sensor indican la distancia en esta

333
00:37:52,170 --> 00:37:58,869
parte y cuando el objeto lo muevo se mueve la distancia pero cuando me acerco por debajo de

334
00:37:58,869 --> 00:38:10,989
10 centímetros veis que se enciende y zumba vale si nos alejamos evidentemente se apaga veis que

335
00:38:10,989 --> 00:38:17,210
funciona vale bien bueno pues entonces vemos que el sensor de aparcamiento funciona y este

336
00:38:17,210 --> 00:38:22,550
es el simulador ahora podríamos este sensor de aparcamiento coger ese código y volcarlo a una

337
00:38:22,550 --> 00:38:28,309
placa de verdad que hayamos hecho este montaje con cables y con aparatos y podríamos ponerlo

338
00:38:28,309 --> 00:38:32,989
para que nos avise cuando estamos más cerca de un objeto de esos 10 centímetros

339
00:38:34,929 --> 00:38:42,369
bueno como hacemos el reto que os había planteado el coche que evitaba los obstáculos versión 1.0

340
00:38:42,369 --> 00:38:46,849
bueno es la versión 1.0 porque realmente no lo evita lo que hace es que cuando llega a menor

341
00:38:46,849 --> 00:38:51,590
distancia de un valor se para bueno pues es lo mismo realmente que el sensor de aparcamientos

342
00:38:51,590 --> 00:39:07,610
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.

343
00:39:07,610 --> 00:39:19,849
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.

344
00:39:20,269 --> 00:39:26,769
Esperamos 6 milisegundos y vuelta y vuelta y vuelta. Este es el algoritmo del robot evita obstáculos que habíamos planteado el reto.

345
00:39:26,769 --> 00:39:34,409
esto sería el código, el código en pseudocódigo sería el mientras verdadero es el bucle infinito de cualquier robot

346
00:39:34,409 --> 00:39:39,849
y luego leemos el sensor de ultrasonico, leemos la distancia, si la distancia es menor que 20 para el motor y activa el led

347
00:39:39,849 --> 00:39:43,230
y si no, activa el motor, apaga el led y ya está, y esperamos

348
00:39:43,230 --> 00:39:48,530
con lo cual ese pseudocódigo si lo ejecutamos va a estar pidiéndonos la distancia continuamente

349
00:39:48,530 --> 00:39:53,949
nosotros se la metemos y cuando la distancia sea menor de 20 nos va a poner para el motor y activa el led

350
00:39:53,949 --> 00:39:55,409
y va a volver a leer la distancia

351
00:39:55,409 --> 00:40:02,949
bien, vemos que tenemos un bloque, sensor de ultrasonidos, otro bloque, motor y otro bloque LED

352
00:40:02,949 --> 00:40:04,750
y además una variable que es distancia

353
00:40:04,750 --> 00:40:09,750
esto es lo que nosotros tenemos que identificar antes de pasar a construir el objeto real, el proyecto real

354
00:40:09,750 --> 00:40:17,349
tres bloques de Tinkercad, el sensor, el motor y el LED y una variable, distancia

355
00:40:17,349 --> 00:40:23,070
pues nos vamos a nuestro Tinkercad, los tres bloques que ya hemos estudiado

356
00:40:23,070 --> 00:40:30,750
cómo se conecta cada uno, los conectamos y ponemos nuestro sensor de ultrasonidos, nuestro motor y nuestro LED.

357
00:40:31,309 --> 00:40:44,110
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.

358
00:40:44,110 --> 00:40:50,869
Nos lo apuntamos, el motor al 12, el LED al 11, el trigger al 3, el eco al 4.

359
00:40:51,809 --> 00:40:53,969
Y con esa información nos vamos a programar.

360
00:40:54,289 --> 00:40:58,849
Como ya sabemos cómo se lee el sensor de ultrasonidos, que es lo primero que tenemos que hacer,

361
00:40:58,889 --> 00:41:03,909
y cómo se asigna ese valor a una variable, luego la condición, sabemos también cómo se hace

362
00:41:03,909 --> 00:41:09,570
porque conocemos los bloques de condición, los de bifurcación, y las órdenes de encender el motor

363
00:41:09,570 --> 00:41:13,489
y de encender el LED también las conocemos y las de pararlo, con lo cual lo que hacemos simplemente

364
00:41:13,489 --> 00:41:21,230
es transcribir literalmente lo que tenemos en nuestro diagrama de flujo en un programa, en este caso a través de bloques.

365
00:41:21,690 --> 00:41:28,650
Primero usamos el bloque de leer el sensor ultrasonico que tengo en el desencadenador, el trigger en el 3, el eco en el 4,

366
00:41:28,809 --> 00:41:32,650
en unidades centímetros y eso lo meto en la variable distancia que la he creado previamente.

367
00:41:33,670 --> 00:41:39,769
Y luego, si la distancia es menor de 20, que es la condición que he puesto aquí, si es verdadero, ¿qué hago?

368
00:41:39,769 --> 00:41:42,010
paro el motor y paro el led

369
00:41:42,010 --> 00:41:44,210
el motor lo tengo en el 12

370
00:41:44,210 --> 00:41:45,989
y el led lo tengo en el 11, por lo tanto

371
00:41:45,989 --> 00:41:48,610
perdón, paro el motor

372
00:41:48,610 --> 00:41:49,469
y activo el led

373
00:41:49,469 --> 00:41:52,449
paro el motor y activo el led, que es lo que tengo que hacer

374
00:41:52,449 --> 00:41:54,110
si la distancia es menor que 20

375
00:41:54,110 --> 00:41:56,510
entonces desactivo el motor

376
00:41:56,510 --> 00:41:57,909
y activo el led

377
00:41:57,909 --> 00:41:59,150
y si

378
00:41:59,150 --> 00:42:02,690
la distancia es mayor de 20, entonces desactivo

379
00:42:02,690 --> 00:42:03,949
el led

380
00:42:03,949 --> 00:42:06,210
y activo el motor, es decir

381
00:42:06,210 --> 00:42:08,530
cuando no hay nada, el coche avanza

382
00:42:08,530 --> 00:42:09,730
y el led está apagado

383
00:42:09,730 --> 00:42:14,449
pero cuando encuentra un objeto a menos de 20 centímetros, el coche se para y enciende el LED.

384
00:42:15,030 --> 00:42:17,929
Espera 100 milisegundos y ya está. Ya estaría hecho el programa.

385
00:42:19,710 --> 00:42:25,690
Entonces, al final, resumiendo, tenemos nuestro algoritmo, que es lo primero que tenemos que hacer.

386
00:42:26,170 --> 00:42:32,409
Tenemos que transformar ese algoritmo en un proyecto identificando los bloques que necesito.

387
00:42:33,489 --> 00:42:36,949
Tenemos que ver qué pines son los que he utilizado para cada uno de los objetos

388
00:42:36,949 --> 00:42:43,869
y luego transcribir el diagrama de flujo directamente a bloques utilizando la analogía que acabamos de ver a principio de clase.

389
00:42:44,929 --> 00:42:47,050
¿Lo tenéis claro? ¿Alguna pregunta?

390
00:42:49,090 --> 00:42:54,949
Esa es un poco la estructura de cómo se haría.

391
00:42:56,010 --> 00:42:57,969
Abro el chat a ver si tenéis alguna pregunta.

392
00:43:01,980 --> 00:43:03,679
O sea que tenemos que hacerlo igual que el tuyo.

393
00:43:03,679 --> 00:43:07,739
Bueno, no tenéis que hacerlo igual, podéis utilizar otros pines, podéis hacer otras cosas,

394
00:43:07,739 --> 00:43:14,880
pero realmente esto, lo que yo quiero es que lo entendáis, no que cojáis y copiéis exactamente lo que yo hago.

395
00:43:15,039 --> 00:43:20,119
Quiero que hagáis una cosa mucho más complicada, que es pensar.

396
00:43:22,320 --> 00:43:24,320
Pensar, eso es lo que quiero que hagáis.

397
00:43:24,860 --> 00:43:28,739
Quiero que cojáis las piezas individuales y las mezcléis para hacer algo diferente.

398
00:43:29,739 --> 00:43:35,019
Entonces, que si era para hoy, claro que era para hoy.

399
00:43:35,019 --> 00:43:37,239
el proyecto era para hoy, de hecho hoy

400
00:43:37,239 --> 00:43:39,260
una cosa, antes de que os vayáis de clase

401
00:43:39,260 --> 00:43:40,920
os voy a

402
00:43:40,920 --> 00:43:42,960
tengo una buena noticia y es que

403
00:43:42,960 --> 00:43:45,139
esta es la última clase que voy a dar y tengo

404
00:43:45,139 --> 00:43:47,000
otra buena noticia y es que ya tengo las notas

405
00:43:47,000 --> 00:43:48,659
entonces ahora os voy a decir

406
00:43:48,659 --> 00:43:51,179
las notas

407
00:43:51,179 --> 00:43:52,940
y os voy a decir que va a pasar a partir de ahora

408
00:43:52,940 --> 00:43:54,780
en cuanto acabe, os lo cuento

409
00:43:54,780 --> 00:43:56,460
me falta lo del puente H y ya

410
00:43:56,460 --> 00:43:59,019
os paso a decir lo de las notas

411
00:43:59,019 --> 00:44:01,079
entonces, lo que quiero es que

412
00:44:01,079 --> 00:44:03,099
penséis, lo que quiero es que tengáis esas piezas

413
00:44:03,099 --> 00:44:05,179
básicas, como funciona un motor

414
00:44:05,179 --> 00:44:07,219
como funciona un LED, como funciona un sensor

415
00:44:07,219 --> 00:44:08,440
como funciona un botón

416
00:44:08,440 --> 00:44:10,519
y luego las pueda mezclar

417
00:44:10,519 --> 00:44:13,199
utilizando estas estructuras que son estructuras muy básicas

418
00:44:13,199 --> 00:44:14,019
¿vale?

419
00:44:14,539 --> 00:44:17,219
entonces, eso es lo que

420
00:44:17,219 --> 00:44:19,619
quería, que vosotros resolvierais

421
00:44:19,619 --> 00:44:20,460
algo

422
00:44:20,460 --> 00:44:22,440
que yo no os haya dado

423
00:44:22,440 --> 00:44:24,980
de forma original, de forma

424
00:44:24,980 --> 00:44:26,659
creativa, de forma

425
00:44:26,659 --> 00:44:28,619
¿vale?

426
00:44:29,500 --> 00:44:31,119
ayer al hacer el robot, el bloque

427
00:44:31,119 --> 00:44:32,980
de leer el sensor de ultrasonidos ponía

428
00:44:32,980 --> 00:44:37,599
que se podía poner el trigger y el eco en el mismo pasador se puede hacer eso sí sí porque

429
00:44:37,599 --> 00:44:45,920
hay un tipo de sensores que tienen solo tres patillas vale entonces si utilizamos el sensor

430
00:44:45,920 --> 00:44:51,880
que tiene tres patillas trigger y eco van por la misma vale pero en el sensor de cuatro patillas

431
00:44:51,880 --> 00:44:55,780
que es el que yo utilizo siempre porque es el que encontramos en cualquier tienda y es el que

432
00:44:55,780 --> 00:45:00,820
tenemos en el labor del taller de robótica y es el que hubiéramos utilizado si hubiéramos

433
00:45:00,820 --> 00:45:08,619
construido esto de verdad es el de cuatro patillas vale entonces estos sensores simplemente pueden

434
00:45:08,619 --> 00:45:14,980
ser con las dos patillas comunes o con las dos patillas separadas entonces si puede ser puede

435
00:45:14,980 --> 00:45:22,980
ser que vaya por la misma pero es otro sensor el que utiliza eso vale albert recibo tus mensajes

436
00:45:22,980 --> 00:45:35,380
si los recibo ya te he visto bueno continuamos entonces este es el proceso del proceso creativo

437
00:45:35,380 --> 00:45:41,599
parte de una idea parte de hacer un algoritmo con un diagrama de flujo una serie de órdenes

438
00:45:41,599 --> 00:45:48,179
identificar qué cosas necesito me voy a la tienda las compro vale o voy al taller y las cojo si

439
00:45:48,179 --> 00:45:56,880
tengo un montón y las junto las conecto y después cojo ese algoritmo y lo transformó en un programa

440
00:45:56,880 --> 00:46:02,639
que ejecute esas órdenes para hacer lo que yo quiero que haga de acuerdo tan sencillo como eso

441
00:46:02,639 --> 00:46:10,619
o tan complicado si se hace muchas veces ya os digo que normalmente se es bastante fácil hay

442
00:46:10,619 --> 00:46:18,139
que saber cómo funciona cada pieza y ya está bueno entonces vamos al último apartado que es el puente

443
00:46:18,139 --> 00:46:25,159
qué es el puente h bueno pues sabemos nosotros estamos utilizando motores verdad los motores

444
00:46:25,159 --> 00:46:30,739
tienen esta pinta los motores de verdad que utilizamos en robótica en los modelos de

445
00:46:30,739 --> 00:46:35,539
robótica de estos que hacemos en el taller pues utilizamos este tipo de motores que son para y

446
00:46:35,539 --> 00:46:38,579
son iguales que los que hemos utilizado por ejemplo al principio curso para el de la puerta

447
00:46:38,579 --> 00:46:43,139
corredera lo único que es un motor que tiene otro formato un formato especial para poderle

448
00:46:43,139 --> 00:46:50,159
enganchar una rueda vale pero es lo mismo al final es un motor y entonces este motor como

449
00:46:50,159 --> 00:46:55,260
lo conectamos pues lo conectamos a una pila a una batería y cuando cierro el interruptor el

450
00:46:55,260 --> 00:46:59,500
motor gira qué pasa que si yo quiero que el motor gire en la dirección contraria os acordáis de la

451
00:46:59,500 --> 00:47:05,019
puerta corredera vale yo lo que tengo que hacer es conectar la pila al revés donde el positivo con

452
00:47:05,019 --> 00:47:08,159
esto el negativo donde el negativo con esto el positivo y entonces el motor lo que hace es girar

453
00:47:08,159 --> 00:47:18,219
al revés pero claro si yo tengo un circuito hecho con mi tinker card tengo un robot construido yo

454
00:47:18,219 --> 00:47:23,559
puedo activar y desactivar este motor pero como hago para que vaya hacia atrás si tendría que

455
00:47:23,559 --> 00:47:30,139
cambiar los cables tendría que conectarle cables en otra posición y no voy a hacer que cada vez que

456
00:47:30,139 --> 00:47:34,800
el robot tenga que cambiar me hace me da que acercar a él a cambiarle un cable entonces

457
00:47:34,800 --> 00:47:42,119
para resolver vale esto que si no podemos cambiar los cables de posición como resolvemos el hecho

458
00:47:42,119 --> 00:47:47,699
de que el motor vaya hacia delante o hacia atrás hacia los dos lados es para lo que se ha inventado

459
00:47:47,699 --> 00:47:54,000
el puente h el puente h no tiene no es nada más que esto que veis aquí vale tenemos la fuente de

460
00:47:54,000 --> 00:48:01,039
tensión y antes de conectar el motor lo que tengo es en lugar de un interno de un de un interruptor

461
00:48:01,039 --> 00:48:13,940
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,

462
00:48:14,579 --> 00:48:21,699
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,

463
00:48:22,000 --> 00:48:29,019
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

464
00:48:29,019 --> 00:48:31,679
y la corriente eléctrica iría de izquierda a derecha.

465
00:48:32,639 --> 00:48:36,019
Pero ¿qué pasa si yo quiero que el motor gire al revés?

466
00:48:36,380 --> 00:48:40,619
Pues abro S1 y S4 y cierro S3 y S2.

467
00:48:41,059 --> 00:48:45,199
Entonces la corriente eléctrica que sigue saliendo de la misma pila por el mismo lado

468
00:48:45,199 --> 00:48:49,960
viene, ahora ya no entra por S1 que está abierto, ahora se viene y entra por S3 que está cerrado.

469
00:48:50,500 --> 00:48:55,659
S4 está abierto, no puede avanzar, con lo cual atraviesa el motor que viene ahora de derecha a izquierda,

470
00:48:56,179 --> 00:48:57,079
al revés que antes.

471
00:48:57,079 --> 00:49:03,699
y si os fijáis ese 2 que estaba cerrado viene y termina el circuito con lo cual la corriente pasa

472
00:49:03,699 --> 00:49:09,679
por el motor de derecha a izquierda si cierro ese 1 y ese 4 la corriente atraviesa el motor de

473
00:49:09,679 --> 00:49:18,119
izquierda a derecha si el paso la corriente por ese 3 y ese 2 el motor la corriente necesita

474
00:49:18,119 --> 00:49:24,920
atraviesa el motor de derecha izquierda y ese día giro contrario de acuerdo es un puente h no tiene

475
00:49:24,920 --> 00:49:29,059
nada más normalmente claro los interruptores no son interruptores de estos que tenemos en

476
00:49:29,059 --> 00:49:34,920
la pared o interruptores de los que tenemos en el taller son transistores y yo los manejo a

477
00:49:34,920 --> 00:49:41,280
través de las señales que utilizo en mi placa de arduino yo a través de las señales de arduino

478
00:49:41,280 --> 00:49:47,300
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

479
00:49:47,300 --> 00:49:53,320
estos circuitos tienen esta pinta normalmente lo vamos a comprar este es un puente h para dos

480
00:49:53,320 --> 00:50:01,159
motores cada motor lo conectaría en las bornas verdes aquí es donde yo conectaría mi motor y

481
00:50:01,159 --> 00:50:06,300
aquí mi otro motor dos motores vale por ejemplo rueda derecha rueda izquierda si tengo un coche

482
00:50:06,300 --> 00:50:11,739
con dos ruedas entonces esas dos ruedas ahora yo les puedo decir que vayan hacia adelante que vayan

483
00:50:11,739 --> 00:50:17,699
hacia atrás que separen o que hagan cosas como se lo digo bueno pues aquí en estos conectores yo voy

484
00:50:17,699 --> 00:50:25,420
a poner en los dos del centro ground y vcc que es tensión le voy a poner cinco voltios y cero

485
00:50:25,420 --> 00:50:31,800
conectado cinco voltios siempre y cero siempre y luego en los dos de este lado estos dos pines

486
00:50:31,800 --> 00:50:36,699
los voy a conectar a dos pines de la placa de arduino que yo voy a activar o desactivar en

487
00:50:36,699 --> 00:50:41,340
función de lo que quiero que haga el motor que está en este lado y los otros dos pines que son

488
00:50:41,340 --> 00:50:47,139
aquellos que están en el otro extremo los voy a conectar a otros dos pines de mi placa arduino

489
00:50:47,139 --> 00:50:52,960
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.

490
00:50:53,780 --> 00:51:05,539
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

491
00:51:05,539 --> 00:51:15,699
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.

492
00:51:15,699 --> 00:51:22,000
entonces eso lo voy a hacer a través de esto de estos dos pines que yo le puedo poner pues en

493
00:51:22,000 --> 00:51:28,139
desactivado desactivado o desactivado activado o también activado desactivado o los dos activados

494
00:51:28,139 --> 00:51:34,579
con lo cual tengo cuatro posibles órdenes que yo le admito que yo le puedo pasar a la placa y esto

495
00:51:34,579 --> 00:51:43,099
de aquí este chip de aquí es el que tiene los transistores para hacer que la corriente eléctrica

496
00:51:43,099 --> 00:51:50,599
a estos dos pines de que son los que van al motor lleguen positivo y negativo o cambiadas negativo

497
00:51:50,599 --> 00:51:56,239
y positivo de acuerdo los interruptores vamos a llamarlos que son realmente transistores están

498
00:51:56,239 --> 00:52:03,260
aquí dentro entonces las órdenes que llegan por aquí entran a este chip este chip hace el cambio

499
00:52:03,260 --> 00:52:09,500
de los interruptores que corresponden en el puente h y activa o desactiva las tensiones en los dos

500
00:52:09,500 --> 00:52:15,559
bornes que van a mi motor por lo tanto al motor le va a llegar lo que yo le estoy indicando tiene

501
00:52:15,559 --> 00:52:25,309
sentido lo que acabo de decir más o menos entendéis cómo funciona un puente h me lo podéis decir por

502
00:52:25,309 --> 00:52:30,949
el chat si entendéis cómo funciona un puente h si vale entonces el puente h básicamente es lo que me

503
00:52:30,949 --> 00:52:37,630
sirve para que en un proyecto de robótica con un motor yo pueda decirle que vaya hacia delante o

504
00:52:37,630 --> 00:52:43,090
que vaya hacia atrás y lo voy a hacer conectando una plaquita intermedia que es esta vale que

505
00:52:43,090 --> 00:52:49,090
normalmente se llaman drivers de motor vale son drivers motor drivers en inglés vale drivers para

506
00:52:49,090 --> 00:52:56,230
motores son drivers que permiten que permiten indicar que el motor vaya hacia delante hacia

507
00:52:56,230 --> 00:53:03,590
atrás sin tener que cambiarle la polaridad de los cables bien esto es un poco lo que lo que

508
00:53:03,590 --> 00:53:10,010
teníamos que haber hecho para hoy los puentes h los retos y todo esto vale entonces

509
00:53:10,010 --> 00:53:25,829
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?

510
00:53:25,829 --> 00:53:44,019
Ahora deberíais estar viendo mi navegador, ¿vale? Entonces, los puentes H, nosotros tenemos un circuito integrado dentro de los dispositivos.

511
00:53:44,019 --> 00:53:53,659
dentro de los dispositivos nosotros tenemos circuitos integrados que son puentes h vale

512
00:53:53,659 --> 00:54:00,860
entonces yo tengo por aquí un ejemplito que lo he copiado de por ahí no lo he hecho yo vale de cómo

513
00:54:00,860 --> 00:54:08,940
funcionan los puentes h normalmente ese driver de ese driver de motores ese driver de puente h

514
00:54:08,940 --> 00:54:42,400
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,

515
00:54:42,400 --> 00:54:58,239
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.

516
00:54:58,239 --> 00:55:04,519
y luego tengo las entradas de señal y las entradas de potencia.

517
00:55:05,360 --> 00:55:12,460
Entonces las señales serían señales que vienen a estos pines, al 5 y al 6, al 10 y al 9,

518
00:55:13,079 --> 00:55:16,179
son los dos pines de señal que yo voy a utilizar para cada uno de los motores

519
00:55:16,179 --> 00:55:21,659
y luego tengo potencia, potencia para un motor y potencia para otro motor

520
00:55:21,659 --> 00:55:24,340
que lo estoy sacando de una pila de 9 voltios para que vaya más rápido.

521
00:55:24,340 --> 00:55:29,280
entonces en el código, en este caso, bueno el código está en formato de código

522
00:55:29,280 --> 00:55:33,739
no está en formato de bloques, pero yo lo que voy a hacer es mandarle determinadas órdenes

523
00:55:33,739 --> 00:55:38,599
para que el motor, en este caso, pues si os fijáis gira uno

524
00:55:38,599 --> 00:55:47,280
que está aquí girando y si yo le voy poniendo, le voy pulsando en determinadas configuraciones

525
00:55:47,960 --> 00:55:50,619
pues estos motores van hacia delante, van hacia detrás, es decir

526
00:55:50,619 --> 00:56:02,840
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.

527
00:56:03,840 --> 00:56:14,280
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.

528
00:56:14,280 --> 00:56:27,480
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.

529
00:56:28,000 --> 00:56:29,139
Y así es como los controlo.

530
00:56:29,519 --> 00:56:33,500
Entonces, ¿qué pasa? Que ahora ya podemos hacer un robot que vaya hacia delante.

531
00:56:34,000 --> 00:56:35,699
¿Os acordáis del reto de Semana Santa?

532
00:56:36,039 --> 00:56:39,099
Un robot que vaya hacia delante y vaya midiendo distancias.

533
00:56:39,099 --> 00:56:45,679
en el momento en el que detecte que la distancia es menor que una cantidad concreta

534
00:56:45,679 --> 00:56:47,940
15 centímetros o 20 centímetros por ejemplo

535
00:56:47,940 --> 00:56:50,300
¿Qué vamos a hacer? Parar motores

536
00:56:50,300 --> 00:56:54,460
vamos a hacer que uno de los dos motores vaya hacia atrás

537
00:56:54,460 --> 00:56:56,340
durante un tiempo concreto

538
00:56:56,340 --> 00:56:59,699
moviéndose a una velocidad

539
00:56:59,699 --> 00:57:04,800
y una vez que hayamos esperado ese tiempo y tengamos el robot reubicado

540
00:57:04,800 --> 00:57:07,019
otra vez pondremos los motores a andar hacia adelante

541
00:57:07,019 --> 00:57:15,139
Este reto que ya lo hicimos en Semana Santa, ¿vale? Es el reto final que yo tengo para vosotros en este curso.

542
00:57:15,380 --> 00:57:26,699
Entonces, ¿qué es lo que quiero? Quiero que investiguéis, ¿vale? Cómo funciona este chip, os lo apuntáis, por favor, chip L293D.

543
00:57:26,699 --> 00:57:35,699
y lo tenéis si os vais aquí a componentes todos vale pues en uno de los chips que estaban por

544
00:57:35,699 --> 00:57:45,440
aquí al final lo tenéis aquí están los chips si encuentro este el controlador de motor de puente

545
00:57:45,440 --> 00:57:53,099
h l 293 de vale el último de acuerdo también tenemos un controlador de motor simple o sea

546
00:57:53,099 --> 00:57:58,940
si os fijáis también tenemos el controlador con la forma con la forma que os he enseñado de placa

547
00:57:58,940 --> 00:58:05,059
con los pines aquí una serie de pines una serie de estos son drivers más complejos este es más

548
00:58:05,059 --> 00:58:14,800
sencillito y por eso quiero que utilicéis este el l 293 de vale entonces si queréis vale ahora

549
00:58:14,800 --> 00:58:22,340
os voy a dar las notas si queréis podéis hacer el reto para subir nota de acuerdo los que os

550
00:58:22,340 --> 00:58:27,920
conformes con la nota que tenéis pues punto final se acabó el curso y los que hayáis suspendido

551
00:58:28,940 --> 00:58:35,059
tendremos un examen de recuperación vale que ya os diré las instrucciones a vosotros concretamente

552
00:58:35,059 --> 00:58:42,619
para que os conectéis o sea que hay que buscar cómo funciona el l exactamente en internet si

553
00:58:42,619 --> 00:58:49,400
tú vas y buscas tinker cad el tinker cad puente h ejemplos vale vas a tener un montón de ejemplos

554
00:58:49,400 --> 00:58:56,639
pero también podéis mirar cómo funciona este chip el l 293 de intentar hacer las conexiones de

555
00:58:56,639 --> 00:59:02,840
acuerdo es un reto complicado ya lo sé si habéis conseguido seguirme hasta este punto si habéis

556
00:59:02,840 --> 00:59:07,179
conseguido saber cómo se conectan las cosas cómo se hacen los algoritmos cómo se hacen los programas

557
00:59:07,179 --> 00:59:13,619
para que vale activar o desactivar los pines esto nos va a resultar demasiado complicado vale pero

558
00:59:13,619 --> 00:59:20,039
un reto interesante y era el reto final de este curso que yo tenía para luego construir un coche

559
00:59:20,039 --> 00:59:25,019
como el que veíamos en el vídeo inicial no sé si os acordáis cuando empezamos con este tema que

560
00:59:25,019 --> 00:59:31,079
es un coche que avanza cuando llega a un objeto se para se gira y sigue avanzando en otra dirección

561
00:59:31,079 --> 00:59:38,000
vale entonces se hace con estas piezas y se hace con esta con estas con esta con estos bloques que

562
00:59:38,000 --> 00:59:42,480
hemos estado viendo de acuerdo y lo único que nos faltaba era la pieza del puente h que es lo que

563
00:59:42,480 --> 00:59:49,840
yo necesito para hacer que el motor vaya hacia adelante y hacia atrás de acuerdo visto alguna

564
00:59:49,840 --> 01:00:03,309
duda hay que hacer algo en tinker card claro hay que y hacer un coche que tenga los dos motores

565
01:00:03,309 --> 01:00:07,650
que vayan hacia adelante y un sensor de distancia y cuando la distancia yo se la ponga por debajo

566
01:00:07,650 --> 01:00:14,710
de 20 los motores tienen que pararse uno de ellos tiene que ir hacia atrás durante un segundo

567
01:00:14,710 --> 01:00:18,969
pongamos o medio segundo el tiempo que decidamos el tiempo que queráis porque luego eso hasta que

568
01:00:18,969 --> 01:00:24,909
no lo pruebas luego no lo podríamos ajustar pues durante medio segundo por ejemplo un segundo se

569
01:00:24,909 --> 01:00:29,949
para y vuelven a avanzar otra vez hacia delante los las dos ruedas con lo cual así el coche lo

570
01:00:29,949 --> 01:00:37,369
que estaría haciendo es evitar obstáculos vale eso sería el reto entonces el reto es para subir nota

571
01:00:37,369 --> 01:00:44,250
los que ya habéis aprobado vale y para los que no habéis aprobado pues os tendréis que poner en

572
01:00:44,250 --> 01:00:47,849
en vez de hacer el reto ponemos a estudiar la primera y la segunda evaluaciones vale

573
01:00:47,849 --> 01:00:54,269
para las recuperaciones ahora os digo las notas y os digo cómo queda la foto final

574
01:00:54,269 --> 01:01:02,820
de acuerdo alguna duda alguna pregunta bueno voy a parar ya la grabación