Bloques básicos en TinkerCAD para programación de robots

Vamos a empezar la clase y lo primero que quiero ver en esta clase de repaso son los conceptos básicos. 00:00:03

Los conceptos básicos que tienen que ver con la programación de robots y luego las piezas con las que nosotros vamos a jugar. 00:00:14

Ya os dije que esto es como un puzzle. Yo os voy a dar piezas y luego las piezas yo las voy a mezclar y las voy a combinar como me interese. 00:00:21

pero las piezas hay que conocerlas y hay que manejarlas. 00:00:29

Entonces voy a ir repasando hoy todas las piezas para que tengamos claro qué es lo que tenemos 00:00:33

y vamos a hacer algunos ejemplos de cómo podemos hacer que interactúen. 00:00:37

Pero antes de eso, quiero empezar con una presentación. 00:00:41

Ahí estamos. 00:00:47

¿Estáis viendo ahora mismo la presentación? 00:00:54

Espero que la estéis viendo todos. 00:00:59

Bien, pues, a ver, vale. Entonces, esta presentación simplemente va a repasar dos conceptos, ¿vale? 00:01:01

A ver un segundito, vale. ¿Estáis viendo la presentación? ¿Me lo podéis confirmar, por favor? Vale, ok. 00:01:14

Entonces, programación de robots, conceptos básicos, ¿vale? 00:01:25

Lo primero que quiero es repasar unos conceptos muy básicos que es cómo funciona un robot, ¿vale? 00:01:29

¿Qué es un robot? ¿Qué es un robot? 00:01:36

Por un lado, un robot es un dispositivo que tiene sensores, que procesa información que recoge de esos sensores 00:01:39

y en función de ese proceso de la información toma decisiones. 00:01:50

Y esas decisiones me pueden llevar a activar ciertos actuadores, que son las salidas, ¿de acuerdo? 00:01:54

Por lo tanto, yo tengo entradas a mi sistema, a mi robot, esas entradas entran por los sensores, 00:02:02

el robot va a procesar la información que recoge y luego va a poner en los actuadores, 00:02:09

va a activar o no activar en función de la decisión que tome esos actuadores. 00:02:15

Por seguir viendo un poquito un ejemplo, cosas reales que tenemos en los sensores, sensor de distancia, el HPSSR04, que es el que nosotros estamos utilizando, el de 4 pines, pulsadores, que son pulsadores de estos que si os fijáis tienen dos patillas por un lado y dos patillas por el otro, dos patillas por cada cara, opuestas, eso tenemos que tener cuidado porque para colocarlo tenemos que tener cuidado de colocarlo en la posición correcta. 00:02:20

Y luego LDRs que son resistencias dependientes de la luz, es decir, una resistencia que va a variar su cantidad de resistencia en función de la luz que incida. 00:02:48

Luego, cuando nosotros tenemos estos sensores, lo que hemos dicho es que estos sensores van a pasarle información a un cerebro que es el que la procesa. 00:02:59

Aquí tenemos las placas de las microcontroladoras, que son, por ejemplo, el Arduino Uno, que es con la que nosotros vamos a trabajar en el simulador, 00:03:13

o Cranbell, que es con la que hubiéramos trabajado en clase si hubiéramos tenido clase presencial. 00:03:20

Y por último, actuadores. 00:03:26

Los actuadores son dispositivos que accionan, que activan el microcontrolador y que devuelven información al entorno. 00:03:28

Puede ser a través de luces, a través de movimiento que generan los motores que yo puedo activar o desactivar u otras cosas. 00:03:38

Entonces, lo que tengo que tener claro es que tengo sensores que me van a meter información al procesador, el propio procesador que procesa la información, que es donde yo voy a ejecutar un programa que es el que yo tengo que hacer, el programa, ¿vale? Para que eso funcione. 00:03:46

Y eso es lo que da la inteligencia y luego los actuadores que son las salidas. 00:04:03

Evidentemente, para poder conectar todos estos cacharritos, yo lo que tengo que utilizar son cables. 00:04:07

Entonces, tengo sensores que conecto a través de cables a las placas. 00:04:16

Las placas recogen la información, lo guardan en unas variables, esas variables yo las utilizo para poder hacer decisiones, para poder tomar decisiones. 00:04:20

Y luego a través de los cables, donde tengo conectadas los actuadores, activo o no, ¿vale? Esos actuadores para devolver nuestra interacción con el entorno. 00:04:29

Entonces, ¿esos cables dónde están conectados? Pues por un lado a los pines de los sensores, ¿vale? A estos pines que están por aquí, a estos cablecitos, a estas conexiones. 00:04:41

y por otro a los pines de mi placa de control, esos pines que son esas conexiones que yo tengo para conectar los cables ahí, 00:04:51

los pincho y entonces ya lo conecto y están numeradas los digitales que son los de este lado del 1 al 13, del 0 al 13 00:05:04

y los analógicos que son estos primeros de aquí, el primer bloque de conexiones de este lado son las conexiones analógicas 00:05:12

y se dan de la A0 a la A5. 00:05:17

Vale, esto es cómo funciona un robot. 00:05:20

Un robot simplemente coge información del entorno a través de los sensores, 00:05:23

procesa esa información en función de un programa que nosotros hemos generado 00:05:28

para tomar decisiones. 00:05:31

Y cuando tome las decisiones hará lo que tenga que hacer con los actuadores 00:05:32

de forma que devolverá al entorno una respuesta. 00:05:37

Y eso es un robot, no tiene más. 00:05:41

¿Vale? 00:05:43

Bien, si lo ponemos todo junto, lo que tenemos es un robot que responde a ciertas cosas 00:05:43

Por ejemplo, esto sería un coche que se mueve con una placa crumble que está aquí encima 00:05:51

Que está conectada a través de pinzas de cocodrilo de estas, que son como pinzas que muerden las conexiones 00:05:56

Que son estas que están aquí en los bordes 00:06:02

Y aquí, bueno, la entrada y la salida sucede a través de esas conexiones en lugar de la de Arduino 00:06:03

Y tenemos pues un sensor de distancia aquí puesto hacia delante 00:06:08

y unos motores que están conectados a las ruedas y que en función de lo que el sensor de distancia va midiendo 00:06:11

actúa sobre las ruedas para que avance, retroceda y haga acción. 00:06:16

Tan sencillo como eso. Eso es un robot. Y ya está. 00:06:20

Bien, pues vamos ahora a ver cómo funciona un programa de un robot. 00:06:24

Y este es el segundo concepto importante. 00:06:31

Lo primero, tener claro que es un robot. Esto ya lo teníamos claro porque lo hemos resumido de nuestro tema. 00:06:33

Sensores, placa de control, actuadores. 00:06:37

Segundo, ¿cómo funciona un programa de un robot? 00:06:42

Primero, es un programa infinito, es un programa que se está ejecutando continuamente. 00:06:46

Cuando se termina por el final, volvemos al principio y volvemos a ejecutarlo. 00:06:50

Final, principio, ejecutamos, ¿vale? 00:06:54

Perdón. 00:06:59

Entonces, vamos a ir ejecutando y ese programa no se va a parar nunca. 00:07:01

El robot siempre está tomando medidas de los sensores, decidiendo y ejecutando. 00:07:04

Y vuelta, y vuelta, y vuelta, y vuelta, infinito. 00:07:10

¿De acuerdo? 00:07:12

Lo primero que hace que es leer de los sensores la información. 00:07:15

Y para que esa información no se pierda, esa lectura la tengo que almacenar en unas variables. 00:07:19

En unas cajas, que son cajas donde yo puedo guardar valores. 00:07:25

Es como los cajones. 00:07:30

Yo cuando quiero guardar algo que no se me pierda, lo meto en un cajón. 00:07:31

Y luego cuando tenga que ver eso que he guardado, voy al cajón, lo abro y lo recupero. 00:07:34

Pues lo mismo son las variables. 00:07:39

Entonces, yo leo la información de los sensores y esos valores que me están devolviendo los sensores los almaceno dentro del variable. 00:07:41

Luego, puedo coger esas variables y con esos valores que tengo allí almacenados, procesar la información, 00:07:49

ver qué se ha leído y tomar decisiones en función de qué me están devolviendo mis sensores. 00:07:55

Tomo las decisiones correspondientes, que es el proceso de la información, tomo decisiones 00:08:03

Y entonces, si tengo que actuar sobre alguno de mis actuadores, si tengo que activar alguno de mis actuadores, 00:08:10

sea un motor, una luz o lo que sea, lo que hago es simplemente poner a las conexiones que correspondan a esos actuadores 00:08:17

los voltajes necesarios o las señales necesarias. Igual que yo leo los sensores, puedo actuar con los actuadores. 00:08:28

vale, esto queda claro 00:08:36

esto que os acabo 00:08:38

de contar está suficientemente 00:08:40

claro, alguna pregunta 00:08:42

sobre esto 00:08:46

esto es fácil, esta es la parte de teoría que ya 00:08:47

habíamos visto, hemos resumido y tal 00:08:50

y bueno, más o menos es sencillo 00:08:51

vale, entonces 00:08:54

vamos al 00:08:56

tajo, vamos a lo importante que es 00:08:58

Tinkercad, vale 00:09:00

cuando vamos a Tinkercad 00:09:01

voy a compartiros 00:09:04

mi Google Chrome 00:09:05

Vale, cuando vamos a Tinkercad, nosotros lo que tenemos son diferentes elementos que yo puedo conectar. 00:09:08

Vamos a empezar por ver las salidas, que es lo más fácil. 00:09:20

Entonces, el robot va a leer las entradas, va a procesar la información y luego va a activar o no las salidas. 00:09:25

Por lo tanto voy a estudiar ciertas salidas, ciertos actuadores que yo puedo conectar en mi robot y esos actuadores que yo puedo conectar en mi robot lo que quiero es que sepáis cómo se activan y cómo no se activan. 00:09:31

Es decir, cuál es el procedimiento para activarlos, porque luego cuando tome las decisiones tendré que activarlos o no en función de lo que haya decidido. 00:09:45

Entonces, vamos a empezar. Ya tengo yo preparados mis esquemas para no perder el tiempo montándolos. 00:09:53

El esquema más sencillo es de salida, una luz. Podemos tener una o 30, me da igual. 00:10:03

El caso es que cada luz que yo tenga conectada a mi placa de control va a estar conectada a través de una resistencia. 00:10:09

el positivo, que es el terminal del ánodo, este que está todo doblado, lo tengo que conectar a mi señal, a mi pin de señal, 00:10:16

que en este caso es el 9, y el cátodo a tierra, a una entrada género de mi plata. 00:10:28

Ese es el circuito. Ya lo puedo hacer a través de protoboard, ya lo puedo hacer a través de cables que den 27 vueltas, 00:10:37

siempre que yo tenga una luz conectada, por un lado, tengo el positivo con una resistencia, 00:10:42

la resistencia de 220 ohmios, siempre, y esto deberíais apuntarlo, esto deberíais de saberlo, ¿vale? 00:10:49

Deberíais de tenerlo en el coco. 00:10:55

De mi pin, que yo voy a utilizar para activar o no ese dispositivo, en este caso la luz, 00:10:57

vamos a una resistencia de 220 ohmios 00:11:04

de la resistencia de 220 ohmios 00:11:07

al terminal 00:11:09

ánodo, al terminal positivo de mi luz 00:11:10

al que está doblado 00:11:12

y luego el que está sin doblar 00:11:14

directo a tierra, a grado 1 00:11:16

¿vale? a GND 00:11:19

y ya está, ese es el montaje 00:11:20

esto me lo tengo que saber 00:11:22

y cada vez que quiero utilizar una luz tengo que hacer este montaje 00:11:24

y conectarlo a un pin 00:11:26

y yo saber que pin es el que controla esa luz 00:11:27

¿y ahora qué hacemos? 00:11:30

Bueno, pues el programa que yo tengo que montar es muy facilito. 00:11:32

Si quiero activar esta luz, tengo que definir el pasador donde está conectado, es decir, el 9, en alta. 00:11:35

¿Vale? 00:11:43

Entonces, si yo ejecuto esto, simplemente la luz se va a encender. 00:11:45

¿Vale? 00:11:48

Pin, se enciende. 00:11:49

Estoy haciendo un programa infinito que está poniendo el pin 9 en alta. 00:11:50

Y eso activa el dispositivo que en este caso es la luz. 00:11:56

¿Vale? 00:11:59

Vamos a parar la simulación. ¿Qué pasa si yo lo pongo en baja? Que la luz se apaga. ¿Vale? Entonces, por ejemplo, si quiero hacer una luz que parpadee, ¿qué voy a hacer? Voy a definirlo en alta para que se active esa salida. Voy a esperar un tiempo con el elemento de control de esperar. Voy a esperar un segundo. 00:12:00

En la salida, ahora lo voy a apagar, el pin 9 lo pongo en baja, que quiere decir que lo desactive, con lo cual el pin 9 va a desactivar el dispositivo que tengo conectado, que es la luz, y va a esperar un segundo. 00:12:24

Y como esto se va a ejecutar de forma infinita, fíjate lo que va a hacer. Enciende, espera un segundo, apaga, espera un segundo. 00:12:42

Enciende, espera un segundo, apaga, espera un segundo, enciende, ¿vale? 00:12:49

Es decir, va a parpadear. 00:12:53

Si yo ejecuto esta simulación, pues la luz parpadea. 00:12:55

Tan sencillo como eso. 00:12:58

Esto es lo que tenéis que saber de las luces. 00:13:00

Las luces se conectan con el montaje que tengo a la izquierda 00:13:02

y la activo poniendo el pasador donde lo he pinchado en alta 00:13:06

y la desactivo poniendo el pasador donde la he pinchado en baja. 00:13:11

Eso es lo que tengo que saber de las luces, ¿vale? 00:13:15

preguntas de las luces. 00:13:17

No hay ninguna pregunta, supongo. 00:13:20

Es muy fácil. ¿Vale? 00:13:22

Muy fácil. 00:13:24

Bien. 00:13:26

Ya tenemos una pieza 00:13:27

que yo puedo utilizar, luces. 00:13:29

Puedo tener una o treinta, pero 00:13:31

cada una de ellas tengo que utilizar 00:13:33

una orden individual para 00:13:35

encenderla o apagarla. Cada luz 00:13:37

individual tiene su orden. No puedo 00:13:39

encender siete luces a la vez. Tengo que encender 00:13:41

cada luz y cada luz va a estar 00:13:43

en un pin correspondiente y yo las iré 00:13:45

Esto es fácil, lo que no es fácil es leer los semáforos. Ahora vamos, no te preocupes, quiero que entendáis todo esto. Siguiente, siguiente circuito, otra salida. En vez de una salida que sea una luz, voy a poner un motor. 00:13:47

vale entonces cómo funcionan los motores es otra salida es otro otro dispositivo que yo conecto en 00:14:02

otro sitio vale pues un motor tiene dos pines solamente negativo y positivo el negativo lo 00:14:11

tenemos que meter atrás a ground y el positivo lo tenemos que meter a un pin de mi placa a un 00:14:16

pin que yo pueda controlar un pin de control y ahora cómo hacemos el código pues igual que la 00:14:22

luz es decir si yo quiero activar este motor que tengo que hacer poner el pasador donde está 00:14:28

conectado al alta en este caso es el pasador número 6 pues en la pieza de software el programa tendrá 00:14:33

que tener un bloque que sea con el pin 6 en alta y ejecutó esto antes de encender la luz ahora que 00:14:39

va a ocurrir porque se enciende el motor y si yo lo pongo en baja y ejecutó la simulación pues no 00:14:45

hace nada, está apagado. Y si quiero que el motor se arranque y se pare, pues vamos 00:14:55

a hacer como el LED, vamos a hacer que parpadee, entre comillas, un motor. Bueno, pues entonces 00:14:59

lo voy a poner en alta, voy a esperar un segundo como antes. Fijaros que ya estoy yo programando 00:15:05

para que haga lo que yo quiera. Y esto es lo que quiero que vosotros penséis, estos 00:15:11

programas. El pin 6 baja y voy a esperar un segundo. Y ahora que estoy haciendo, estoy 00:15:14

haciendo un programa que lo que va a hacer es activar el motor, esperar un segundo, desactivar 00:15:20

el motor, pararlo y esperar un segundo. Y esto de forma infinita, con lo cual le decimos 00:15:25

y mirad, se arranca, se para, se arranca, se para, se arranca, se para. Ya tengo el 00:15:29

motor funcionando. Con lo cual, motor de corriente continua funciona igual que una luz. Se conecta 00:15:36

sin resistencias, directo, y funciona de esta forma. Se activa o se desactiva. Fácil. Seguimos. 00:15:41

Siguiente elemento o dispositivo de salida, el servo. 00:15:50

¿Cómo funciona un servo? 00:15:56

Bueno, pues un servo es un dispositivo de salida que tiene tres pines, positivo, negativo y señal, igual que, por ejemplo, tenemos, igual que tenemos otros. 00:15:59

En este caso ya no hay solo dos, hay tres. 00:16:11

Tengo el positivo que va siempre a 5 voltios, ese siempre está puesto, el negativo que siempre va a ground, ¿vale? Y luego tengo, fijaros, el positivo que es el negro llega a 5 voltios y el negativo, perdón, el positivo que es el rojo llega a 5 voltios y el negativo que es el negro llega a ground, ¿vale? 00:16:13

Y luego tengo el pin de señal. Veis que aquí si me pongo encima me lo va a decir tierra, potencia y señal. Bueno, pues el pin de la señal es el que yo tengo que meter a mi conexión sin resistencias y sin nada, simplemente a mi conexión de control. 00:16:35

vale, ya tenemos el montaje, esto hay que sabérselo 00:16:48

vuelvo a lo mismo, esto hay que sabérselo 00:16:51

y siempre que yo quiera poner un servo 00:16:52

tengo que conectarle 5 voltios 00:16:54

con siempre, o sea, de forma continua 00:16:56

5 voltios a potencia, 0 voltios 00:16:58

ground a tierra 00:17:01

y luego el pin de la señal para activar 00:17:02

o desactivarlo, vale 00:17:04

al, perdón, vamos a ponerle 00:17:06

al 9, ¿por qué al 9? 00:17:08

porque para el servo 00:17:11

tiene que ser uno de los que tenga 00:17:12

gurruñito, vale, de estos 00:17:13

de los que tenga un gurruñito 00:17:16

entonces para el servo 00:17:18

ya no es activar y desactivar como antes 00:17:20

ahora necesitamos una señal especial 00:17:23

y por eso esta señal especial es de las de gurruñito 00:17:24

esto lo tenéis que saber 00:17:27

yo os lo he explicado 00:17:29

ya lo tenéis que saber, simplemente lo apuntáis 00:17:30

y sabéis que siempre que yo quiera poner 00:17:32

un servo, lo puedo poner 00:17:34

hacia la de gurruñito, la del latido 00:17:36

si voy a poner un LED, lo puedo poner en cualquiera 00:17:39

si voy a poner un motor de corriente continua 00:17:41

lo puedo poner en cualquiera, pero un servo 00:17:43

lo pongo siempre en un pin de estos de Google. 00:17:45

¿Y ahora cómo funciona? 00:17:47

Bueno, pues si yo quiero activarlo, en este caso, el servo es un dispositivo 00:17:49

que va a hacer que su aspa esté desde 0 a 180 grados. 00:17:54

Es decir, va a estar en una posición que va a recorrer media circunferencia. 00:18:01

Y yo le voy a indicar el ángulo en el que quiero que se coloque. 00:18:06

Simplemente va a colocarse en el ángulo que yo le diga. 00:18:09

Entonces, ¿qué tengo? 00:18:11

en lugar de utilizar que un pasador 00:18:13

se ponga en alta o en baja, lo que voy a hacer es 00:18:16

fijaros que tengo una orden específica 00:18:18

para el servo, entonces 00:18:20

girar el servo que tengo en el pin 00:18:22

en este caso 9 00:18:24

voy a ponerlo en el pin 9 00:18:25

y aquí le pongo los grados, y este 00:18:27

número de grados tiene que ser un número entre 0 00:18:30

y 180, imaginemos 00:18:32

que yo le pongo 00:18:34

90 grados, vale 00:18:35

si yo pongo la simulación, fijaros 00:18:38

que el servo se pone a 90 grados 00:18:40

y como siempre está a 90 grados, pues se queda ahí. 00:18:42

Si yo le pongo a 180 grados, la orden, al iniciar la simulación, se va a poner a 180 grados. 00:18:46

¿Lo veis? Fiebre a 180 grados, más o menos, ¿vale? 00:18:52

Es un dispositivo mecánico que, bueno, que tendríamos que calibrar un poco 00:18:55

cuando hagamos un robot de verdad, pero vamos, al final, más o menos son 0 a 180. 00:18:58

Y si lo pongo a 45 grados, pues si antes estaba en horizontal y 90 grados era vertical, 00:19:03

va a ser como así, como en esta posición, más o menos, en la lateral, ¿vale? 00:19:10

Pues vamos a verlo. Perfecto. 00:19:14

Unas 45 grados, ahí lo tenemos, ¿vale? 00:19:17

Y ahora imaginaos que yo quiero que el servo pase de la posición horizontal 00:19:19

a una primera posición a 60 grados, luego a una posición a 120 grados 00:19:23

y luego a una posición a 180 grados y luego vuelva a cero. 00:19:29

Bueno, pues entonces voy a poner el servo del pasador 9 a 60 grados 00:19:34

Voy a esperar un segundito. Estoy haciendo lo mismo pero con otra salida. Giro el servo del pin 9 a 120 grados, esperamos otro segundito y giramos el servo del pin 9 a 180 grados para que comprobemos que va pasando por las diferentes y esperamos. 00:19:39

Como esto se va a ejecutar de forma infinita, va a pasar por 60 grados, ¿vale? 00:20:09

Y ahora, aquí después, lo tengo que llevar de nuevo a 0 grados. 00:20:14

El pin 9 a 0 grados y espero eso. 00:20:22

Con lo cual, empezando en 0, lo primero que va a hacer, ¿qué es? 00:20:27

Girarlo a 60, esperar un segundo. 00:20:30

Girarlo a 120, esperar un segundo. 00:20:33

Girarlo a 180, esperar un segundo. 00:20:35

girarlo a 0 grados, es decir, lo lleva a la posición inicial y espera un segundo. 00:20:36

Vamos a iniciar la simulación. Fijaros. 120, 180 y a 0. ¿Qué ocurre? ¿Por qué en el 0 no se espera un segundo? 00:20:42

Porque realmente la orden de girar se ejecuta y mientras que está haciendo el recorrido de volver a 0 00:20:55

ya está contando este segundo 00:21:04

por lo tanto aquí vamos a ponerle 00:21:06

dos segundos, ¿vale? eso es una 00:21:08

cosa que es 00:21:10

fácil de ver, pero vamos, os lo 00:21:12

explico, ahora son dos segundos 00:21:14

con lo cual va a estar un segundo más o menos 00:21:16

¿vale? ahora estaría funcionando perfectamente 00:21:18

¿veis? cuando yo 00:21:20

lanzo la orden, el motor 00:21:22

empieza a girar, pero todo el tiempo que está 00:21:24

girando ya está contando el tiempo que 00:21:26

le he dicho que espera, ¿vale? porque el programa 00:21:28

ya lanzó la orden y 00:21:30

se pone a ejecutar la siguiente 00:21:32

Bueno, pues aquí lo tenéis, ¿vale? El servo funcionando y haciendo los giros que yo le he dicho. 00:21:34

Entonces, ya tenemos dispositivos de salida, que son la luz, tenemos el motor de corriente continua y el servo que se mueve en función del ángulo que yo le indique. 00:21:40

Y las órdenes se ejecutan, en el caso de la luz y del motor, simplemente con activar y desactivar el pin. 00:21:48

Y en este caso, vamos a decirle el número de grados. Por esta característica que yo le puedo dar información, es por la que necesito que sea un pin de burbuño. 00:21:53

¿Vale? Un pin de estos de tilde. ¿De acuerdo? Vale. ¿Alguna pregunta hasta aquí? ¿Alguna pregunta? Estos son los dispositivos de salida, los que yo voy a utilizar para interactuar con el entorno. ¿Vale? 00:22:02

Hay un último dispositivo de salida, ¿vale? Hay un último dispositivo de salida que lo voy a utilizar cuando empiece a leer información de sensores, que es el monitor serie. El monitor en serie es como una pantalla integrada que tiene la propia placa, no se muestra la información por ningún sitio, no hay una pantalla física conectada, pero yo voy a poder ver esa información a través de este monitor, ¿vale? A través de esta ventanita. 00:22:22

Entonces, ¿para qué me vale? Para que cuando yo lea algo pueda comprobar qué valor tiene. 00:22:49

Y esto tiene su correspondiente orden que sería esta, la de imprimir en el monitor serie y un valor. 00:22:55

Si yo le pongo, fijaros, ¿vale? Voy a eliminar estos bloques, bueno, voy a dejar así, un segundito, ¿vale? 00:23:03

Voy a crear un circuito nuevo con mi placa, simplemente para que veáis cómo funciona el monitor serie, voy a poner mi plaquita, ¿vale? Y entonces ahora no le voy a conectar nada, simplemente lo que voy a hacer es imprimir por el monitor serie mi nombre, Juanra, ¿vale? 00:23:12

entonces fijaros que aquí en el monitor serie 00:23:40

va a empezar a aparecer 00:23:42

Juanra un montón de veces 00:23:45

¿vale? voy a decirle que espere 00:23:46

un segundo 00:23:48

para que veáis como 00:23:52

pasan las cosas voy a escribir dos cosas 00:23:54

después 00:23:56

hola a todos 00:23:58

¿vale? y luego nueva línea 00:24:01

y vamos a esperar un segundo 00:24:04

entonces fijaros que yo con estas órdenes 00:24:05

lo que voy a hacer es imprimir a través de esta 00:24:08

pantallita que no está conectada a ningún sitio 00:24:10

pero yo la puedo ver ahí 00:24:12

¿Vale? Puedo ver Juanra, hola a todos, Juanra, hola a todos, el programa se está ejecutando cíclicamente como todos y yo voy imprimiendo en esta pantallita información, puede ser un texto o puede ser el valor de una variable, que es lo que yo voy a utilizar para comprobar las lecturas de las variables cuando no sepa que han... ¿Vale? 00:24:14

Bueno, simplemente que sepáis que el monitor serie existe, se interactúa con él a través de esta orden, 00:24:35

imprimir en el monitor serie, y la salida sale por esta ventana que es el monitor serie. 00:24:40

Bien. 00:24:46

Con lo cual ya tenemos todas nuestras salidas. 00:24:47

Esas son las piezas con las que vamos a trabajar. 00:24:50

Motores, servos y luces. 00:24:52

Se acabó. 00:24:55

¿Vale? 00:24:56

¿Podemos tener más salidas? 00:24:56

Claro que sí. 00:24:58

Por ejemplo, imaginaros que yo quiero conectar algo que genere sonido. 00:24:59

Bueno, pues fijaros que aquí tengo positivo y negativo, ¿vale? 00:25:08

Bueno, pues el negativo lo voy a conectar a ground, que tengo uno por aquí, con lo cual voy a aprovechar este mismo. 00:25:12

El negativo siempre a tierra, negro, y el positivo va a ser mi señal. 00:25:19

Esto es como una luz, lo único que en vez de hacer una luz, lo que va a hacer es un sonido, un pitido. 00:25:24

lo voy a poner en rojo 00:25:30

y como va a ser 00:25:32

como lo voy a activar y como lo voy a 00:25:33

desactivar, pues exactamente igual 00:25:36

que un anu, es decir 00:25:38

lo que voy a hacer es 00:25:40

para activar y desactivar 00:25:41

un fumador, que sería este 00:25:44

lo que voy a hacer es poner 00:25:46

el pin donde está conectado, el 9 00:25:48

en alta, entonces 00:25:50

ahora al darle a iniciar la simulación 00:25:52

suena, vale, ahí lo tenéis 00:25:53

veis que tiene el símbolo de que está sonando 00:25:56

y si paro, deja de sonar, tan fácil como eso 00:25:58

¿vale? si yo le digo que 00:26:02

se active durante un segundo y luego 00:26:05

el pin 9 se desactive 00:26:09

pues esto lo que va a hacer es un parpadeo 00:26:14

pero en sonido, en vez de en luz, ¿vale? va a activarse 00:26:19

se va a desactivar, se va a activar, se va a desactivar, va a sonar 00:26:23

Va a dejar de sonar. 00:26:27

Esto cuando lo hagáis en casa vais a oír un sonido por vuestro ordenador, ¿vale? 00:26:28

Que quiere decir que está sonando. 00:26:33

¿De acuerdo? Ahora no sé si lo oís, probablemente no. 00:26:35

Pero además pone el simbolito de que está sonando con esa sondita, ¿vale? 00:26:38

Eso es un formador y eso sería pues lo que nosotros pondríamos, por ejemplo, 00:26:42

en un sensor de aparcamiento acústico. 00:26:45

En lugar de con una luz, con un sonido. 00:26:47

Bueno, tan sencillo como esto. 00:26:50

Preguntas con respecto a las salidas. 00:26:53

Salidas, dispositivos de salida. Venga, este es vuestro momento de gloria. ¿Vale? ¿No hay preguntas? Estoy mirando el chat. ¿Vale? Perfecto. Pues vamos entonces con los dispositivos de entrada. ¿Cómo funcionan los dispositivos de entrada? ¿Vale? 00:26:55

Y para los dispositivos de entrada, vamos a empezar por el primero y más sencillo, que es el botón. 00:27:22

¿Cómo puedo yo meter información a mi placa de control? 00:27:31

Bueno, pues una de las formas que tengo es a través de un botón. 00:27:36

El montaje del botón, ya sé que no es trivial, pero os lo he explicado ya varias veces y siempre tenemos que utilizar estas piezas. 00:27:40

Una de las patas, fijaros que el botón, como hemos visto antes en la foto, tiene dos pines en una cara y dos pines en otra cara. 00:27:49

Yo solo voy a utilizar los dos pines de una cara, porque este botón es doble, con lo cual yo esto es como si lo partiera a la mitad y la mitad de la derecha no quisiera utilizarlo. 00:27:57

La parte de la izquierda, estos dos pines los voy a utilizar como un interruptor normal, cuando pulso el botón se me unen y cuando dejo de pulsar se me separan. 00:28:08

¿Y cómo conecto este botón? Bueno, pues las dos patillas que están en la misma cara, una de ellas la conecto a positivo, ¿vale? La conecto a 5 voltios. ¿Veis? Que esto está conectado a 5 voltios. 00:28:17

Y la otra patilla tengo que conectarla a la vez a dos sitios. Por un lado, a través de una resistencia de 10K a tierra, a ground, al negro. 00:28:29

Veis que todo esto se me va hasta el negro. Con lo cual, esta patilla que está conectada a todos estos pines, por este lado está conectada a esta resistencia que a su vez en la otra patilla está conectada a ground. 00:28:44

Y además, esta patilla también está conectada al pin de señal que yo voy a utilizar para leer ese botón, que en este caso es el pin 4, es un pin digital. 00:28:56

Entonces, ¿qué voy a hacer yo para leer la información que tengo del botón, para saber si ese botón está pulsado o no? 00:29:07

Bueno, pues yo lo que voy a hacer es, en las entradas, voy a asignarle la lectura del pin 4 a una variable. 00:29:15

Con lo cual lo primero que tengo que hacer es definirme una variable, un almacén donde yo guarde la información que lea de ese sensor. Voy a llamarla botón, ¿vale? Puedo llamarla Felipe, puedo llamarle Asunción, me da igual, ¿vale? Es un nombre identificativo y yo le llamo como me dé la gana. 00:29:22

En este caso, en la caja, es como una caja de zapatos en la que yo le he puesto un cárter que pone botón y entonces yo ahí voy a meter valores y luego voy a abrir la caja y voy a ver qué valores están dentro. 00:29:44

con lo cual, como leo yo si el botón está pulsado o no 00:29:54

viendo en qué estado se encuentra el pin 4 00:30:01

si está en alta o en baja 00:30:05

igual que para activar una luz lo poníamos en alta 00:30:07

el pin correspondiente y para desactivar la luz lo poníamos en baja 00:30:10

cuando el botón se pulsa me va a poner este pin en alta 00:30:14

y yo voy a poder leerlo 00:30:19

Y cuando DER no está pulsado, este pin va a estar en baja y yo voy a poder leerlo. 00:30:21

Por lo tanto, ¿qué voy a hacer? Voy a definir, voy a asignar a la variable botón la entrada correspondiente a leer un pasador digital, que es el número 4. 00:30:28

Con esta orden, yo lo que estoy haciendo simplemente es leer lo que está ocurriendo en el pin 4, que en el pin 4 puede haber conectado lo que sea. 00:30:42

Yo sé que es un botón, pero la placa de control no. 00:30:50

La placa de control solamente va a ir al TIN4 y va a comprobar si está en alta o en baja. 00:30:55

Y esa información la va a almacenar dentro de la caja botón. 00:30:59

Se acabó. 00:31:02

¿Vale? 00:31:03

Dentro de esa caja de zapatos que hemos visto, que hemos puesto con la etiqueta botón. 00:31:03

Entonces, si yo utilizo esta orden, estoy leyendo la información del botón y almacenándola en una variable. 00:31:07

Vamos a poner por el monitor serie cuánto vale la variable botón. 00:31:15

Entonces, si yo utilizo esta orden de poner a través del monitor serie la variable botón 00:31:27

y ahora vamos a decirle que espere, por ejemplo, 100 milisegundos, 00:31:32

que esto es algo que ya os he dicho que siempre es bueno ponerlo para que no se saturen los sensores, 00:31:36

¿qué voy a hacer? 00:31:42

voy a poner, voy a hacer una cosa 00:31:43

para saber diferenciar 00:31:46

las líneas 00:31:50

para que veáis que sí que están pasando 00:31:52

bueno, da igual, vale, lo dejo así 00:31:54

le damos a iniciar simulación 00:31:56

y fijaros que aquí me va poniendo 00:31:58

0, 0, 0, 0, ahí están pasando 0 00:32:00

¿qué pasa en el momento en el que yo pulse? 00:32:02

¿por qué está poniendo 0? 00:32:05

porque está desactivado, porque el botón no está pulsado 00:32:06

y el 4 está en baja 00:32:08

¿ahora qué pasa si yo lo pulso? 00:32:10

que se pone en alta, se pone a 1, veis que ha cambiado en el monitor serie, ha cambiado el valor a 1 00:32:12

y si suelto, que voy a soltar ahora, se pone a 0, con lo cual esto que estoy haciendo simplemente es 00:32:18

coger la información correspondiente al pin del botón y guardándola en la variable botón, ya está 00:32:24

y esta es la forma de trabajar con botones, entonces cuando yo utilice un botón tendré que leerlo 00:32:32

y almacenar su valor en una variable. 00:32:40

Ya os acordáis que el funcionamiento de un programa de un robot 00:32:42

siempre era leer los sensores, almacenar esos valores en variables, 00:32:45

luego tomar decisiones y finalmente actuar. 00:32:50

Y vuelta a la burra al trigo, ¿vale? 00:32:53

Vuelta al ciclo, vuelta a volver a hacer lo mismo. 00:32:56

Y eso siempre. 00:32:59

Entonces, insisto, definimos la variable botón 00:33:00

y después asignamos su valor como una lectura de un pin digital, 00:33:04

que en este caso es el botón. 00:33:08

Vale. Preguntas sobre cómo funcionan los botones. ¿Alguna duda? Esto es otra pieza que tengo para mi puzle. ¿De acuerdo? ¿Vale? Bueno, no hay dudas. Continuamos. 00:33:10

¿Más dispositivos de entrada? Tengo otros dos que hemos estudiado. Ya voy un poquito más rápido. ¿Vale? Entonces, ¿qué dispositivos tenemos? La LDR. La LDR es un sensor de intensidad lumínica. 00:33:29

El sensor de intensidad lumínica, ¿cómo se conecta a la placa de Arduino? 00:33:45

Exactamente igual que el botón. 00:33:50

Tiene dos pines, ya hemos visto que nosotros el botón tiene dos conexiones, que son las que usamos, 00:33:52

las dos que están en la misma cara, pues aquí tengo dos pines. 00:33:57

Uno de ellos a positivo y el otro conectado con una resistencia de 10K a ground 00:34:00

y además al pin de señal, que en este caso es un pin analog. 00:34:05

¿Y qué quiere decir esto? 00:34:10

Que cuando yo lea ese pin, no voy a tener solamente dos estados, que son los estados digitales de activado y desactivado, alto, abajo, uno, cero, como habéis visto, sino que voy a tener un valor entre cero y mil veinticuatro. 00:34:11

Realmente ese valor entre cero y mil veinticuatro va a depender de la resistencia que yo le coloque aquí. 00:34:26

No va a ser desde cero ni hasta mil veinticuatro, dependiendo de la resistencia, va a ser más o menos un valor cercano a cero y un valor cercano a mil. 00:34:33

más o menos. Aquí yo le he puesto una resistencia de 10 gas, ¿vale? Y entonces con esa resistencia 00:34:41

esto va a ir desde un rango a otro. ¿Qué rango es el que va a coger? Bueno, pues lo 00:34:49

primero que vamos a hacer es ver cómo leemos ese sensor. ¿Cómo hemos leído el botón? 00:34:56

Creando una variable y luego yendo al pin digital correspondiente y leyéndolo. Ahora 00:35:02

vamos a hacer exactamente lo mismo pero desde el pin 00:35:08

analógico. Vamos a crearnos una variable 00:35:10

y esa variable se va a llamar 00:35:12

LDR para ser 00:35:15

originales. Cuando la 00:35:16

creo ya me genera los 00:35:18

bloques para poderlas dar valor 00:35:20

y quitarse y cambiarle el valor. 00:35:22

Y vamos a hacer como antes. 00:35:24

Vamos a asignarle 00:35:26

a la caja que ahora hemos llamado 00:35:27

LDR. Tenemos otra caja de zapatos 00:35:30

que hemos creado y hemos puesto una etiqueta 00:35:32

que se llama LDR. Y en esa caja 00:35:34

de zapatos ¿qué valor voy a meter? 00:35:36

Pues la entrada correspondiente a leer un pasador, que en este caso es analógico. 00:35:37

Por lo tanto, leer el pasador analógico y aquí es donde lo he conectado al A1. 00:35:42

Y ya está. 00:35:49

Con esto ya estoy leyendo el valor de la LDR, el montaje es el que veis a la izquierda, 00:35:50

y su valor lo estoy almacenando en A1. 00:35:56

Ahora vamos a ver cuánto vale ese valor. 00:35:59

¿Cómo lo puedo ver? 00:36:02

Pues como antes, lo que voy a hacer es imprimirlo por la pantalla, el valor de la variable. 00:36:03

Con lo cual, si yo ejecuto esto, vemos que aquí me está dando un valor, 54, 00:36:11

pero si yo voy cambiando la intensidad lumínica que actúa sobre ese LDR, veis que se va hasta 974 en el otro extremo. 00:36:18

Pero fijaros que no es lineal, es decir, no es proporcional. 00:36:29

Aquí son 54 y lo muevo un poquitín y ya me he ido a 800, ¿vale? 00:36:32

Eso es porque esta resistencia es muy grande. 00:36:37

Entonces, normalmente, las LDRs, nosotros las vamos a trabajar con resistencias más pequeñas. 00:36:40

Una resistencia de 2K. 00:36:47

Eso va a hacer que esto sea más lineal, pero aún así no es 100% lineal. 00:36:49

Con una resistencia de 2K, ahora en lugar de 54 es 11, en el mínimo, ¿vale? 00:36:54

Y en el máximo nos vamos a 816. 00:37:01

¿Qué es lo que tengo que hacer yo cuando quiero utilizar una LDR? 00:37:03

Tengo que calibrar. 00:37:06

Es decir, si yo quiero que suceda algo, por ejemplo, cuando pase del valor medio, 00:37:08

pues me tengo que venir con mi medidor de intensidad al valor medio 00:37:13

y ver qué valor me está ofreciendo en ese caso la LDR. 00:37:16

Y este será el valor que yo tendré que utilizar para tomar decisiones. 00:37:21

Por ejemplo, si cuando es más oscuro que la mitad de la intensidad lumínica 00:37:25

quiero que una luz esté apagada y cuando sea más alto quiero que se encienda, 00:37:29

pues entonces utilizaré ese valor de 695 como el valor de compasión. 00:37:35

Para que cuando esté por encima de esto, el sensor, estaremos por un valor más bajo 00:37:39

del valor que hemos utilizado como referencia y cuando estamos en el otro extremo 00:37:43

estamos un valor por encima. Esa es la idea. 00:37:49

Por lo tanto, lo que tenemos que hacer con los sensores analógicos es calibrarlos un poquito 00:37:52

para estar seguros de que estamos midiendo y interpretando lo que queremos, ¿vale? 00:37:57

Por ejemplo, 700, ¿vale? Pues puede ser un valor intermedio válido. 00:38:03

¿Entendido cómo funciona el LDR? ¿Y cómo se calibra? 00:38:09

Hola, os habéis muerto ya todos. 00:38:21

¿Hola? ¿Alguna pregunta? Escribidlo por el chat. Vale. 00:38:29

Lo de sí es que os habéis muerto, ¿no? 00:38:37

Bueno, ninguna duda. Vale, venga. 00:38:39

De verdad, son piezas, piezas que yo ya os las doy resueltas. No tenéis que inventar nada, solamente tenéis que utilizar. Perfecto, entonces, LDR, analógico y por lo tanto un valor entre 0 y 1024 más o menos. 00:38:45

Bien, hemos visto el otro sensor, perdón, que es el pulsador, que es digital, 01. 00:39:01

Vamos a hacer un tercero, un tercer sensor, ¿vale? 00:39:12

Que es el medidor de distancia. 00:39:16

Y con esto ya terminamos con todas las piezas. 00:39:17

Tenemos seis piezas. 00:39:20

Ya vamos a ver que son solo seis piezas, ¿vale? 00:39:21

Y esas seis piezas son las que yo voy a utilizar para hacer mis puntos. 00:39:24

Por lo tanto, vamos a ver el sensor de distancia. 00:39:27

El sensor de distancia que yo voy a utilizar es el sensor de distancia que tiene cuatro pines. 00:39:30

Esto es importante. 00:39:35

Y ese sensor de distancia que tiene cuatro pines lo encontramos en componentes todos. 00:39:37

Y ahora ya nos vamos a donde los sensores de distancia. 00:39:45

Ya tengo los dos módulos. 00:39:47

El de tres pines y el de cuatro. 00:39:48

Yo utilizaré el de cuatro. 00:39:50

El HC-SR04. 00:39:51

¿Vale? 00:39:53

Esto es importante porque yo todas las órdenes las estoy haciendo con este sensor. 00:39:54

Bien. 00:39:59

¿Cómo se conecta? Pues tiene una conexión a potencia, una conexión a tierra, VCC y ground, y luego tiene un pin de trigger y un pin de eco, un pin de disparador y un pin de eco, ¿vale? 00:40:00

Bueno, pues entonces, el positivo VCC tiene que ir a 5 voltios, aquí lo tenéis, 00:40:13

el ground tiene que ir a tierra, y luego el trigger tiene que ir a un pin 00:40:20

y el eco a otro pin de control. 00:40:26

Son los dos pines que yo voy a utilizar de control, ¿vale? 00:40:29

¿Vale? Entonces, ¿cómo interactúo yo, cómo programo, cómo puedo leer la información de ese sensor? 00:40:32

En este caso concreto tengo una orden especial en las entradas que es leer el sensor de distancia. 00:40:44

Antes, como siempre, tengo que crear una variable que voy a llamarle distancia, por ser original, 00:40:50

Y ahora le voy a decir que lea la distancia del sensor utilizando su orden específica. 00:40:55

No voy a leer un pin digital ni uno analógico como antes, sino que ahora tengo una orden específica. 00:41:03

Que es leer el sensor de distancia de ultrasonico. 00:41:10

Hemos visto que el pasador del desencadenador, el trigger, el desencadenador, ¿vale? 00:41:14

O el disparador, trigger, lo he pinchado al 5. 00:41:20

en el 5 00:41:23

y el pasador 00:41:26

del eco 00:41:28

hemos visto que es el 9 00:41:29

estos pueden estar a cualquiera 00:41:31

no hace falta que sean con tilde 00:41:33

pueden estar a uno con tilde o a uno sin tilde 00:41:35

me da igual 00:41:38

entonces el caso es que yo tenga 00:41:38

dos pines digitales cualesquiera 00:41:40

y le tengo que indicar que pines 00:41:43

son los que estoy utilizando 00:41:45

para el desencadenador o trigger y para el eco 00:41:46

o eco 00:41:49

y en las unidades en las que lo mido en centímetros 00:41:50

Pues por lo tanto, directamente, yo en esa caja en la que he puesto la etiqueta distancia, 00:41:53

lo que voy a meter es la distancia en centímetros que me mida ese senso. 00:41:59

¿Vale? 00:42:05

Tan fácil como eso. 00:42:06

Y ahora, ¿yo qué puedo hacer? 00:42:08

Pues como antes, voy a poner por el monitor serie la distancia. 00:42:09

Voy a imprimir en el monitor serie directamente la variable distancia. 00:42:16

Si yo ejecuto, fijaros que ahora me sale aquí el arco de influencia, cuando pincho sobre el sensor, aquí estoy en 113,4, como esto es una variable entera, me está cogiendo 113. 00:42:22

Si yo lo varío, veis que 66 centímetros, 66. Y si me voy a 158,5, me coge 158. Si me voy a 174,1, 174. 00:42:35

Veis que en la variable distancia yo estoy metiendo la lectura de esta distancia de este sensor. 00:42:48

Este sensor, si me acerco mucho, pierde el rango y me da valores extraños. 00:42:56

Por aquí fuera no está detectando, está detectando nada, ¿vale? 00:43:00

Y eso tenemos que tener cuidado. 00:43:05

Este sensor me da valores espurios, pero cuando me meto dentro sí me está dando valores válidos. 00:43:07

Fijaros que la distancia máxima a la que llega en este caso son 3 metros 30 más o menos, ¿vale? 00:43:16

3.30. 00:43:22

Entonces cuando yo me salgo del rango simplemente me está dando la distancia máxima. 00:43:23

Cualquier objeto que esté fuera del rango de visualización no es detectado. 00:43:28

Y el sensor está contando como que no existe ningún objeto dentro del rango de visualización. 00:43:33

Pero en el momento en el que un objeto entra dentro del rango, empieza a medir y ya me empieza a dar las medidas correctas, ¿vale? 00:43:39

En cualquier punto del rango me va a dar la distancia. 00:43:48

Vale, pues eso es cómo funciona el sensor de distancia. 00:43:51

Y eso es cómo funciona el sensor de distancia de verdad, ¿vale? 00:43:53

Entonces, yo leo el sensor, meto la variable y ya la pongo, en este caso hago con ella lo que quiero, que lo que estoy haciendo es imprimirla en el momento. 00:43:56

Bueno, pues ya tengo todas mis piezas. 00:44:06

piezas de entrada botón sensor de distancia ldr piezas de salida luces motores de corriente 00:44:08

continua y servos y además puedo visualizar cosas es una salida también por el monitor 00:44:19

serie puedo visualizar variables el valor de las variables los puedo poner aquí para visualizar su 00:44:28

contenido bien y ahora como lo pongo junto bueno 00:44:34

pues a través de las secuencias de control yo solamente os he enseñado una 00:44:39

secuencia de control la secuencia si vale es decir si la variable tiene 00:44:44

determinado valor u otro yo actúo o dejo de actuar entonces vamos a empezar 00:44:50

haciendo el ejemplo más fácil de todos que es 00:44:56

por ejemplo pues un botón que me encienda un motor vale por ejemplo o una 00:45:02

LDR que me encienda un motor vamos a verlo con la LDR que es quizá el caso un poco 00:45:09

más complejo que podemos encontrar entonces en este caso si yo cojo la LDR 00:45:13

y digo que cuando la LDR esté por debajo de un determinado umbral 00:45:20

de valor, se encienda el motor 00:45:26

y cuando esté por encima de ese umbral se apague, 00:45:30

lo primero que tengo que hacer es poner mis dos piezas, ¿vale? 00:45:33

Mis dos piezas son la LDR, que ya la he puesto, y un motor. 00:45:36

Aquí está el motor. 00:45:40

¿Y el motor cómo lo conectamos? 00:45:41

¿Este pin es el negativo? Pues lo voy a poner al negativo 00:45:44

y lo voy a conectar a este negativo que tengo aquí, 00:45:47

toda esta columna, ya sabéis que está negativo porque lo he electrificado en la protoboard 00:45:49

como negativo. Entonces toda esa línea que se pone ahora en verde, ahí lo tenéis iluminado 00:45:54

en verde, es negativa. Y toda esta columna que está ahora iluminada está en positivo. 00:45:58

Por lo tanto, el negativo es negativo y hemos dicho que el positivo lo tengo que meter a 00:46:03

un pin de señal. Pues voy a utilizar el pin 9 para encender o apagar el motor. Este es 00:46:07

mi montaje que he estudiado de mi motor normal y corriente. ¿Vale? Este es el montaje que he visto 00:46:15

antes de mi motor. Es decir, un pin de señal y el negativo a tierra. Ya está. Y ahora, cuando yo 00:46:24

quiero activar ese motor, ¿qué tengo que hacer? Poner el pin 9 en alta y cuando quiero desactivarlo 00:46:32

poner el pin 9 en baja. ¿Vale? Por lo tanto, ¿yo qué tengo que hacer? Bien, primero acordaros de cómo 00:46:36

son los programas de robots. Primero leemos las variables, leemos la variable y almacenamos 00:46:43

su valor en una variable, o sea, leemos las entradas, leemos los sensores y almacenamos 00:46:52

su valor en una variable. Entonces leemos el pasador analógico A1, con lo cual yo voy 00:46:59

a coger esta resistencia y voy a meter su pin de conexión, donde me está ofreciendo 00:47:04

la información en una variable. Bien, una vez que yo tenga esa variable cargada con el valor que he leído, voy a tomar decisiones. 00:47:11

Y para tomar decisiones utilizo el sí, el bloque de condición. Si esta variable tiene un valor por encima de un valor o por debajo de un valor, 00:47:25

voy a hacer una cosa u otra. Entonces, voy a hacer con el bloque de comparación, si la variable de LDR, el valor que tengo ahí metido 00:47:33

dentro de esa variable, ese valor que yo he leído, es menor que 600, ¿vale? Habíamos visto que la variable LDR antes me ofrecía valores 00:47:43

que iban entre 11 y 800 y pico, y que más o menos la mitad de camino estaban en 600 o en 700, no recuerdo bien, ¿vale? 00:47:56

Luego lo comprobamos. Pero en este caso voy a coger el 600 como el valor umbral que yo quiero para activar o desactivar mi motor. 00:48:04

Bueno, pues si estoy por debajo de ese umbral, quiero activar el motor. ¿Cuál era la orden para activar un motor? 00:48:11

Pues en las de salida poníamos el pin correspondiente al motor en alta, el 9. 00:48:17

Estoy juntando dos piezas, dos piezas, la de leer el LDR con la de activar el motor. 00:48:23

Pero para activarlo tiene que cumplirse una condición, por eso utilizo la estructura del sí. 00:48:31

En caso de que no esté por debajo, ¿qué quiero hacer? 00:48:37

Tener el motor parado. 00:48:39

Por lo tanto, lo que voy a hacer es el pin 9 en baja. 00:48:41

Si está por debajo de este umbral el motor se enciende, si está por encima, si no está por debajo es porque está por encima, entonces se apaga. 00:48:46

Ya está, ya hemos hecho un programa con dos piezas y una decisión entre medias, ya estamos haciendo un robot. 00:48:56

Leemos la información, leemos la información, almacenamos esa información en variables, tomamos decisiones y en función de las decisiones decidimos si actuamos. 00:49:03

Con lo cual, iniciando la simulación, fijaros que ahora está encendido 00:49:14

¿Por qué? Porque inicialmente esto está siempre en apagado, en oscuro, en oscuridad 00:49:19

Entonces voy a moverlo y cuando llegue al umbral de 600, ahí más un poquito antes de la mitad 00:49:24

Se para y ya a partir de ahí está parado 00:49:30

Y cuando baje del umbral, se encenderá 00:49:32

Fijaros, voy a poner, para comprobar, voy a imprimir por el monitor serie 00:49:36

Esto simplemente se hace para comprobar, ¿vale? 00:49:43

Voy a poner el valor de la variable y así tengo visibilidad de qué valor estoy utilizando. 00:49:46

Fijaros, cuando yo ejecuto esta orden ahora de leer la variable y poner el valor, estamos en 11. 00:49:51

Vamos a modificar y vamos viendo que sube, sube, sube, sube, sube y da un momento hasta que no pasa, 00:49:57

ya estamos en 614, cuando pasa de 600, esto se ha parado. 00:50:03

¿Vale? ¿Qué pasa si yo quiero que el grado de luminosidad sea aquí, en la mitad? 00:50:08

Pues que voy a coger ese valor que son 700 y lo voy a sustituir aquí, 700. 00:50:13

Entonces, como 700 es el valor de la mitad de la luminosidad, ahora habré ajustado para que mi robot funcione 00:50:20

moviendo el motor hasta que llegue aquí a la mitad, cuando llegue justo a la mitad, para. 00:50:28

¿Lo veis? Y ahora funciona como yo quiero. 00:50:34

Entonces, ¿cómo hay que hacer, por ejemplo, el medidor de luminosidad con el servo? 00:50:37

¿Vale? Con la flechita y los indicadores de nube, sol, luna. 00:50:47

Bueno, pues yo tengo que hacer un montaje en lugar de con un motor, con un servo. 00:50:54

El servo ya hemos visto que yo le puedo indicar el ángulo con el que quiero que se mueva. 00:50:58

Y en este caso se movería entre 0 a 60, a 120 y a 180. Serían los 3 grados. 00:51:02

Y luego lo que tengo que hacer es calibrarlo. ¿Para qué? Para que cuando pase de una determinada cantidad, por ejemplo, de 586, que es como un cuarto del camino, pase a la primera posición. 00:51:08

cuando pase del medio camino, que hemos visto que eran como 700, 00:51:20

llegue a la mitad, cuando pase de tres cuartos del camino 00:51:26

se vaya a la siguiente posición y cuando esté a tope, que son 816, 00:51:29

se vaya a la luminosidad. 00:51:34

Y esos son los valores que yo voy a utilizar en función de un programa 00:51:36

que construiré con sí, si el valor es menor que el primer umbral, 00:51:40

entonces lo pongo a 60 grados. 00:51:47

Si no, tengo que hacer otra condición aquí dentro, en la anidada. Si es menor que el segundo umbral, ponlo a 120. Si es menor que el tercer umbral, ponlo a 180. ¿Vale? Y así yo lo que estoy haciendo es definirme los tres rangos o cuatro rangos y puedo ir moviendo el servo en su posición. Entradas y salidas. Y así es como yo hago mis robots. ¿Vale? 00:51:48

Entonces, preguntas que tengáis y voy a pasar a ver directamente los montajes de los ejemplos que tenéis que hacer ahora en los ejercicios y ya con eso termino. ¿Vale? Venga, tengo el chat abierto. ¿Alguna pregunta? ¿Alguna preguntita que tengáis? ¿De cómo funciona cada una de las piezas y cómo puedo mezclarlas? Vale. 00:52:16

Entonces, de verdad, no nos complicamos, es fácil, simplemente tengo que saber cada pieza de las que tengo disponibles 00:52:42

y luego hacer que esas piezas enganchen, que engranen. 00:52:49

Vale, pues vamos a ver los ejercicios de nuestro famoso libro. 00:52:54

Primer montaje que teníamos, ya hemos dicho, un montaje en el que teníamos una LDR y teníamos también un servo. 00:53:02

¿Vale? Entonces, el ejercicio 1, ¿vale? Sería de esta forma. Sería un ejercicio en el que yo necesito dos piezas. Una LDR y un servo. 00:53:11

Lo he colocado así porque es la forma en la que está dibujado en vuestro libro. ¿Vale? Está más o menos clavado. 00:53:30

Así es como lo tenéis en el libro. Yo lo he pintado así, pero lo puedo colocar en vertical como lo tenía antes o lo puedo colocar sin la protoboard, 00:53:36

conectando cables directamente, me da igual 00:53:43

la cuestión es que 00:53:45

el montaje de la LDR 00:53:47

si os fijáis es 00:53:49

la patilla de la derecha 00:53:50

tiene que ir 00:53:53

a negativo 00:53:54

a través de una resistencia 00:53:56

y a la señal 00:53:59

a cero, y la de la izquierda 00:54:00

a positivo, ya tengo 00:54:03

mi LDR montado con mi montaje 00:54:04

normal y corriente, ¿vale? 00:54:07

aquí que le he puesto 5K en este caso 00:54:08

bueno, pues tendré que calibrarlo 00:54:10

Y después, mi servo tiene potencia 5 voltios, tierra a cero y luego la señal que la he puesto a través del cable amarillo al pin. 00:54:12

¿Vale? Entonces, tengo mis dos montajes, mis dos piezas y cada pieza la he montado por separado. 00:54:24

Sé cómo funcionan y ahora, cuando yo quiera leer, una vez que tengo el hardware hecho, una vez que tengo la parte física construida, 00:54:31

Ahora que tengo, muy fácil, que leer el LDR en la variable cero y en función del valor que lea, actuar sobre el servo indicándole qué grados quiero que gire. 00:54:38

Bueno, pues ¿cómo sería el programa? 00:54:52

Esto es lo que quiero que hagáis vosotros, el programa. 00:54:55

Es tan fácil como este programita que he puesto. 00:54:57

¿vale? primero dos variables 00:54:59

en este caso, una 00:55:03

que se va a llamar luz, que es donde yo voy a leer 00:55:04

¿vale? una es donde yo 00:55:07

voy a leer el valor 00:55:09

de la LDR y otra es 00:55:11

donde yo voy a 00:55:13

asignar ¿vale? 00:55:14

asignar, esperad un segundo 00:55:17

este es otro que 00:55:18

¿vale? es que tengo 00:55:20

dos ejemplos ¿vale? 00:55:23

el de la LDR, ¿dónde estamos? 00:55:24

¿dónde estamos? 00:55:27

jolín 00:55:30

Ejercicio 1, bloques, este, perdonad. 00:55:32

Vale, es el mismo montaje, ¿vale? 00:55:35

Todo lo que se explica dual. 00:55:37

Entonces, el montaje es este. 00:55:39

El mismo. 00:55:43

¿Pero cómo es el código? Vale, pues es muy fácil. 00:55:45

Yo, ¿qué he hecho? 00:55:48

He venido, me he definido una variable que se llama luz, 00:55:50

que es donde voy a almacenar el valor de la LDR. 00:55:54

La leo. 00:55:56

Leo la LDR y almaceno su valor en luz. 00:55:58

Y luego, si la luz es menor que 350, entonces me pones el servo a 180 grados. 00:56:00

Si no es menor de 350, voy a comprobar si es menor de 525. 00:56:09

Claro, como no es menor de 350, porque estamos en el si no, 00:56:14

eso quiere decir que es mayor de 350 y menor de 525. 00:56:18

En ese rango, gira el servo a 120. 00:56:21

Si no, es decir, si es mayor de 525 y es menor de 625, gira el servo a 60 grados. 00:56:25

Y si no, es decir, si es mayor de 625, ponlo a 0 grados. 00:56:35

Y luego espera 100 milisegundos. 00:56:39

Fijaros qué ocurre. 00:56:41

Yo tengo aquí el servo, se pone a 0, y ahora en función de la luminosidad que incida, 00:56:43

cuando llego al 25% salta a la primera posición, cuando llego al 50% salta a la segunda posición, 00:56:48

Y cuando paso del 75% se va a luminosidad total. 00:56:55

Por lo tanto, yo lo que tengo aquí es exactamente un medidor de luminosidad 00:57:00

que me va a ir indicando cuatro posiciones. 00:57:04

Las cuatro posiciones que teníamos en nuestro diagrama con la luna, nublado, soleado y sol. 00:57:06

¿Vale? 00:57:14

Y ya estaría hecho mi montaje. 00:57:15

¿Cómo he averiguado yo estos valores de la LDR? 00:57:17

Para que sean exactamente los puntos en los que yo quiero. 00:57:21

Muy fácil. 00:57:23

Ya lo sabéis, he cogido la variable luz y he mostrado su valor por el monitor serie, con un bloque aquí entre medias. 00:57:25

Si yo estoy visualizando en el monitor serie cuánto vale el valor, me he venido ejecutado y entonces he cogido y me he venido con esto a la posición aproximadamente de un cuarto 00:57:33

y he visto que está en torno al 350, pues ese es el valor que he utilizado. 00:57:47

Me he venido al medio y he visto que el valor está en torno al 525 00:57:51

y es el valor que he utilizado. 00:57:56

Después, la tercera posición, he visto que eran tres cuartos del trayecto 00:57:58

y me he venido y he visto que son 625, más o menos. 00:58:04

Con lo cual yo lo que he hecho ha sido venirme al programa antes de que funcionara 00:58:07

y hacer una medición utilizando el monitor serie de la luz. 00:58:13

Y he calibrado dónde está el 25%, el 50% y el 75%. 00:58:18

Y luego ya he hecho que gire el servo en sus posiciones. 00:58:22

Y ese sería el programa. 00:58:28

¿Vale? 00:58:30

¿Lo habéis visto cómo funciona este programa? 00:58:32

¿Habéis visto cómo se resuelve? 00:58:35

y habéis visto cómo se 00:58:37

hace que en función 00:58:40

de la luz que incida esto gire 00:58:42

¿vale? 00:58:44

también podemos hacer una cosa 00:58:46

también podemos hacer una cosa 00:58:48

antes de 00:58:50

terminar ¿vale? ya sé que me estoy enrollando 00:58:52

pero quiero que quede muy claro y 00:58:54

que hay que aprenderse 00:58:56

la memoria, no hombre, no, tú lo tienes ahí apuntado 00:58:58

en un papelito y ya está y lo tienes todo 00:59:00

eso, si estuviéramos en clase 00:59:02

y fuéramos a hacer un examen, todavía 00:59:04

Pero ahora que estamos en online, simplemente con que lo tengas y sepas ahí con un papelito que sepas cómo se conecta cada cosa, son seis cosas y muchas de ellas van conectadas directas. 00:59:06

O sea que no es muy complicado. 00:59:17

¿Vale? 00:59:20

¿Qué quería deciros? 00:59:21

Mira, si yo en lugar de querer hacerlo por bloques quiero utilizar los códigos del libro, ¿vale? 00:59:22

Entonces también lo puedo hacer. 00:59:30

¿Vale? 00:59:33

El ejercicio 1, hecho con código, yo cuando abro la parte correspondiente al código, tengo aquí la opción de poner bloques, bloques y texto o solo texto. 00:59:33

Si me voy a la opción de solo texto, me da un mensaje de aviso de que todo lo que tenga hecho con bloques se va a perder, pero este que es el mismo montaje que yo tengo hecho en el libro, si copio el programa del libro y lo incluyo, también funciona. 00:59:46

Pero en este caso, el libro lo que ha hecho ha sido que va cambiando los grados en función de la luminosidad. Si os fijáis, yo voy moviendo y se va moviendo conmigo. Es decir, no son cuatro posiciones, sino que es como continuo. 00:59:59

¿Vale? Entonces ese es el programa que ha hecho el libro. Y esto es copiándolo aquí directamente, copiar y pegar y funcionaría. ¿Por qué? Porque he conectado los dispositivos a los mismos pines que ha conectado el libro y tendría que funcionar. 01:00:16

Creo que este programa tenía un error y es que aquí ponía, ponía un, no ponía ángulo. ¿Vale? Entonces había que poner ángulo, había que cambiar algo. Pero bueno, básicamente sí fue. 01:00:30

los otros dos montajes 01:00:42

súper rápido, el semáforo 01:00:45

que tal día tenía problemas con el semáforo 01:00:47

¿vale? me voy a por el semáforo 01:00:49

¿dónde lo tengo? 01:00:52

aquí, semáforo con código 01:00:55

bueno, vale 01:00:57

semáforo con código 01:00:59

yo lo que he hecho ha sido el montaje del semáforo 01:01:00

el montaje del semáforo queda como esto 01:01:04

¿vale? 01:01:07

tengo tres luces 01:01:09

rojo, amarillo y verde 01:01:10

rojo y verde para los peatones 01:01:12

dos luces más y un botón entre medias 01:01:14

¿vale? 01:01:16

entonces, fijaros en una cosa importante 01:01:18

el positivo, si vais 01:01:20

al libro, fijaros que el positivo 01:01:22

es el que conecta al 01:01:24

pin de señal y es el 01:01:26

negativo, el que no está doblado, el que 01:01:28

va con la resistencia, negativo 01:01:30

en este caso ha puesto la resistencia en el negativo 01:01:32

realmente da igual, yo siempre la pongo en el positivo 01:01:34

pero en el libro la he puesto en el negativo y yo 01:01:36

he mantenido la estructura del libro 01:01:38

Con lo cual, aquí veis que tengo mi resistencia de 220 ohmios, aquí tengo mi resistencia de 10 Hz, mi botón, mi montaje del botón con los dos pines del mismo lado conectados aquí, porque es el que yo conozco, la señal con su resistencia a masa y el otro a positivo. 01:01:40

Los montajes son lo mismo que hemos hecho nosotros en clase. 01:01:58

¿De acuerdo? 01:02:01

Los positivos son los que van a las señales y los negativos son los que van. 01:02:02

Bien, lo he conectado en los mismos pines porque lo que he hecho ha sido utilizar el código que viene en el libro. 01:02:07

¿Vale? 01:02:12

¿Y cuál es el código que viene en el libro? 01:02:13

Pues si lo ejecutamos, vemos que se pone el disco en verde. 01:02:15

Y cuando yo pulso el botón, espera dos segundos, cambia a amarillo, espera dos segundos. 01:02:19

Cambia a rojo y en ese momento el de peatones puede ser por el verde. 01:02:27

Ahí espera 5 segundos y vuelve a poner el de coches en verde y se queda esperando. 01:02:31

Está peatones en rojo y coches en verde y está esperando. 01:02:37

Cuando yo vuelvo a pulsar el botón, espera 2 segundos, cambia a amarillo, 2 segundos, 01:02:41

cambia a rojo sustituyendo el rojo de los peatones por verde 01:02:48

y en 5 segundos vuelve de nuevo a la configuración inicial, que es verde y rojo. 01:02:52

Ya sabemos cómo se encienden y cómo se apagan luces. 01:02:57

Ya sabemos cómo leer si el botón está pulsado o no. 01:03:01

¿Qué tengo que hacer? 01:03:04

Pues simplemente leer el valor del botón, almacenarlo en una variable y luego, si el botón está pulsado, empezar con la secuencia. 01:03:06

Apaga la luz verde. ¿La secuencia cuál es? 01:03:14

Apaga la luz verde. 01:03:16

O sea, espérate dos segundos. 01:03:18

Apaga la luz verde y enciende la luz amarilla. 01:03:20

Espera dos segundos. 01:03:23

Apaga la luz amarilla. 01:03:24

enciende la luz roja 01:03:25

apaga la luz roja 01:03:27

y enciende la luz verde de peatones 01:03:29

y ahí te esperas 5 segundos 01:03:31

y luego apagas la luz roja 01:03:33

de coches y enciendes la verde 01:03:36

apagas la luz verde de peatones 01:03:38

y enciendes la luz roja y ya está 01:03:39

y no haces nada más, toda esa secuencia 01:03:42

de enciende, apaga, espera 01:03:44

tal, no sé qué, se tiene que hacer 01:03:46

independientemente de que lo haga el botón, es decir 01:03:47

es una secuencia continua 01:03:49

y entonces cuando termine eso 01:03:50

se vuelve a terminar el programa 01:03:53

y se quedan otra vez en bucle esperando a que el botón 01:03:55

¿vale? 01:03:58

Ese sería el del semáforo. 01:04:01

¿Vale? 01:04:04

Vale, yo escribí, este es el libro, 01:04:06

este es el código que 01:04:08

viene en el libro. En el libro, 01:04:09

¿vale? Tenéis los ejercicios 01:04:11

resueltos en los, 01:04:13

en el libro, bueno, ahora os lo enseño, ¿vale? 01:04:16

Ahora os lo enseño. 01:04:19

Voy a enseñaros el último ejercicio y ahora 01:04:19

os digo dónde tenéis los programazones, no tengáis que escribirlos. 01:04:21

justo el último no lo tenéis 01:04:24

y sí que hay que escribirlo 01:04:25

el del sensor de aparcamiento 01:04:28

¿vale? el sensor de aparcamiento 01:04:30

tenemos nuestro 01:04:32

sensor de aparcamiento 01:04:34

y 01:04:36

el sensor de aparcamiento, este es el montaje 01:04:37

que viene con una luz 01:04:41

y con un sensor de distancia 01:04:43

y yo en el código 01:04:44

le he puesto el código que viene en el libro 01:04:47

lo he copiado, tal cual, el código 01:04:49

que viene en el libro, entonces 01:04:51

iniciamos la simulación 01:04:53

Y ahora, ¿qué pasa? Cuando la distancia baje de, ¿cuánto tenemos aquí? 01:04:55

Si la distancia es menor de 10 centímetros, ¿vale? A 8 centímetros coma 7, la luz se enciende. 01:05:01

¿Por qué tarda tanto? Porque tiene un delay de un segundo, es decir, pasa un segundo hasta que se enciende, ¿vale? 01:05:09

Y luego encima se apaga para luego volverse a encender. Es un poco raro, ¿vale? 01:05:15

Este programa a mí no me gusta como está resuelto. 01:05:19

Yo prefiero hacerlo por bloques. Y por bloques es muy fácil, es leer la distancia y solamente si la distancia es menor de 10, enciende la luz. Es un código que hacemos en 3 segundos. ¿Vale? Un sí y ya está. ¿De acuerdo? 01:05:21

entonces, bueno, pues este sería el de 01:05:38

sensor de aparcamiento, aquí en el 01:05:40

libro electrónico 01:05:42

y ya termino con esto, de verdad, os prometo 01:05:43

que no os quito más 01:05:47

¿vale? en el libro electrónico 01:05:49

si vamos a Blink Learning 01:05:51

en el libro electrónico, en nuestro 01:05:52

libro de tecnología 01:06:04

en la unidad 01:06:05

¿qué unidad era? la 5, era la 4 01:06:07

vale, la 4, la de 01:06:10

control y robótica 01:06:14

pues si nos vamos a la unidad 4 01:06:15

aquí 01:06:17

Aquí tenéis los programas ya hechos. Unidad 4, el programa 2, el 3, el del 4, por ejemplo, el programa del servo estaría aquí. Y si yo lo abro, tengo aquí el texto. Si os fijáis, directamente puedo cogerlo y copiarlo. ¿Vale? 01:06:19

entonces este texto es el que yo tengo que copiar 01:06:34

luego en la parte correspondiente 01:06:37

a los circuitos de Tinkercad 01:06:39

en el código, te vienes aquí 01:06:41

te vas a solo texto 01:06:42

¿vale? te coges la opción solo de texto 01:06:44

y entonces cuando te vengas a esa opción 01:06:47

te va a dar un mensaje de visión, oye que todos los bloques 01:06:49

que tengas hechos se van a perder 01:06:51

¿vale? y lo copias, lo pegas y ya está y funcionaría 01:06:53

pero yo quiero 01:06:55

que lo hagáis con bloques 01:06:56

yo quiero que me resolváis los problemas con bloques 01:06:58

¿vale? 01:07:01

no quiero que me copiéis el texto 01:07:02

que viene en el ejercicio y os 01:07:05

vayáis tan contentos. Quiero que lo intentéis 01:07:07

con bloques. Solo eso. 01:07:08

¿Vale? Yo os he dado ya los bloques. 01:07:11

Solamente mezclados. 01:07:13

¿Vale? 01:07:15

Lo tuviste que escribir. 01:07:19

A lo mejor te dejaste algún punto y coma 01:07:21

o te dejaste alguna cosita 01:07:22

que no te habías dado cuenta. 01:07:24

¿Vale? O puede ser que en el libro 01:07:26

porque a veces lo que aparecen los programas 01:07:29

que están en el 01:07:31

en el tema, con lo que viene en el libro imprimido 01:07:32

hay algún problema, ¿vale? Hay alguna cosa. Entonces, de verdad 01:07:37

Talía, no te calientes. Quiero que lo hagáis a través 01:07:41

de bloques, ¿vale? Intentar con los bloques que os he explicado hoy, que ya 01:07:45

os he dicho cómo se interactúa con cada uno de los sensores y con cada uno de los actuadores 01:07:49

hacerlo por bloques. Leer la 01:07:53

entrada de los sensores que estén involucrados y almacenéis los valores 01:07:57

en las variables. Luego hacéis una estructura condicional con sí 01:08:01

y en función de que el valor de la variable 01:08:05

leída tenga un determinado parámetro, un determinado rango 01:08:09

o tenga un determinado valor, ahí actuamos o no actuamos. 01:08:13

¿Vale? Es muy fácil. Y eso es lo que quiero que hagáis. 01:08:17

Creer una estructura con sí y una actuación 01:08:21

sobre los actuadores. ¿Vale? ¿De acuerdo? 01:08:25

Pero es muy fácil, de verdad, intentarlo y si no, el miércoles os doy la solución. Con lo que vayáis consiguiendo. Tampoco quiero que os dediquéis solo a esta asignatura, pero intentarlo un ratito, ¿vale? Y ya veréis como en cuanto cojáis el truco es súper fácil. 01:08:30

Bien, preguntas, dudas, cuestiones, alguna duda más, ahora es vuestro momento de gloria, podéis preguntarme lo que queréis. 01:08:51

Que si puedo repetir las resistencias, vale, Carla, sí, perdona, que no te había visto. 01:09:07

Las resistencias para una LED son 220 ohmios, vale, para una LED son 220 ohmios. 01:09:12

Si os fijáis, la resistencia son 220 ohmios. 01:09:22

Cuidado aquí que esté en ohmios, no en kilos. 01:09:28

¿Vale? En ohmios, no en cas, en kilohmios. 01:09:30

¿Vale? La resistencia para un botón, 10 cas, 10 kilohmios. 01:09:34

¿Vale? Y la resistencia para una LDR, yo estoy utilizando entre 2 y 5, 01:09:41

la que me funcione mejor, o 2 kilohmios o 5 kilohmios. 01:09:47

¿Vale? O dos o cinco. Uno de los dos valores. Normalmente cinco. 01:09:52

Entonces, empezar por cinco kilohmios y ver si os funciona bien y si os funciona bien con cinco kilohmios, pues lo dejamos. 01:09:57

¿Vale? 01:10:04

Entonces, esas son las tres resistencias que vais a necesitar. 01:10:06

Si no recuerdo mal, solamente eran los tres únicos elementos que utilizaban resistencias. 01:10:09

El motor, la LDR y el... ¿Vale? 01:10:13

¿Listo? 01:10:20

Bueno, pues ya vale de clase de repaso, creo que ha sido bastante intensa, 01:10:22

pero por lo menos, de verdad, no me cansaré de repetirlo. 01:10:26

Seis piezas de un puzzle. 01:10:30

Ahora, sí, dime, dime. 01:10:33

Carla, escríbela. 01:10:35

Seis piezas de un puzzle. 01:10:36

LEDs, motores y servos como dispositivos de salida. 01:10:37

Botones, LDRs y sensor de ultrasonidos como dispositivos de entrada. 01:10:43

¿Vale? 01:10:49

Y como ayuda, tenemos el monitor serie, donde yo puedo mostrar la información de las variables para indicarme, para darme una pista de por dónde van. ¿Vale? Carla, dime, en la práctica 4, ¿qué es esa cosa cuadrada negra? Vale, en la práctica 4, una cosa cuadrada negra. A ver, un segundito, que voy a verla. 01:10:49

la práctica 4 01:11:15

me voy a tecnología 01:11:18

un segundito que estoy buscando 01:11:22

el 01:11:24

vale, tenéis 01:11:25

ahora deberíais estar viendo mi 01:11:37

mi Acrobat Reader, vale 01:11:39

lo estáis viendo, estáis viendo 01:11:46

estáis viendo mi 01:11:47

PDF en el ejemplo 01:11:50

de la foto, vale, en la práctica 4 01:11:54

es esto 01:11:56

este es el montaje que viene en la práctica 4 01:11:57

¿no? 01:12:00

entonces 01:12:00

esto de aquí, esto cuadrado 01:12:03

grande es el servo 01:12:06

¿ves que pone ahí servo? el micro servomotor 01:12:07

este cuadrado grande 01:12:09

es 01:12:11

ese cuadrado grande 01:12:12

es el servo que tiene tres patillas 01:12:18

la patilla de señal 01:12:20

la del positivo y la del negativo 01:12:21

¿vale? y este otro es el 01:12:23

LDR ¿cómo se ve eso en 01:12:26

Tinkercad? porque no lo veía el otro día 01:12:30

¿vale? pues mira, en Tinkercad 01:12:32

lo tienes aquí. Esa práctica, a ver, lo voy a poner uno al lado del otro para que lo veáis 01:12:34

y así yo lo tengo aquí hecho. Este es el del servo, ¿vale? Este es el micro servomotor. 01:12:39

Entonces, fíjate, te voy a poner los dos uno al lado del otro, ¿vale? A ver un segundito 01:12:48

que voy a intentar visualizarlo todo junto. Ahí lo tienes este y ahí tienes el otro, 01:12:59

Entonces fíjate que yo tengo la LDR, aquí está mi LDR con mis dos patillas 01:13:08

La patilla de la izquierda, esta está mal, por cierto, esto va al positivo, por eso es roja 01:13:19

¿Veis? Va al positivo 01:13:26

Y esta, que es la resistencia, va al negativo, que es al menos 01:13:27

Esta va al negativo, ahí lo tenéis, lo voy a acercar ahí 01:13:33

Ahí lo tenéis 01:13:37

¿vale? y luego 01:13:40

el servo, que es este, el micro 01:13:42

servomotor, el que hemos utilizado 01:13:44

el pin de señal 01:13:45

va al 9, que es el amarillo 01:13:48

ahí lo tienes 01:13:50

el pin de señal, que es el 01:13:52

amarillo, va al 9 01:13:54

el pin rojo, que es el de 01:13:55

VCC, va a positivo 01:13:58

y el pin negro 01:13:59

va a 01:14:02

ya estaría, ¿vale? 01:14:03

entonces tengo el mismo montaje 01:14:07

si te fijas en TinkerCAD se ve así 01:14:09

¿vale? porque el servomotor en vez de tener 01:14:10

esta forma tan de bloque, tiene 01:14:12

una forma de micro servomotor real 01:14:14

¿vale? los nuestros se parecerían mucho a estos 01:14:16

si los utilizáramos en clase 01:14:18

¿de acuerdo? 01:14:21

y así es como se ve 01:14:22

venga, más preguntas 01:14:23

que tengáis, que hayáis tenido problemas 01:14:28

al montar los motores o las cosas 01:14:30

¿vale? cuidado con 01:14:32

este que sí que es verdad que este dibujo 01:14:34

¿vale? aquí es un poco confuso porque 01:14:36

está conectado al negativo 01:14:38

y no es tan... es rojo, ¿vale? 01:14:40

Esto va conectado al positivo. 01:14:42

O sea, esto va hasta abajo. 01:14:43

Y está conectado a la franja de los positivos. 01:14:45

¿Vale? Que es como yo lo he conectado aquí. 01:14:48

¿Lo veis? Que está conectado en la franja de abajo al positivo. 01:14:50

Eso es... hay que tener cuidado con eso. 01:14:54

¿Vale? ¿Más cosas? 01:14:56

¿Nada más? 01:15:00

Vale, pues lo damos por concluido. 01:15:01

Terminamos aquí la clase. 01:15:03

El del semáforo sigue sin entender mucho el código. 01:15:04

El código no lo tienes que entender. 01:15:07

¿Vale? 01:15:09

el código, no 01:15:09

lo tienes que entender 01:15:11

el código ese es un rollo, ¿vale? 01:15:13

yo no quiero que entendáis el código, no estamos 01:15:15

programando un código, quiero que programemos 01:15:17

la cosa negra al lado del servo 01:15:19

que es, a ver, esperad un segundito 01:15:21

esto, este es el conector 01:15:23

del servo, es un conector negro 01:15:25

que tiene las tres pines, ¿vale? 01:15:27

esto pertenece todo al servo, fíjate que yo 01:15:29

lo puedo mover y es un bloque, ¿vale? 01:15:31

¿lo veis? 01:15:33

no es nada, solamente es 01:15:35

las conexiones del semáforo. 01:15:37

Vale. 01:15:40

Me devuelvo contigo, Tania. 01:15:41

El semáforo, ¿vale? 01:15:43

El semáforo, no os calentéis. 01:15:45

Iros al semáforo, ¿vale? 01:15:48

¿Dónde lo tengo mi semáforo? 01:15:50

Aquí. 01:15:52

Modificar. 01:15:54

Cuando vengáis al semáforo, 01:15:58

no os vayáis 01:16:00

a la parte de 01:16:01

código. 01:16:03

Cambiaros aquí, 01:16:06

a bloques. Me dice que voy a perder el código, 01:16:08

vale, entonces, voy, perdón, vuelvo a bloques aquí, vale, elimino mis bloques y entonces, ¿cómo resolvemos, Talía, cómo resolvemos esto? 01:16:10

Pues lo primero que tengo que hacer es leer el botón y el botón, si te fijas, lo estoy leyendo en el pin 6, por lo tanto, me creo una variable que se llame botón, vale, 01:16:22

y entonces le defino el botón, lo que reciba del pin digital donde lo tengo conectado, que es el 6. 01:16:35

Y hacemos con la pieza del botón la lectura del sensor. 01:16:45

Ahora, en función de lo que esté leyendo, tengo que tomar decisiones. 01:16:51

¿Qué decisiones tomo? Pues muy fácil, me voy a control, sí. 01:16:54

Siempre una decisión la tomo a través de la estructura, sí. 01:16:57

Y ahora tengo que hacer una comparación. 01:17:01

Si el botón está en posición High, en alta, quiere decir que está pulsado. 01:17:02

Con lo cual aquí tengo que meter todos los bloques que suponen la secuencia de encender y apagar y esperar las luces. 01:17:16

Y si no, lo que voy a hacer es, voy a poner el pin de la luz verde, que es la 10, el verde encendido, pero fíjate que me tengo que asegurar que los otros dos estén apagados, para no dejarme ninguna luz encendida. 01:17:23

con lo cual el amarillo que está en el 11 tiene que estar apagado, y el 12 tiene que estar también apagado. 01:17:48

Entonces, el verde encendido y los otros dos apagados, y en el caso de los peatones, ¿qué tengo que poner? 01:18:02

Tengo que poner el 4, que es el rojo, en alta y el verde, que es el 3, en baja, ¿vale? 01:18:10

Con lo cual, fijaros, en este semáforo, cuando haga el botón, ¿vale? 01:18:29

Cuando se actúe luego sobre el botón, no le voy a hacer nada. 01:18:39

pero estoy leyendo el botón 01:18:45

si el botón está pulsado 01:18:47

tiene que hacer toda la secuencia 01:18:49

a base de encender y apagar luces 01:18:50

y hacer pausas entre medias 01:18:53

que eso es lo que tenéis que hacer vosotros 01:18:55

y si no, simplemente me lo va a poner 01:18:56

el verde de los coches 01:18:58

encendido y el amarillo y el rojo 01:19:00

apagados y el rojo 01:19:03

de los peatones encendido 01:19:04

entonces si yo le doy a iniciar simulación, fijaros 01:19:06

¿veis? 01:19:08

se me enciende el verde y se me enciende el rojo 01:19:10

esa es la 01:19:12

funcionamiento por defecto. Ahora, si pulso el botón, voy a hacer una cosa que no es 01:19:13

lo que hay que hacer, que es apagarlos, ¿vale? Simplemente para que veáis que funciona. 01:19:21

Voy a apagar el pin 10, que es el verde de los coches. Voy a apagar el pin 4, que es 01:19:28

el rojo de los peatones. Y aquí me voy a esperar un segundo, ¿vale? Con lo cual, cuando 01:19:41

yo pulse el botón, ¿qué va a ocurrir? Se van a apagar las luces, va a esperar un segundo 01:19:49

y luego va a volver a su estado normal que es encendido. Fijaros, ahí está. El semáforo 01:19:53

está en verde y el de peatones en rojo. Cuando yo pulso, se apaga un segundo y vuelve a su 01:20:00

estado normal que es encendido, ¿vale? Si en vez de apagarlo, simplemente hacéis toda 01:20:06

la secuencia de apaga el verde y enciende 01:20:10

el amarillo. Apaga el amarillo y espera. 01:20:12

Apaga el amarillo y enciende el rojo. 01:20:14

Además, apaga el rojo 01:20:17

y enciende el verde de peatones. Y espera. 01:20:18

Y después, vuelve a 01:20:21

al final de todo eso, 01:20:22

tenéis el programa del semáforo que hay 01:20:24

que hacer. Tan fácil como eso. 01:20:26

¿Vale? Así sería. 01:20:29

Sí, lo estoy grabando. 01:20:33

¿Vale? También. Entonces, quiero que lo hagáis 01:20:35

con bloques. De verdad, quiero que los programas los hagáis 01:20:36

con bloques. Lo primero, utilizar 01:20:38

las piezas. Aquí quedó utilizado 01:20:40

cinco piezas de LED 01:20:41

y una pieza de botón. 01:20:43

¿Vale? 01:20:46

Y luego, a través de la programación, 01:20:48

mezclas 01:20:51

la lectura del botón 01:20:51

con la actuación sobre la LED 01:20:54

en la función que yo quiera. 01:20:56

¿Vale? 01:20:58

Venga, que esto ya se está alargando mucho. 01:20:59

Más preguntas. 01:21:02

No quiero dejaros con preguntas en el aire. 01:21:03

Venga. 01:21:05

Más preguntitas que tengáis. 01:21:06

Alguna cosa, alguna duda. 01:21:13

ya veis que no es, de verdad, cuando le cojáis el truco 01:21:15

va a ser súper fácil, pero lo importante es que 01:21:18

por eso he perdido tanto tiempo 01:21:20

cada pieza, sepáis cómo funciona 01:21:21

cómo leo los sensores y cómo 01:21:23

actúan los actuadores 01:21:26

y luego simplemente pensando un poquito 01:21:27

y con la función sí, tomo las decisiones 01:21:29

¿vale? 01:21:32

¿no hay más preguntas? pues venga 01:21:37

entonces lo vamos a dejar aquí 01:21:39

¿vale? 01:21:42

espero que haya sido 01:21:45

espero que haya sido de ayuda 01:21:46

espero que todo esto os sirva 01:21:47

para intentar coger un poco 01:21:50

de ritmo, ya sé que ha sido una clase 01:21:52

larga esta y un repaso 01:21:54

largo pero yo creo 01:21:56

que queda claro un poquito 01:21:58

lo que espero 01:22:00

y de verdad que es 01:22:01

súper fácil, ya sé que 01:22:03

me repito mucho con esto de que es fácil pero es que es verdad 01:22:06

es que es fácil 01:22:08

son cuatro cosas y juntarlas 01:22:09

no es muy complicado, lo que pasa es que 01:22:12

hay que practicarlo, si se practica un poquito 01:22:14

no vais a tener ningún problema, damos por concluida 01:22:16

pues la clase, alguien más tiene algo que decir, que levante la mano 01:22:20

que diga algo por el chat o si no, terminamos 01:22:23

y lo damos por concluido y ya el miércoles 01:22:27

pues resolveremos todas las dudas 01:22:29

y preguntas, me tenéis disponible de todas formas en el 01:22:32

correo, o sea que cualquier cosa que tengáis me lo decís 01:22:36

en Tinkercad, me compartís los 01:22:38

proyectos y yo los puedo ver, vale, y entonces os puedo decir 01:22:41

lo que está bien, lo que está mal, nada más pues 01:22:45

pues nada, chicos, muchas gracias 01:22:50

a los que habéis estado 01:22:52

y nada, eso, que 01:22:53

suerte, ¿vale? con 01:22:56

los proyectos, venga 01:22:58

chao, chao 01:22:59

Bloques básicos en TinkerCAD para programación de robots - Contenido educativo

Del mismo autor…

Navidad 2

Navidad 1

Villancico en Inglés

Festival

Teatro: "Quiero ser como tú"

Actuación Festival Navidad 2025

PRIMER TRIMESTRE 2C

Comentarios