Sesión 3: extendiendo las aplicaciones prácticas de Micro:bit (y Maqueen)

Lope González Vázquez > ESO y Bachillerato > Curso intermedio de pensamiento computacional, robótica e internet de las cosas > Sesión 3: extendiendo las aplicaciones prácticas de Micro:bit (y Maqueen)

Currículo: aquí encontrarás el desarrollo detallado de los contenidos que forman parte del Curso de pensamiento computacional, robótica e internet de las cosas, organizado por el CEP de Huelva – Isla Cristina.

Tabla de contenidos

1. Introducción

El uso de Scratch como herramienta de introducción a la programación tiene múltiples beneficios para el entrenamiento del pensamiento computacional, como pudimos comprobar en la sesión anterior. 

Sin embargo, cuando tenemos que practicar con robots, Scratch presenta serias limitaciones:

  • Su diseño se centra más en la animación y los juegos, lo que limita su aplicabilidad en el control de hardware y proyectos de robótica más complejos.
  • Scratch no está diseñado para interactuar directamente con componentes de hardware como sensores y actuadores, elementos fundamentales en la robótica.

Por todo ello, es necesario buscar otra herramienta que nos permita satisfacer nuestras necesidades de aprendizaje, especialmente ahora que queremos comenzar a programar robots.

El robot con el que se suele iniciar esta fase se llama Maqueen, y suele controlarse con una de las mejores placas educativas, la Micro:bit, utilizando la plataforma de programación Microsoft MakeCode.

Esta combinación de tecnologías es muy adecuada para la educación secundaria, pero si tu trabajo con la robótica se inicia a edades más tempranas, existen otras soluciones más adecuadas como estas:

  • Beebot: es un punto de partida excelente para iniciarnos en el lenguaje direccional y la programación, con el que es posible crear actividades interdisciplinares basadas en el juego. Ver precio >
  • Escornabot: es un proyecto con filosofía abierta que pretende acercar la robótica y la programación a los niños. Se parece a Beebot pero con la diferencia de que tú construyes el robot desde cero. Cómo conseguirlo >
  • Makey Makey: es más «robótico» que los anteriores y empieza a profundizar en los conocimientos electrónicos necesarios para construir proyectos con cables, sensores y otros componentes complementarios. Ver precio >

Siguiendo con nuestra hoja de ruta establecida, veamos por qué elegimos esta plataforma de programación con Micro:bit.

2. MakeCode

¿Por qué usamos Microsoft Makecode?

Por muchos motivos, pero quizás los más importantes son:

  • MakeCode ofrece soporte integrado para Micro:bit, permitiéndonos programar y controlar directamente el coche Maqueen. Esta compatibilidad es vital para proyectos de robótica aplicada.
  • MakeCode proporciona una transición suave desde una interfaz basada en bloques (similar a Scratch) a la codificación en lenguajes más avanzados como Python, facilitando así el desarrollo progresivo de habilidades de programación. 
  • A través de MakeCode, podéis aprender cómo la programación se traduce en acciones físicas, controlando motores, luces, sensores y otros componentes del robot Maqueen.
  • Al trabajar con MakeCode y Maqueen, no solo aprendéis a programar, sino que también comprendéis los principios de ingeniería que subyacen en la robótica, como el control de sistemas, la automatización y la interacción con el entorno.
  • La programación de un dispositivo físico como el Maqueen presenta dificultades y situaciones impredecibles, lo que nos estimula a pensar de forma crítica y a resolver problemas de manera creativa.

Seguramente, ya conozcas la interfaz del programa, pero nunca está de más refrescar la memoria. 

Accedemos a Makecode y pulsamos en Nuevo proyecto (si quieres guardar tu proyecto, debes registrarte e iniciar sesión).

Esto es lo que obtenemos:

El entorno de programación tiene cuatro partes muy bien diferenciadas:

  • Flecha azul – Nuestro programa: aquí iremos situando cada uno de los bloques que nos interesen para ir construyendo nuestro programa.
  • Flecha verde – Bloques: estos son todos los tipos de bloques que hay disponibles. Cuando pulses sobre uno de ellos, te aparecerán todos los bloques que forman parte de esa categoría.
  • Flecha roja – Simulador: conforme vayamos creando nuestro programa, esa Micro:bit virtual irá reaccionando a las órdenes que le hayamos dado en nuestro programa. No lo vamos a necesitar, así que puedes dejarla parada pulsando el botón de Stop (el primero por la izquierda).
  • Flecha morada – Descarga: en esta sección, podemos cambiar el nombre a nuestro proyecto, descargar nuestro programa en el ordenador, o directamente descargarlo a la Micro:bit. 

Si te fijas, existen muchos tipos de bloques en la herramienta, pero ninguno de ellos hace referencia al robot Maqueen. DEBEMOS INSTALAR UNA EXTENSIÓN. Para ello, pulsamos en el botón Extensiones que se indica a continuación:

En ese momento se nos abrirá la página de extensiones de Makecode:

En la parte superior (escribimos Maqueen), donde indica la flecha roja. Y seguidamente, pulsamos en la lupa que se indica con la flecha verde.

Verás que aparecen varias extensiones. La que aparece rodeada de amarillo es la que nos interesa. Así que pulsamos sobre ella, y ya nos aparecerán los bloques para poder programar nuestro robot Maqueen.

Ya tienes todo lo necesario para poder crear programas que controlen tu robot.

Pero, ¿cómo será capaz el robot de leer las instrucciones de nuestro programa?

Los robots tienen en su interior un componente electrónico que se encarga, precisamente de esta tarea: de leer un programa escrito por un programador, interpretarlo y enviar al robots las órdenes necesarias para controlarlo, por eso se llama placa controladora.

3. Micro:bit

Una placa controladora Micro:bit es un dispositivo de hardware programable diseñado para introducir a las personas en el mundo de la robótica e internet de las cosas. Es una placa pequeña, equipada con una variedad de sensores y actuadores, como luces LED, botones y sensores de movimiento. Nos permite crear proyectos interactivos, desde simples juegos hasta sistemas de control para dispositivos más complejos.

Este es un esquema de sus componentes:

Su uso básico ya lo conoces, porque has trabajado con ella o la has visto en el curso de introducción a la robótica, así que pasemos al tercer y último elemento de nuestras tecnologías, el robot Maqueen.

4. Maqueen

Se trata de un pequeño robot móvil fabricado por la empresa china DFRobot, cuya placa controladora es una tarjeta Micro:bit.

Este pequeño robot, parece simple pero incorpora todos estos elementos.

Sensores

  • Diodo LED infrarrojo IR para telemando (P16).
  • 2 diodos LEDs infrarrojos por reflexión para detectar el color blanco y negro (P13 – P14).
  • Sensor de ultrasonidos para medir la distancia a un objeto (P1 – P2).
  • A estos hay que sumar los que proporciona la Micro:bit, como los sensores de sonido, temperatura, etc.

Actuadores

  • 2 motores con reductoras de engranajes y regulación de velocidad (0 a 255).
  • 2 diodos LEDs de color rojo (P8 – P12).
  • 4 diodos neopixel (P15).
  • Zumbador (buzzer) pasivo (P0).
  • A estos hay que sumar los que proporciona la Micro:bit, como la matriz de 25 diodos LEDs.

Conectores

  • Para la tarjeta Micro:Bit.
  • Para el portapilas.
  • Para pines 0, 1 y 2. El funcionamiento de los pines 1 y 2 es incompatible con el
  • sensor de ultrasonidos.
  • Para 2 microservos (S1 y S2). Su funcionamiento es incompatible con el sensor
  • de ultrasonidos.
  • Pines 0, 1, 2, 3V (+) y GND (-), en la parte trasera para conectar pinzas de
  • cocodrilo.
  • Para bus I2C que permite ampliar los sensores y actuadores.

Interruptores

  • Interruptor general.
  • Interruptor para el zumbador.

Alimentación eléctrica

  • 3 pilas de 1,5 V tipo AAA.

Esta es la localización de cada uno de esos elementos:

Bueno, ahora que ya hemos refrescado la memoria sobre qué elementos forman cada uno de nuestros componentes, vamos a empezar a extender su uso, para aplicarlos al campo de la robótica primero, y del IoT básico después.

5. Proyectos

A continuación, encontrarás una variedad de proyectos que nos permitirán profundizar en lo que ya conocíamos, de manera incremental; así que partamos de lo básico, para ir complicando un poco más nuestras tareas.

Si un proyecto te parece demasiado fácil, tienes libertad para saltar a otro que consideres ajustado a tu nivel actual.

5.1. Entendiendo a los LEDS

Empezaremos aprendiendo cómo programar el encendido y apagado de un LED usando Microbit y Makecode.

🛠 Materiales:

Existen muchos tipos de LED, pero los que nosotros vamos a utilizar con fines pedagógicos son estos:

Si te fijas, está formado por una pequeña bombilla que se enciende cuando recibe corriente, y se apaga cuando no la recibe. Tiene, por lo tanto, dos estados: encendido -si recibe corriente- y apagado -si no recibe corriente-.

Además, observa cómo tiene dos patillas de distinta longitud:

  • La pata larga se llama ÁNODO y representa al positivo, es decir, a donde tenemos que enviar la corriente.
  • La pata corta se llama CÁTODO y representa al negativo, es decir, a donde tenemos que conectar la toma de tierra.

Recuerda, que para que la corriente circule, debe haber una diferencia de potencial, de manera que la corriente fluirá de un nivel alto de energía (el positivo) a un nivel bajo (el negativo o tierra/GND).

Conociendo todo lo anterior, vamos a ver cómo podemos usar una placa Micro:bit para controlar el encendido del LED.

Como nosotros siempre vamos a utilizar nuestra Microbit con el cable USB, será ese mismo conector el que proporcionará energía a la placa.

Esos tres pines que ves rodeados de rojo, son los que utilizaremos para conectarle otros dispositivos a la placa, como por ejemplo un LED, y a través de ellos enviaremos señales eléctricas controladas por nuestros programas.

Así, podremos hacer que nuestro programa ordene enviar una señal eléctrica al pin 0, y el dispositivo que esté conectado a ese pin recibirá esa corriente eléctrica.

Además, el último pin, etiquetado como GND, es el pin de tierra, el negativo.

Con lo que ya sabes de electrónica, puedes intuir cómo funcionará nuestro circuito: conectaremos la patilla larga del LED al pin 0, y la patilla corta al pin GND. 

Debes ser cuidadoso y evitar que dos componentes metálicos se toquen.

Ahora sólo nos quedaría escribir un programa con Makecode, para que envíe corriente al pin 0 cuando se encienda la placa.

Si pulsas sobre Avanzado y luego Pines, verás un conjunto de bloques destinados a trabajar con los pines de la Microbit:

Como nosotros queremos enviar una señal digital -recuerda que el LED solo tenía dos estados-, usaremos el bloque que aparece seleccionado. 

Lo único que debes hacer es seleccionar el pin al que has conectado el cable de corriente (el que va al ÁNODO del LED) y decirle qué valor quieres enviarle:

  • 1 significa enviar corriente -esto encenderá el LED-.
  • 0 significa no enviar corriente -esto apagará el LED-.

Si cargas ese programa en la placa, verás cómo el LED se enciende.

Bueno, no ha estado mal, pero nuestro proyecto no es nada de otro mundo. Vamos a ir un poco más allá, ya que sabemos programar los botones de la placa.

Vamos a mantener nuestro circuito tal y como está, y lo que vamos a programar ahora es lo siguiente:

  • Al iniciar el programa, se mostrará en la placa una carita sonriente, y el LED se encenderá.
  • Si pulsamos a la vez los botones A+B, se mostrará en la placa una carita triste, y el LED se apagará.
  • Si pulsamos el botón A, se mostrará en la placa el corazón grande, y el LED se encenderá y apagará 5 veces. La duración entre cada encendido y apagado será de 200ms.
  • Si pulsamos el botón B, se mostrará en la placa el corazón pequeño, y el LED se encenderá y apagará 5 veces. La duración entre cada encendido y apagado será de 1s.

Aquí tienes el código que consigue realizar esta rutina:

Se supone, que con la experiencia que tienes de programación y lo que has aprendido hasta ahora, deberías saber interpretar el código.

Pruébalo y asegúrate de que funciona. Si no entiendes algo, pregunta al ponente.

Ahora que ya sabes cómo funcionan los LEDs usando una placa Micro:bit, te propongo la siguiente modificación 👇

  • Modifica el circuito para conectar tres LEDs a la placa: un LED rojo, otro verde y otro amarillo.
  • Cuando la placa se encienda, todos deben permanecer apagados.
  • Si pulsamos el botón A, se encenderá el LED rojo durante 2s.
  • Si pulsamos el botón B, se encenderá el LED verde durante 3s.
  • Si pulsamos los botones A+B, se encenderá el LED amarillo durante 1s.

5.2. Lámpara inteligente

🛠 Materiales:

En la práctica anterior aprendimos cómo podíamos encender y apagar un LED del color que habíamos elegido: rojo, verde o amarillo.

Pero existe un tipo especial de LED que nos permite encenderlo y hacer que brille con la luz que nosotros queramos: el LED RGB.

¿Qué significan las siglas RGB?

R: Red -Rojo-

G: Green -Verde-

B: Blue -Azul-

Esto quiere decir que, podemos crear cualquier color que queramos realizando una mezcla de esos tres colores.

Además, no debes perder de vista que, estamos trabajando con luz, con lo cual cada uno de esos tres canales (rojo, verde y azul) pueden tener diferentes intensidades. Por ejemplo, tomando el canal del rojo:


Rojo al 25%
Rojo al 50%
Rojo al 75%
Rojo al 100%

De la misma manera podemos hacer con el verde y el azul.

Concretamente, de cada canal, tenemos 256 posibles valores, que varían del 0 al 255.

Así, podemos abrir un configurador de color como este: Google Color Picker, y utilizar sus valores RGB para construir colores:

Como ves, el naranja de aquí arriba, se ha construido aportando a la mezcla 255 de rojo (el máximo), 128 de verde (la mitad) y 0 de azul (nada).

Así, variando la cantidad de cada canal, puedes obtener el color que quieras. O también, a la inversa, podrías utilizar el selector de color y observar los valores RGB para ver qué cantidad de rojo, verde y azul te llevan a ese color.

Sabiendo todo lo anterior, ya tienes la base suficiente para poder programar este LED RGB:

Si te fijas bien, ese LED tiene 4 patillas. Tres de ellas te indican qué canal RGB representan, y la cuarta es la que conectamos a tierra.

Bueno, nuestro circuito está terminado.

Ahora veamos cómo podemos hacer para que al encenderse la placa, nuestro LED emita un color RGB aleatorio.

Elegir un color aleatorio supone, mezclar una cantidad aleatoria de rojo, una cantidad aleatoria de verde y una cantidad aleatoria de azul.

Y como el LED tiene una patilla para el rojo, otra para el verde y otra para el azul, nuestro problema se reduce a enviar una señal eléctrica al pin que hemos conectado la patilla roja (pin 0 en nuestro dibujo), otra señal al pin que hemos conectado la patilla del verde (pin 1 en nuestro dibujo) y otra señal al pin que hemos conectado la patilla del azul (pin 2 en nuestro dibujo).

⚠️ Pero aquí surge un gran problema. 

Cada canal de color puede variar entre 0 y 255, pero nuestro bloque de escritura digital -el que conocíamos de la práctica anterior-, sólo nos permite meter dos valores 0 o 1.

¿Qué hacemos?

No podemos usar un bloque de escritura digital. Tenemos que usar un bloque de escritura analógica.

⚠️ Y aquí surge nuestro segundo problema: el bloque de escritura analógica puede recibir 1024 valores -del 0 al 1023-, pero ¡yo necesito 256 valores -del 0 al 255-!

¿Cómo podemos resolver esto? 

Para estos casos, Makecode nos ofrece un bloque llamado MAP, que se encarga de cambiar de escala de valores.

Espera, espera, ¿qué significa eso?

Significa que nos permite convertir un rango de valores de 0 a 1023, a otro de 0 a 255.

Para que lo entiendas: supongamos que estamos organizando un viaje y tenemos que meter a 100 personas en 5 autobuses. Las tenemos que meter de forma aleatoria porque todas quieren ir en el mismo autobús. Metemos en una caja 100 papeletas -del 1 al 100- y les decimos a cada una que coja una papeleta. Si sacan una papeleta entre el 1 y el 25, irán en el primer autobús; si sacan una papeleta entre el 26 y el 40, irán en el segundo autobús; y así sucesivamente hasta que se completen los 5 autobuses:

En Makecode esto se haría así:

En nuestro caso, lo que queremos es meter a 1024 personas en 256 autobuses, es decir, cambiar una escala que va de 0 a 1023, a otra de va de 0 a 255.

Así que, a cada canal de color – a cada pin- debemos enviar:

Si hacemos esto con cada canal, nuestro programa quedaría:

De esta manera, tenemos una lámpara inteligente que va cambiando aleatoriamente de color cada medio segundo.

Si además al LED lo metemos en una pelota de ping-pong 🏓, el efecto es aún más bonito❤️:

Pruébalo y asegúrate de que funciona. Si no entiendes algo, pregunta al ponente.

Ahora que ya sabes cómo funcionan los LED RGB usando una placa Microbit, te propongo el siguiente desafío 👉 modifica el código de tu circuito para que el LED muestre -durante 3s- estos colores cuando se pulsen los siguientes botones.


Al pulsar el botón A
Al pulsar el botón B
Al pulsar los botones A+B

Las tonalidades pueden ser aproximadas (puedes apoyarte en la herramienta que vimos al principio para descubrir la cantidad de cada canal necesaria para llegar a esos colores).

5.3. Moviendo un servomotor

En esta ocasión vamos a aprender a controlar un servomotor de manera automática para construir un indicador de ruido en el aula.

🛠 Materiales:

Un servomotor es un tipo especial de motor que puede moverse a una posición específica y mantenerse en ella.

A diferencia de otros motores que simplemente giran sin control, el servo sabe exactamente cuánto y en qué dirección debe girar. Esto se consigue mediante una señal eléctrica que le enviamos, y que le indica en qué posición debe estar.

Piensa en una barrera como la que te encuentras en los aparcamientos de cualquier ciudad. La barrera está en horizontal (no recibe corriente) cerrando el paso a los vehículos. Cuando un vehículo llega, el conductor introduce una tarjeta y la barrera se abre (recibe corriente). Se queda en vertical el tiempo suficiente para que el vehículo pase. Cuando detecta que el vehículo ha pasado, vuelve a cerrarse volviendo a su posición original (deja de recibir corriente). Esta barrera si la construyéramos en casa con cartón y un pequeño listón de madera, podría estar conectada a un servo motor que recibe señales de una placa Micro:bit.

Los servos necesitan energía para moverse.

Si te fijas, el servomotor tendrá un pequeño conector negro con tres cables: uno marrón (o negro), otro rojo y otro naranja (también puede ser amarillo o blanco). Para que funcione, asegúrate de conectarlo a una fuente de alimentación adecuada. A veces, la Micro:bit por sí sola no es suficiente, y podría necesitar una fuente de energía externa. Para ello utiliza el pin que conecta con el cable rojo (+). El marrón lo usaremos para conectar la tierra (-) y el naranja para enviarle señales eléctricas para que cambie su posición.

Es importante que no cometas errores conectando los cables, puesto que conectarlos al revés puede dañar el dispositivo y dejarlo inservible.

Cuando hablamos de la «posición» de un servo, nos referimos a un ángulo. La mayoría de los servos comunes pueden moverse desde 0º hasta 180º. Si lo piensas es como un abanico que se abre y se cierra.

Antes de montar el servo en tu proyecto, es una buena práctica centrarlo (ponerlo en 90º) usando MakeCode. Esto te permitirá saber cuál es la posición neutral del servo y asegurarte de que se mueve como esperas. 

Además, comprueba siempre que el servo pueda moverse libremente a lo largo de su rango de movimiento. Evita que choque con otros componentes o partes de la interfaz de tu dispositivo.

Por último, ten cuidado al conectar cables a los pines. Asegúrate de que las conexiones sean firmes, porque las flojas pueden causar comportamientos inesperados.

Ha llegado la hora de integrar todos nuestros componentes aplicando los conceptos que hemos aprendido a lo largo del proyecto.

El primer elemento que debemos considerar es la placa controladora. De todo lo que hemos visto, sabemos que la placa debe recibir corriente eléctrica (establecer un camino de ida para los electrones) y también debe conectarse a tierra (establecer un camino de vuelta para los electrones). Esto podemos hacerlo de dos maneras diferentes:

  • Podemos dejar libre el pin de 3V de la placa y alimentarla con el cable USB.
  • Podemos utilizar el pin de 3V de la placa y no alimentarla con el cable USB.

Es una elección de diseño que debéis realizar vosotros. Pero con cuidado, porque en función de la distribución que elijáis, las conexiones ser realizarán de una manera distinta.

En cualquier caso lo que sí sabemos es que debemos conectar el cable de tierra al pin GND de la placa.

Además, debemos elegir entre los pines 0, 1 y 2, en cuál de ellos vamos a conectar el servo motor para enviarle instrucciones.

En todos los casos anteriores utilizaremos cables de cocodrilo, ya que nos facilitan la tarea de conectar y desconectar componentes de forma rápida.

Por tanto, en este punto de nuestro montaje podríamos tener un esquema parecido a este:

Del servomotor sabemos que tiene disponible tres pines: uno para recibir alimentación (el rojo), otro para conectarlo a tierra (el marrón o negro) y otro para recibir señales eléctricas y saber qué tiene que hacer (cable amarillo, naranja o blanco).

Además, los cables de cocodrilo no los podemos conectar directamente a los pines hembra del conector del servo, así que debemos recurrir a los cables Dupont.

Ahora sólo nos quedaría conectar correctamente los cables de cocodrilo de la Micro:bit a los cables Dupont para insertarlos en los pines del servomotor. Hazlo con cuidado y asegurándote de que las conexiones quedan firmes.

Llegados a este punto tendríamos nuestro circuito montado con los dos componentes principales. Este es un esquema conceptual de cómo quedaría hasta ahora:

Ten en cuenta que este montaje es un ejemplo conceptual, tú debes tomar tus propias decisiones y elegir el montaje que creas que mejor se ajusta a tus necesidades.

Y no olvides que debes aportar energía al circuito de alguna manera que debes elegir tú: usando el cable USB de la Micro:bit o utilizando un portapilas o una combinación de ambos.

Asumiendo que tu circuito está correctamente conectado, llega el momento más emocionante de todo: hacer que la placa hable con el servo.

Para eso hemos aprendido a programar, así que manos a la obra.

Antes de comenzar a construir nuestro programa, debemos activar una extensión específica para servomotores. Así que, nos dirigimos al panel de bloques, pulsamos sobre Extensiones y seleccionamos la que se llama Servos. Una vez hecho esto, ya tendremos nuestro panel de bloques para servo motores disponible:

Lo primero que debe hacer la placa con el servo (si lo recuerdas) es decirle que vamos a comunicarnos usando el Pin 0 (podrías usar el 1 o el 2 si quisieras) y que se sitúe en un ángulo de 90º cuando se inicie el programa. Para ello, podemos usar estos bloques:

Nuestro programa ha comenzado, hemos establecido la comunicación entre los dos componentes y hemos colocado el servo donde nos interesa. Ahora, y de manera indefinida (bloque para siempre), debemos ir comprobando el nivel de sonido que llega al sensor de la placa e ir moviendo el servo en consecuencia. 

De momento, no sabemos cómo leer el nivel de sonido, pero lo que sí sabemos es que nuestra interfaz queremos que tenga tres niveles: verde (ruido normal), amarillo (ruido un poco alto) y rojo (ruido demasiado alto). Para ello podemos establecer una estructura condicional que sitúe el servo en las tres posiciones que nos interesan (revisa el apartado dedicado al servo motor si no recuerdas cuántos grados de giro tiene el servo):

Ahora sólo quedaría, indicar correctamente las condiciones. Si nosotros arrastramos al área de programación el bloque nivel de sonido, observamos que sobre la placa aparece una barrita que nos permite mover el nivel de ruido que en cada momento está recibiendo el sensor. Si te fijas, el nivel mínimo de ruido es 0 y el máximo 255. Sabiendo esto podemos decidir:

  • Si el nivel de sonido es inferior a 100, consideramos que el ruido es asumible (zona verde de nuestra interfaz).
  • Si el nivel de sonido está entre 100 y 150, consideramos que el ruido empieza a ser alto (zona amarilla de nuestra interfaz).
  • Si el nivel de sonido es superior a 150, consideramos que el ruido es demasiado alto (zona roja de nuestra interfaz).

Tomadas las decisiones anteriores, solo nos queda trasladar las condiciones a los bloques:

Observa cómo funciona el servo cuando modificas los valores de sonido. Ten en cuenta que es posible que necesites colocar el servo de una manera u otra para que las indicaciones sean coherentes con tu interfaz y con el nivel de sonido que se está detectando en cada momento.

Si ahora pegas una flecha de cartón a la pala del servomotor y construyes una interfaz bonita, tienes un indicador de ruido en el aula, como este:

5.4. Tiempo de reacción

En esta ocasión construiremos un juego que, utilizando la conductividad eléctrica de nuestro cuerpo, nos permitirá calcular el tiempo de reacción de dos jugadores para ver quién es el más rápido de la clase.

🛠 Materiales:

La instalación de nuestro circuito es muy sencilla. Conectaremos todos los componentes tal y como aparecen en la imagen, teniendo en cuenta que los 4 rectángulos blancos deben estar cubiertos con papel de aluminio.

Como puedes ver conectaremos la zona de INICIO con un cable hasta el pin P0 de la microbit. Luego conectaremos la zona de GND / TIERRA con un cable hasta el pin GND de la microbit. Y, finalmente, un cable para la zona de cada jugador, de manera que PLAYER 1 esté conectado al pin P1 y PLAYER 2 al pin P2.

A la vista del montaje anterior, se puede entender cómo funcionará nuestro juego: los dos jugadores situarán una de sus manos al mismo tiempo en GND / TIERRA (siempre estarán tocando esta zona). Para activar el juego, uno de los jugadores, tocará con su segunda mano la zona de INICIO, el circuito en ese momento se cerrará y se activará un temporizador de cuenta atrás de 3 segundos que aparecerá en el panel de LEDs de la microbit. Transcurrido el contador, en una posición aleatoria del panel de LEDs se encenderá un LED; ésa será la señal de comienzo. El jugador que antes toque con su segunda mano su zona de juego será el ganador. 

Para que no haya controversia sobre quién ha pulsado antes su zona, la placa lo habrá detectado y mostrará en el panel de LEDs qué jugador ha sido y cuántos milisegundos ha tardado en hacerlo. Además, ojito porque no te puedes adelantar, si la placa detecta que te has adelantado, no funcionará y aparecerá en el panel que has sido tú. 

Ahora que entiendes la mecánica del juego, vamos a programarlo. Vamos a ver cómo se programaría para un sólo jugador. Después de eso, lo adaptaremos para que podáis competir entre vosotros con dos jugadores.

1. Variables

Con el objetivo de conocer la velocidad de reacción de un jugador, necesitamos crear algunas variables que almacenen ciertos datos. Primero inicializamos (fijamos o establecemos) las variables a ciertos valores de inicio. Las variables que necesitamos son: start, end y false_start.

A start y end le daremos inicialmente el valor de 0, que significa que no ha pasado tiempo. Después pondremos a false las variables false_start y running, para indicar que todavía no hemos empezado (la primera para indicar que no ha habido un falso inicio, y la segunda para indicar que todavía no está corriendo el tiempo).

De esta manera, cubrimos esta necesidad: el experimento de tiempo de reacción comienza y termina en ciertos instantes de tiempo basados en la reacción del jugador. El código detecta cuándo está corriendo el experimento y cuándo se ha producido un falso inicio (se ha pulsado antes de cuenta).

Ya puedes crear las variables e inicializarlas:

2. Pulsando aluminio

Necesitamos preparar gestores de eventos que detecten cuándo el jugador pulsa sobre GND con una mano, y pulsa sobre P0 o P1 con la otra mano, que es como se completa el circuito eléctrico. Por eso, vamos a tener dos gestores de eventos, uno al presionarse el pin P0 y otro al presionarse el pin P1:

3. Cuenta atrás

Necesitamos una cuenta atrás que muestre los segundos del 3 al 1 cuando se pulsa en el pin P0. Para hacer esto, simplemente mostramos el número 3, luego el 2 y luego el 1. Y después, borramos la pantalla.

4. Booleanos

Ahora, estableceremos nuestras variables running y false_start a false en el gestor de eventos de P0, para asegurarnos de que todo se reinicializa correctamente en los momentos clave.

5. 3,2,1,……

Esos puntos suspensivos ….. es lo que vamos a programar ahora, es decir, el instante antes de que comience la competición. No podemos iniciar el juego siempre al mismo tiempo, porque los jugadores estarían preparados y a base de ensayo y error serían capaces de estimar cuándo va a empezar el juego. Esto restaría justicia a la competición. Así que, la manera que tenemos de resolver este problema, es crear un número aleatorio de milisegundos que será 1000 (1s) como mínimo y 3000 (3s) como máximo. Esto lo hacemos estableciendo una pausa de ese número de milisegundos, antes de comenzar:

6. ¡Ya!

Ahora sí, en este paso programaremos, ese evento que activa a los jugadores para que compitan. Como sabes, el evento que hace que los jugadores compitan es un LED que se encenderá en la microbit. 

Desde el punto de vista de la programación, el tiempo de reacción empezará a contar SI NO se ha detectado un inicio falso (pin P0 presionado a destiempo). Cuando el tiempo de reacción comienza (esto lo calculamos con el bloque tiempo de ejecución), le decimos a nuestra variable running que el programa está iniciado, detenemos cualquier animación que pudiera quedar pendiente, limpiamos la pantalla y encendemos un LED aleatorio.

Con esto ya tendríamos nuestro juego preparado para funcionar, pero todavía no hemos desarrollado la parte del programa que detecta las pulsaciones del jugador en su espacio de juego.

7. Mostrar la reacción del jugador

Vamos a añadir algo de código para detectar cuando el jugador pulsa sobre GND con una mano y P1 con la otra. Esta pieza de código detiene la circulación de corriente y paraliza el contador de tiempo. Además, añadiremos código para que la microbit lea en milisegundos la cantidad de tiempo transcurrida desde la activación del inicio del juego (paso anterior) y la finalización del mismo con la pulsación del usuario. Nuestro código también debe detectar si se ha producido un inicio válido o un inicio falso.

El panel de LEDs mostrará esta imagen si el jugador P1 ha pulsado correctamente su espacio de juego:
El panel de LEDs mostrará esta imagen si se ha producido un inicio falso, es decir, el jugador ha pulsado su espacio de juego antes de que apareciera el LED activador de inicio del juego:
Información para el jugador de la izquierda.

Por tanto, el código del gestor de eventos al presionarse el pin P1, sería algo muy parecido a:

8. ¡Hora de volar solos!

Ahora que has entendido cómo funciona nuestro juego, estoy seguro que serás capaz de añadirle lo necesario para que podáis jugar dos jugadores, e iniciar la competición con tu compañero.

Pista: para saber cuál de los dos jugadores ha pulsado antes, y también cuál de los dos ha hecho un falso inicio, podrías utilizar estos dos paneles para el jugador 2:

Este código añade la información del jugador de la derecha.

5.5. Maqueen teledirigido por Micro:bit

Lo último que hicimos con nuestro Maqueen en el curso de iniciación, fue construir un programa que tomaba las lecturas de los infrarrojos para conseguir que el coche siguiera un circuito pintado sobre el suelo, el clásico siguelíneas.

Ahora, vamos a ir un poco más allá, programando una Micro:bit para que funcione como un mando a distancia que consiga controlar el movimiento del robot.

🛠 Materiales:

Como necesitamos hacer que el coche responda a los movimientos de otra Micro:bit, vamos a necesitar dos placas controladoras: la emisora (el mando a distancia) y la receptora (la que controla el coche).

La comunicación entre las dos placas, lo haremos usando los bloques de Radio:

Para facilitar, y acortar, la programación, usaremos cuatro posibles direcciones: IZQUIERDA, DERECHA, ADELANTE y ATRAS.

Pero, antes de comenzar a programar, necesitamos saber cómo funciona el sensor que usaremos para controlar el movimiento: el acelerómetro.

Un acelerómetro es un sensor que por medio de la fuerza gravitatoria de la tierra es capaz de detectar en qué plano de inclinación la has movido.

Tiene 4 posibles componentes: X, Y, Z y fuerza.

  1. X mide la aceleración a la derecha o a la izquierda.
  2. Y mide la aceleración hacia delante o hacia atrás.
  3. Z mide la aceleración en dirección ascendente y descendente.
  4. Fuerza mide la aceleración resultante de las tres dimensiones.

Fuerzas en el espacio
Como no vivimos en un mundo plano, las fuerzas ocurren en un espacio tridimensional (X, Y, Z). Si el movimiento de un objeto no es exactamente en la dirección de un eje, necesitamos una forma de calcular su aceleración a partir de los valores medidos para todos los ejes juntos. Si colocas tu Micro:bit sobre una mesa nivelada y lo empujas en diagonal, tendrás una aceleración en dos dimensiones ( X e Y ). Si decides levantar tu Micro:bit de la mesa, entonces acabas de agregar otra dimensión (Z).

Los valores que controlan esta aceleración se expresan en mili-g, que es 1/1000 g, siendo g la misma aceleración que obtienes de la gravedad de la Tierra, y varían en un rango de 2048 posibles valores (de -1023 a 1023). De manera que la placa en plano, mostrará una aceleración de 0 en la dimensión X. Si está completamente inclinada a la derecha, X será 1023, y completamente inclinada a la izquierda -1023.

La mejor manera de ver esto, es graficar sus valores para ver qué ocurre cuando la inclinas:

Sabiendo cómo funciona el sensor que usaremos, ya podemos empezar a programar.

Comencemos con la placa emisora.

Emisora

La comunicación entre las dos placas se va a realizar por medio de ondas de radio, así que lo primero que haremos será establecer un canal de comunicación, en nuestro caso el 1.

Además, nuestro coche se va a mover sobre el plano del suelo, así que no necesitaremos usar la dimensión Z del acelerómetro, sólo la X y la Y.

Esto nos deja sólo cuatro posibilidades de movimiento: DERECHA e IZQUIERDA para la X, y ATRAS y ADELANTE para la Y.

Por tanto, ya sabemos que nuestro programa debe tener una estructura condicional con cuatro casos:

Lo que queremos que suceda en cada caso es exactamente lo mismo: enviar a la placa receptora la dirección para que el coche se mueva, y mostrar en la emisora una flecha que indique la dirección que acabamos de mandar. Pues ya podemos hacerlo:

Lo único que nos quedaría por diseñar, son las condiciones que activan cada uno de esos casos. Vamos a asumir que queremos ir a la derecha cuando la X sea mayor o igual a 200, y a la izquierda cuando sea menor o igual que -200. Igualmente procederemos con la dimensión Y. Así que, nuestro programa se completaría así:

Ya puedes descargar el código en un archivo y meterlo en la placa que funcionará como emisora.

Receptora

La placa receptora debe recibir la información de la dirección, también por radio, por lo que debemos iniciarla estableciendo el mismo canal de comunicación que la emisora:

¿Cómo hacemos para recibir las palabras IZQUIERDA, DERECHA, ADELANTE y ATRAS que envió la emisora?

Usando el bloque de Radio disponible para ello:

Ten mucha precaución cuando uses la comunicación por radio, porque debes usar el bloque que recibe el mismo tipo de dato que se envió. Si se envió un número, debes usar receivedNumber. En nuestro caso, como se envió una palabra, debemos usar receivedString (cadena de caracteres en inglés).

Si la emisora era capaz de enviar cuatro posibles palabras, el programa de la receptora debe gestionar exactamente los mismos casos para las mismas palabras. Así que, ya sabes:

¿Cómo programamos, por ejemplo, el avance del coche cuando se recibe ADELANTE? Esto es algo que ya sabemos hacerlo, pero hay un pequeño detalle que ayuda a mejorar el comportamiento del coche en este proyecto.

Como el coche va a estar recibiendo constantemente mensajes para que se mueva, lo que haremos es moverlo durante medio segundo y luego pararlo orientado hacia delante:

Procederemos de la misma manera en los cuatro casos, hasta tener completado el código de nuestra receptora:

Ya puedes descargar tu programa y alojarlo en la Micro:bit que insertarás en el coche.

Para probar tu proyecto, enciende el coche para que esté disponible la receptora y luego activa la emisora. Inclínala hacia donde quieras y observa si el coche se mueve en la dirección que apunta la flecha que sale en la emisora.

Espero que hayas aprovechado estos contenidos, que los repases y por supuesto, que los pongas en práctica en tu aula.

Si quieres compartir con nosotros tu experiencia, no dudes en dejar un comentario.

👋 Hasta la próxima sesión.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *