Chismes del Lince 48: piano binario y pi pico

La noche en Sierra Bermeja estaba tranquila. Entre los pinsapos solo se oían los grillos, que, todo sea dicho, tocan siempre la misma nota y bastante desafinada.

El Lince de la Noche estaba sentado delante de sus tres faros, con las luces parpadeando a su ritmo: una roja cada cuatro segundos, una amarilla con dos destellos, una verde con tres. Funcionaban de maravilla.

—Los faros avisan muy bien —dijo la Gata Montesa, subida a una roca—. Pero tú siempre quieres que hagan algo más.

—Pues sí. Quiero que canten.

—Que canten… ¿luces?

—Una luz por nota. Do, la primera. Re, la segunda. Mi, la tercera. Y así hasta el Si —explicó el Lince, muy orgulloso—. Solo necesito comprar cuatro luces más, hacerles su soporte, soldar…

—Lince, tienes tres luces. Y con tres luces salen siete combinaciones distintas.

—¿Siete? Con tres luces yo solo cuento tres.

La Gata se rió y fue enseñándole los dedos de la pata: la primera sola, la segunda sola, la tercera sola, la primera con la segunda, la primera con la tercera, la segunda con la tercera… y las tres a la vez.

—Siete. Justo las siete notas.

El Lince se quedó mirando sus tres luces, muy callado. Después sonrió.

—Entonces lo que tengo es un piano.

—Un piano binario —dijo la Gata—. Y ahora, a componer.

Introducción

En este chisme construimos un piano binario: una página en el móvil con un teclado de siete notas y una Raspberry Pi Pico W con tres LEDs. Cuando pulsas una nota, suena en el móvil y se enciende su combinación de luces en la placa, a la vez.

El montaje electrónico es exactamente el del chisme anterior, el de los faros: tres LEDs en GP2, GP3 y GP4. No hay que cablear nada nuevo. Lo que cambia es el programa, y sobre todo la dirección de la conversación.

Por qué este chisme

Hasta ahora la Pico hablaba y el móvil escuchaba: en el dado, la placa mandaba un número. Aquí es al revés. El móvil da las órdenes y la Pico las cumple. Es la primera vez que la Pico recibe datos por Bluetooth, y es la base de cualquier mando a distancia.

Además, el piano binario esconde una idea de informática: con solo tres luces que pueden estar encendidas o apagadas se pueden representar siete notas distintas. Así es como un ordenador guarda cualquier cosa.

A dónde queremos llegar

Ya hicimos luces controladas por el móvil en el chisme 27, el semáforo Bluetooth con Heltec, y una pantalla de puntos en la pizarra de LEDs con micro:bit. Aquí damos un paso más: las luces ya no se limitan a obedecer, ahora cuentan una melodía.

A largo plazo, esas luces serán el oráculo del Lince para señalar dónde están los drones de los Centuriones. Para eso la Pico tiene que aprender a obedecer al móvil, y este chisme es justo ese paso.

Cómo funciona el piano binario

Un LED solo tiene dos estados: encendido o apagado. En informática a eso se le llama un bit: un 1 si está encendido y un 0 si está apagado. Con tres LEDs tenemos tres bits.

¿Cuántas combinaciones salen con tres bits? Cada luz puede estar de dos maneras, así que son 2 × 2 × 2 = 8. De esas ocho, una es «todo apagado», que usaremos como silencio. Las otras siete son las siete notas.

Cada luz vale un número, igual que en las unidades, decenas y centenas, pero en base dos: la luz 1 vale 1, la luz 2 vale 2 y la luz 3 vale 4. El número de una nota es la suma de lo que valen sus luces encendidas. Esto es el sistema binario.

Nota	Luz 3 (verde)	Luz 2 (amarilla)	Luz 1 (roja)	Binario	Número	Sonido (Hz)
Silencio	0	0	0	000	0	–
Do	0	0	1	001	1	261,63
Re	0	1	0	010	2	293,66
Mi	1	0	0	100	4	329,63
Fa	0	1	1	011	3	349,23
Sol	1	0	1	101	5	392,00
La	1	1	0	110	6	440,00
Si	1	1	1	111	7	493,88

Fíjate en el Fa: enciende las luces 1 y 2, y 1 + 2 = 3. El Mi enciende solo la luz 3, que vale 4. Por eso los números no siguen el orden de las notas.

Ese número es lo único que viaja por Bluetooth: el móvil envía un texto como «5» y la Pico enciende las luces 1 y 3. El sonido no viaja: lo genera el propio móvil con la frecuencia de la última columna.

Qué necesitamos

• Una Raspberry Pi Pico W con MicroPython, preparada como en el chisme del dado
• Thonny en el ordenador
• 3 LEDs: uno rojo, uno amarillo y uno verde
• 3 resistencias de 220 Ω
• Una protoboard y unos cables
• Un móvil Android con Chrome, o un ordenador con Chrome o Edge. En iPhone no funciona el Bluetooth de la página.

Construcción

Si ya montaste los faros del chisme anterior, no toques nada: el montaje es el mismo. Si no, cada LED va con su resistencia entre la pata larga y el pin de la Pico, y la pata corta va a GND.

Luz	LED	Pin de la Pico	Nombre del pin
Luz 1	Rojo	4	GP2
Luz 2	Amarillo	5	GP3
Luz 3	Verde	6	GP4
Tierra de los tres	Pata corta	3 u 8	GND

Antes de seguir, comprueba que el orden es ese: el rojo vale 1, el amarillo vale 2 y el verde vale 4. Si cambias el orden, las notas se encenderán con otras luces, aunque suenen igual.

El programa de la Pico W

En Thonny, con la Pico conectada, abre un archivo nuevo, pega este programa y guárdalo en la Pico con el nombre main.py. Así arrancará solo cada vez que la enchufes.

El programa tiene tres partes. La 1 y la 3 son lo importante. La 2 es el Bluetooth y es igual que en el chisme del dado: no hace falta tocarla.

# Chisme 48 - Las luces de la melodía
# Raspberry Pi Pico W + MicroPython
# El móvil manda un número del 0 al 7 por Bluetooth y la Pico enciende la combinación
# de luces que le corresponde. Montaje: los mismos 3 LEDs del chisme 47 (GP2, GP3, GP4).
#
#   número  luces encendidas        nota
#      1    luz 1                   Do
#      2    luz 2                   Re
#      4    luz 3                   Mi
#      3    luz 1 + luz 2           Fa
#      5    luz 1 + luz 3           Sol
#      6    luz 2 + luz 3           La
#      7    las tres                Si
#      0    ninguna                 silencio

import bluetooth, struct, time
from machine import Pin
from micropython import const

# ===== PARTE 1 · LO IMPORTANTE: los 3 LEDs (cada uno con su resistencia de 220 ohmios a GND) =====
luces = [Pin(2, Pin.OUT), Pin(3, Pin.OUT), Pin(4, Pin.OUT)]   # luz 1, luz 2, luz 3

# ===== PARTE 2 · BLUETOOTH: igual que en el chisme 46, NO hace falta tocarlo =====
# (lo único nuevo está en la función irq, donde se marca con «LO NUEVO»)
_IRQ_CENTRAL_CONNECT = const(1)
_IRQ_CENTRAL_DISCONNECT = const(2)
_IRQ_GATTS_WRITE = const(3)

NOMBRE = "Pico-Faros"       # el nombre que verás en el móvil

_UART_UUID = bluetooth.UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")
_UART_TX = (bluetooth.UUID("6E400003-B5A3-F393-E0A9-E50E24DCCA9E"), bluetooth.FLAG_NOTIFY)
_UART_RX = (bluetooth.UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA9E"),
            bluetooth.FLAG_WRITE | bluetooth.FLAG_WRITE_NO_RESPONSE)
_UART_SERVICE = (_UART_UUID, (_UART_TX, _UART_RX))

led = Pin("LED", Pin.OUT)   # el LED de la placa: encendido = móvil conectado
mascara = 0                 # lo que el móvil ha pedido (0 a 7)


def anuncio(nombre=None, uuid=None):
    # Paquete con el que la Pico se "anuncia" para que el móvil la encuentre
    datos = bytearray()

    def anade(tipo, valor):
        datos.extend(struct.pack("BB", len(valor) + 1, tipo) + valor)

    if nombre:
        anade(0x01, struct.pack("B", 0x06))
        anade(0x09, nombre.encode())
    if uuid:
        anade(0x07, bytes(uuid))
    return datos


def publicitar():
    ble.gap_advertise(100_000, adv_data=anuncio(nombre=NOMBRE),
                      resp_data=anuncio(uuid=_UART_UUID))


def irq(evento, datos):
    # Esta función se ejecuta sola cuando pasa algo en el Bluetooth.
    # Dentro solo apuntamos lo que ha llegado; encender los LEDs lo hace el bucle de abajo.
    global mascara
    if evento == _IRQ_CENTRAL_CONNECT:
        led.on()
    elif evento == _IRQ_CENTRAL_DISCONNECT:
        led.off()
        mascara = 0                        # sin móvil, luces apagadas
        publicitar()
    elif evento == _IRQ_GATTS_WRITE:       # LO NUEVO: el móvil nos ha escrito algo
        conn, valor = datos
        if valor == rx:
            for c in ble.gatts_read(rx):   # el texto llega como bytes: "5\n"
                if 48 <= c <= 55:          # códigos de las cifras '0' a '7'
                    mascara = c - 48       # nos quedamos con la última cifra que llegue


ble = bluetooth.BLE()
ble.active(True)
ble.irq(irq)
((tx, rx),) = ble.gatts_register_services((_UART_SERVICE,))
publicitar()

# ===== PARTE 3 · LO IMPORTANTE: encender lo que pide el móvil =====
# Saludo: las tres luces parpadean una vez para saber que el programa ha arrancado
for pin in luces:
    pin.on()
time.sleep_ms(400)
for pin in luces:
    pin.off()

# Bucle principal: ponemos en los LEDs lo que ha pedido el móvil
aplicada = 0
while True:
    if mascara != aplicada:
        for i in range(3):
            luces[i].value((mascara >> i) & 1)   # el bit i del número manda sobre la luz i+1
        aplicada = mascara
    time.sleep_ms(2)

Al arrancar, las tres luces parpadean una vez. Si no lo hacen, el programa no se está ejecutando.

Cómo lee la Pico el número

Cuando el móvil escribe, Bluetooth llama a la función irq. Esa función solo apunta el número en la variable mascara. No enciende nada: de eso se encarga el bucle del final, que mira cada 2 milisegundos si hay un número nuevo.

Es la misma regla que con las interrupciones de cualquier placa: lo que llega de fuera se apunta rápido y se atiende en el programa principal.

La línea que enciende las luces es luces[i].value((mascara >> i) & 1). Significa: «mira el bit número i del número». Con mascara = 5, que en binario es 101, el bit 0 vale 1, el bit 1 vale 0 y el bit 2 vale 1. Se encienden las luces 1 y 3: es el Sol.

Lee y predice

1. Si el móvil manda un 6, ¿qué luces se encienden y qué nota es?
2. Si manda un 7, ¿cuántos LEDs lucen?
3. Si por error manda un 9, ¿qué hace la Pico? Pista: mira el if 48 <= c <= 55.
4. ¿Por qué la Pico deja de lucir las luces cuando se desconecta el móvil?

Respuestas: 6 es la luz 2 con la luz 3 (La). El 7 enciende los tres. Un 9 no es una cifra válida y la Pico lo ignora, así que sigue como estaba. Al desconectarse, la función irq pone mascara = 0.

Cambio guiado: cambia Pin(2, Pin.OUT), Pin(3, Pin.OUT), Pin(4, Pin.OUT) por otros tres pines libres y mueve los cables. Todo sigue funcionando, solo cambia el cableado.

La página del piano binario

La página de control es un solo archivo HTML, igual que en los chismes anteriores. Puedes abrirla directamente en la página del piano binario con Chrome o Edge, o guardarla en tu ordenador y abrirla desde allí.

Se usa así: pulsa Conectar Pico W, elige Pico-Faros en la lista y empieza a pulsar notas. Aunque no tengas la placa, la página funciona: suena y muestra tres luces en la pantalla.

La página tiene:

• un teclado con las siete notas, cada una con su combinación de luces dibujada
• una melodía hecha de fichas: toca una ficha para alargarla (×2), acortarla (½) o dejarla normal
• un botón de silencio, la velocidad y la opción de repetir sin parar
• tres melodías de ejemplo: la escala, Fray Santiago y Estrellita
• la tabla de bits de este chisme, para tenerla siempre a la vista

Lo importante de la página

De todo el código de la página solo hay dos trozos que explican el chisme. El primero es la lista de notas, con el número que corresponde a cada una y la frecuencia con la que suena:

const NOTAS = [
  {n: "Do",  f: 261.63, m: 1},   // luz 1
  {n: "Re",  f: 293.66, m: 2},   // luz 2
  {n: "Mi",  f: 329.63, m: 4},   // luz 3
  {n: "Fa",  f: 349.23, m: 3},   // luz 1 + luz 2
  {n: "Sol", f: 392.00, m: 5},   // luz 1 + luz 3
  {n: "La",  f: 440.00, m: 6},   // luz 2 + luz 3
  {n: "Si",  f: 493.88, m: 7}    // las tres
];

El segundo es la función que envía el número a la Pico. Escribe el texto, por ejemplo «5» más un salto de línea, en la característica RX del servicio UART:

function enviarBT(m){
  if (!rx || m === ultimaEnviada) return;
  ultimaEnviada = m;
  const datos = new TextEncoder().encode(m + "\n");
  cola = cola.then(() => rx.properties.writeWithoutResponse ? rx.writeValueWithoutResponse(datos) : rx.writeValue(datos))
             .catch(() => {});
}

Las órdenes salen una detrás de otra, en fila (cola), porque Bluetooth no admite dos escrituras a la vez. Y si el número es el mismo que el anterior, no se vuelve a enviar.

El sonido lo fabrica el móvil con un oscilador de la API Web Audio: una onda que vibra a los hercios de la nota. No hay archivos de audio.

Cómo probarlo

1. Enchufa la Pico con el programa guardado como main.py. Las tres luces deben parpadear una vez.
2. Abre la página, pulsa Conectar Pico W y elige Pico-Faros. Se enciende el LED verde de la propia placa: ya hay móvil conectado.
3. Pulsa Do: debe lucir solo la luz roja. Pulsa Mi: solo la verde. Pulsa Si: las tres.
4. Comprueba cada nota con la tabla de bits. Si alguna no coincide, casi seguro hay dos LEDs cambiados de sitio.
5. Carga Fray Santiago y pulsa Tocar. Suena en el móvil y se enciende en la placa al mismo tiempo.

Si la Pico no aparece en la lista, desenchufa y enchufa la placa y vuelve a pulsar Conectar. Si aparece pero da error al conectar, también ayuda cerrar otras páginas que usen Bluetooth.

Qué estamos midiendo realmente

En este chisme la Pico no mide nada: no hay ningún sensor. El número que viaja por Bluetooth es un dato codificado, no una medida. Es una orden escrita en binario.

Lo que sí se puede medir es el retraso. El sonido sale del móvil casi al instante, pero la orden tiene que viajar por Bluetooth, que la agrupa en paquetes, y que la Pico la lea y la encienda. Todo eso tarda. Por eso la página tiene el deslizador de retraso del sonido: retrasamos el sonido para que espere a las luces.

Para medirlo se puede grabar un vídeo en cámara lenta, que muchos móviles hacen a 120 o 240 fotogramas por segundo. Se cuenta cuántos fotogramas hay entre que la luz se enciende y que suena la nota. Cada fotograma dura menos de una décima de segundo, así que la medida es bastante fina.

Las frecuencias de la tabla son valores de la afinación estándar: el La suena a 440 Hz, es decir, 440 vibraciones por segundo. Los altavoces pequeños de un móvil reproducen mejor unas notas que otras, así que lo que oyes no es una medida exacta de la frecuencia.

Por último, un aviso de seguridad. La Pico no pide contraseña: cualquier móvil cercano con la página podría conectarse y encender tus luces. No pasa nada grave con un LED, pero es una buena razón para pensar cómo se protegería una orden importante.

Nada sale del dispositivo: la melodía vive en la página y el Bluetooth solo une el móvil con la Pico. No hay servidor ni cuentas.

Para el aula

El piano binario sirve para trabajar el binario sin una sola cuenta aburrida: las luces lo hacen visible. Algunas actividades:

• Descifra las luces. Un grupo toca una melodía con la pantalla del móvil tapada y el sonido apagado. Los demás ven solo las luces de la placa y tienen que adivinar las notas usando la tabla de bits.
• Binario a mano. En papel, convierte 110, 011 y 100 a decimal y di qué nota es cada uno. Después haz el camino inverso con el 5.
• ¿Cuántas combinaciones? Con 3 LEDs salen 8. ¿Y con 4? ¿Y con 8? ¿Qué regla sigue la cuenta?
• Medir el retraso. Graba con la cámara lenta del móvil la placa y la página a la vez, cuenta los fotogramas entre luz y sonido y repite 20 veces. ¿Sale siempre lo mismo? ¿Cuál es la media?
• Dos móviles, dos resultados. Repite la medida con otro móvil. Si salen valores distintos, ¿a qué puede deberse?
• Una variable cada vez. Aleja el móvil de la placa o pon un obstáculo en medio. Formula una hipótesis antes de medir y comprueba si se cumple.
• Compositores. Cada pareja inventa una melodía de ocho notas, la apunta como secuencia de números y se la pasa a otra pareja para que la toque.

Retos

1. Haz que funcione. Monta los LEDs, carga el programa y toca Fray Santiago.
2. Modifica algo. Haz que el Do encienda la luz 3 en vez de la luz 1. Tienes que cambiar la tabla de la página y entender qué cambia en la Pico.
3. Cambia el orden de los LEDs. Intercambia dos cables y mira qué notas «se equivocan». ¿Por qué?
4. Guarda tu melodía. Haz que la página guarde la melodía en el navegador para que no se pierda al cerrarla.
5. Representa los datos. Apunta en una hoja de cálculo los retrasos que midas y dibuja una gráfica.
6. Que toque sola. Guarda una melodía dentro de la Pico y haz que la reproduzca sin móvil.
7. Añade un cuarto LED. Con 4 bits salen 15 combinaciones. Tendrás que mandar números de dos cifras o usar letras, y decidir qué hacen las notas nuevas.
8. Pequeña investigación. Mide el retraso con el móvil a 1, 3 y 6 metros de la placa, con 30 medidas en cada distancia. Compara las medias y decide si la distancia importa.

Qué hemos aprendido

Con tres LEDs y un móvil hemos construido un piano binario. Hemos visto que tres bits dan 8 combinaciones, que siete de ellas son las notas y que la octava combinación es el silencio.

También hemos aprendido que la Pico puede recibir órdenes por Bluetooth y no solo enviar datos, que lo que llega de fuera se apunta rápido y se atiende en el bucle principal, y que un dato codificado no es lo mismo que una medida.

Y una lección de ciencia: medir el retraso entre la luz y el sonido nos recuerda que medir no significa medir bien. Una medida depende de cómo se haga, y repetirla muchas veces es lo que nos da confianza.

El Lince ya tiene luces que obedecen. Falta enseñarles a señalar, pero ese es otro chisme.

Para seguir investigando

• Chisme 22: Simón dice con gestos, para otro juego de luces y memoria
• Chisme 27: semáforo Bluetooth con Heltec, para las luces controladas desde el móvil
• Documentación de MicroPython: el módulo bluetooth, para ver todo lo que puede hacer la Pico con Bluetooth
• API Web Audio en MDN, para crear sonidos desde una página web
• Sistema binario en Wikipedia, para pasar de decimal a binario y al revés