Currículo: aquí encontrarás el desarrollo detallado de los contenidos que forman parte de la primera sesión del Curso avanzado de pensamiento computacional, robótica e internet de las cosas, impartido por el CEP de Huelva – Isla Cristina.
Tabla de contenidos
- 1. Retomando el hilo
- 2. Radar de suelo para el control de velocidad
- 3. Sistemas cooperativos
- 4. Tu propia extensión de Makecode
1. Retomando el hilo
En las ediciones anteriores del curso, tanto en el nivel básico como el intermedio, estudiamos las características más importantes de la placa controladora Micro:bit en una variedad de situaciones y proyectos interesantes.
Es muy recomendable para continuar con la progresión en la complejidad de los proyectos que vamos a hacer, que repasemos durante unos minutos dónde lo dejamos en el curso anterior.
Aquí podemos recordar cómo funcionaba la plataforma de programación Makecode, aquí las características de nuestra placa controladora, aquí la funcionalidad del coche Maqueen y aquí una lista de pequeños proyectos intermedios que pusimos en práctica.
Con la destreza que hemos alcanzado, ya deberíamos poder completar todo lo anterior en una hora.
Pongámonos a ello, y al finalizar abordaremos otro proyecto interesante que gusta mucho a los alumnos.
2. Radar de suelo para el control de velocidad
Seguramente, cuando has ido conduciendo por alguna de las carreteras que usas habitualmente, habrás advertido cómo en determinados tramos, el asfalto mostraba marcas como la de esta imagen:
Se trata de espiras de tráfico, de la DGT, y sirven para medir la intensidad del tráfico así como de las velocidades medias.
Utiliza un concepto muy básico de la cinemática, basado en calcular el tiempo que tarda un vehículo en pisar las dos filas de marcas. Con esos dos valores se puede medir la velocidad a la que circulan los vehículos.
Si se tardan 2s en llegar de una marca a otra y están separadas 10m, solo tenemos que aplicar la conocida fórmula de la velocidad = distancia / tiempo, y tendremos una medida de la velocidad que llevaba el vehículo.
Pues eso es lo que vamos a hacer con nuestra Micro:bit y nuestro Maqueen.
🛠 Materiales:
- 1 x Placa Micro:bit.
- 1 x Robot Maqueen.
- 1 x carretera de cartón.
- 4 x Cables de cocodrilo.
- Papel de aluminio.
- Cinta adhesiva para cartón.
Para detectar cada una de las marcas de la carretera construiremos dos «puertas». Cada una de las puertas debe detectar el paso del coche.
Para construir una puerta extenderemos dos bandas de aluminio lo más pegadas posible, sin que se toquen (puedes hacerlo usando cinta de doble cara, o cualquier otro método que se te ocurra).
Ahora conecta un cable de cocodrilo a cada una de las bandas de aluminio, lleva un cable al Pin 0, y el otro al Pin GND.
La primera puerta, está lista para detectar el paso del coche.
La Micro:bit viene equipada con un bloque de evento llamado al presionarse pin, que se activa cuando se detecta un circuito entre GND y el PIN 0 -u otro que hayas conectado-. El circuito conductor puede ser un cable o incluso tu propio cuerpo.
Lo que haremos será que colocaremos en la base del coche una pieza de aluminio, de manera que cuando pase por la hendidura entre las dos bandas de aluminio, haga contacto con ambas bandas, las conecte, cierre el circuito y dispare el evento.
Así que, añade esto a tu código en Makecode, para indicar que el coche ha pasado por la primera puerta:
Veamos si funciona, probando a cerrar el circuito con nuestra mano:
Bien, nuestro circuito se cierra y se lanza el evento correctamente.
Ahora vamos a equipar nuestro coche con el elemento que funcionará como ha hecho nuestro dedo. Vamos a instalarle una pequeña banda de aluminio (cualquier conductor serviría) que irá arrastrando sobre el suelo, y que debe ser lo suficientemente ancho como para que pise ambas bandas de aluminio de la carretera:
De la misma manera que hemos hecho con nuestra «puerta de entrada», procedemos con nuestra «puerta de salida». En mi caso,he separado ambas «puertas» unos 30cm.
Y además, necesitamos modificar nuestro código para que incorpore el paso por la segunda puerta, que en este caso la tendremos conectada al PIN 1, y también a GND -tal y como hicimos con la primera-:
¿Cómo registramos el tiempo que lleva activa cada puerta? Usando el bloque:
Este bloque devuelve un «timestamp» del último evento que se ejecutó, y se mide en microsegundos. Si tenemos esa marca del paso del coche por ambas puertas, restamos el segundo (t1) del primero (t0) y tendremos el tiempo en microsegundos que ha transcurrido entre ambas. Dividiendo ese tiempo por 1.000.000 tenemos los segundos que ha tardado.
Como sabemos que la distancia entre las dos es de 30cm, ya podemos calcular la velocidad en cm/s:
velocidad = 30cm / (t1 – t0)
Veamos nuestro radar de suelo terminado en acción.
Como se puede ver en la matriz de LEDs de la Micro:bit, mi coche viaja a 13,94 cm/s.
3. Sistemas cooperativos
Hasta ahora hemos estado programando una única Micro:bit para resolver problemas concretos: detectar movimiento, encender LEDs, mover un servomotor o reaccionar ante un sensor. Pero ahora vamos a dar un salto importante.
La Micro:bit incorpora una funcionalidad muy potente llamada radio, que permite que varias placas puedan comunicarse entre sí de forma inalámbrica. Esto significa que una placa puede detectar un evento, otra puede procesar esa información y una tercera puede ejecutar una acción.
Recuerda que para que dos o más placas se comuniquen entre sí, deben configurar el mismo canal de radio:
Enviar algo al canal de radio puede hacerse en formato número o en formato cadena de texto:
Y finalmente, para recibir un número o una cadena de texto DEBEMOS usar el evento correspondiente:
Con estos bloques de radio y aplicando las estructuras que ya conocemos como bucles, condicionales, variables y lógica, tenemos todo lo necesario para controlar cualquier sistema.
De repente, dejamos de programar dispositivos aislados y empezamos a construir sistemas cooperativos, muy parecidos a los que encontramos en la tecnología del mundo real.
Y aquí es donde las posibilidades se disparan.
Si una sola micro:bit ya puede leer sensores y controlar actuadores, imagina lo que podemos conseguir cuando 5, 10 o incluso 20 placas colaboran entre sí. Con suficientes nodos trabajando en red, podríamos llegar a domotizar por completo una maqueta de una vivienda, repartiendo sensores y actuadores por cada estancia.
Por ejemplo, una Micro:bit colocada en el salón podría usar su sensor de sonido para detectar que la televisión está encendida o que hay demasiado ruido ambiental. Otra situada cerca de una ventana podría usar el sensor de temperatura para detectar un exceso de calor. Otra más, colocada en una puerta o ventana, podría usar el acelerómetro para detectar inclinación, apertura o vibración.
Cada una de estas placas podría enviar mensajes por radio a una Micro:bit central encargada de tomar decisiones:
- Si detecta demasiado calor: activar un motor que ponga en marcha un sistema de ventilación.
- Si detecta una ventana abierta: mostrar una alerta visual.
- Si detecta ruido excesivo: activar una señal luminosa o acústica.
- Si detecta movimiento en una puerta: mover un servomotor para simular una cerradura inteligente.
Lo interesante es que la programación necesaria para conseguirlo no es especialmente compleja. Cada placa puede limitarse a hacer una tarea muy concreta: detectar, comunicar o actuar. La verdadera inteligencia del sistema aparece cuando todas cooperan entre sí.
La tecnología no siempre empieza con componentes sofisticados. Muchas veces empieza con una pregunta sencilla:
¿Qué pasaría si una placa detectara esto… y otra respondiera haciendo aquello?
Voy un poco más allá, ¿y si no solamente creamos un sistema cooperativo sino que además creamos nuestra propia extensión de Makecode para controlarlo todo de manera sencilla e intuitiva?
👇
4. Tu propia extensión de Makecode
Si, podemos crear nuestras propias extensiones en Makecode.
¿Para qué? Pues para crear algo que no existe o para mejorar algo que ya existe.
En nuestro caso va a ser lo segundo.
Como bien sabes, cuando queremos programar el coche Maqueen, debemos ir a Makecode y añadir la extensión Maqueen que buscamos directamente en la interfaz de Extensiones:
Si te fijas, ahí donde solemos buscar el nombre de las extensión también se puede poner una URL. ¿Cuál? Pues la de nuestra extensión, concretamente la de un repositorio de GitHub donde estén los archivos de código fuente de nuestra extensión.
GitHub es una plataforma en Internet pensada para guardar, organizar y compartir proyectos digitales, especialmente proyectos de programación.
Aunque no sepas programar, puedes imaginarlo como una mezcla entre Google Drive, una red social profesional y un historial de cambios. Sirve para que una persona o un equipo pueda crear archivos, modificarlos con el tiempo, recuperar versiones anteriores si algo sale mal y colaborar con otras personas sin pisarse el trabajo.
Por eso, hoy en día, muchas empresas, profesores, estudiantes y desarrolladores lo utilizan para construir software, páginas web, proyectos de robótica o incluso documentación técnica de forma organizada.
Toca registrarse en GitHub.
No te preocupes, es extremadamente simple.
Pulsa aquí, luego en Sign up, usa el botón de Google, tu cuenta de correo corporativa y adelante.
Bien, ya tienes todo lo necesario.
Lo que queremos programar es un bloque que nos facilite girar el coche. Para que no tengamos que estar pensando constantemente qué rueda tengo que cambiar de velocidad, cómo lo hago si voy marcha atrás o cuánto tiempo le pongo al giro. Vamos a simplificarlo todo creando un bloque que gire. El bloque se llamará girar, podrás elegir si vas hacia delante o hacia detrás y también si quieres girar a derecha o izquierda. Todo en un único bloque. Y lo vas a hacer tú.
Vámonos a Makecode.
Inicia sesión.
Crea un proyecto nuevo con el nombre que quieras.
Pulsa en JavaScript. Si, vamos a programar.
Verás que han aparecido dos cosas que no conocías hasta ahora: a la derecha el código del programa, y a la izquierda el explorador de archivos.
Si pinchas en el Explorador podrás ver todos los archivos que forman parte de este programa.
Activa la integración con GitHub pulsando en el gatito:
Si no tienes sesión iniciada en GitHub te pedirá que lo hagas, lo haces y vuelves aquí.
Te aparecerá esta ventana. Solo hace falta que le des un nombre al repositorio que se creará en tu GitHub para alojar los archivos de tu extensión:
Cuando pulses el botón verde Makecode se sincronizará con GitHub, se crearán archivos nuevos para tu extensión y Makecode quedará listo para que lo programes:
Abre el Explorador y pulsa sobre el archivo llamado pxt.json y si te sale una ventana con el botón Guardar y Edit Settings As text, pulsa el segundo:
Eso que ves es el archivo de configuración de tu extensión. Puedes dejarlo tal y como está todo, pero debemos añadir una línea en “dependencies“, para indicarle que nuestra extensión para funcionar necesita de otra llamada Maqueen, ya que vamos a programar una funcionalidad que está en la extensión de Maqueen.
Esta es la parte que aparece por defecto:
"dependencies": {
"core": "*",
"radio": "*",
"microphone": "*"
},Y así es como debemos dejarla:
"dependencies": {
"core": "*",
"radio": "*",
"microphone": "*",
"maqueen": "github:DFRobot/pxt-maqueen"
},Ahora pulsamos sobre el archivo main.ts.
Aquí es donde programaremos toda la lógica de nuestra extensión.
Borra el código que aparece.
Primero colocamos dos estructuras que nos permitirán seleccionar entre Avanzando y Retrocediendo, y otra que nos permitirá elegir entre Derecha o Izquierda.
El resto del código contiene la lógica que usa los bloques de Maqueen para hacer lo que nosotros le indicamos con nuestro bloque:
enum SentidoMovimiento {
//% block="avanzando"
Avanzando,
//% block="retrocediendo"
Retrocediendo
}
enum LadoGiro {
//% block="derecha"
Derecha,
//% block="izquierda"
Izquierda
}
//% weight=100 color=#0fbc11 icon="\uf1b9" block="Maqueen fácil"
namespace maqueenFacil {
/**
* Hace girar el coche Maqueen avanzando o retrocediendo hacia un lado.
*/
//% block="girar %sentido hacia %lado"
//% weight=100
export function girar(sentido: SentidoMovimiento, lado: LadoGiro): void {
let velocidad = 80
if (sentido == SentidoMovimiento.Avanzando && lado == LadoGiro.Derecha) {
maqueen.motorRun(maqueen.Motors.M1, maqueen.Dir.CW, velocidad)
maqueen.motorStop(maqueen.Motors.M2)
}
if (sentido == SentidoMovimiento.Avanzando && lado == LadoGiro.Izquierda) {
maqueen.motorStop(maqueen.Motors.M1)
maqueen.motorRun(maqueen.Motors.M2, maqueen.Dir.CW, velocidad)
}
if (sentido == SentidoMovimiento.Retrocediendo && lado == LadoGiro.Derecha) {
maqueen.motorRun(maqueen.Motors.M1, maqueen.Dir.CCW, velocidad)
maqueen.motorStop(maqueen.Motors.M2)
}
if (sentido == SentidoMovimiento.Retrocediendo && lado == LadoGiro.Izquierda) {
maqueen.motorStop(maqueen.Motors.M1)
maqueen.motorRun(maqueen.Motors.M2, maqueen.Dir.CCW, velocidad)
}
}
}Listo.
Pulsa en el iconito del gato de GitHub para que se envíen los cambios y ya tienes tu extensión lista.
Para probarla crea un proyecto nuevo en Makecode, ve a las extensiones, pega en el campo de búsqueda la URL de tu repositorio de GitHub, te saldrá en los resultados, pinchas sobre él y ya lo tendrás en tu Makecode.
Si le quieres hacer cualquier cambio a tu extensión puedes ir al repositorio de GitHub que lo aloja, modificas el código a tu gusto, confirmas los cambios y a funcionar.
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.