Chisme 155 del Lince: zumbador pasivo con micro:bit, la alarma de tonos de Sierra Bermeja

Víctor Vílchez, el Lince de la Noche, llegó a la cueva de Sierra Bermeja tapándose las orejas con las patas. En la otra mano llevaba la placa de expansión con un pequeño cilindro negro conectado. Zumbador pasivo microbit.

Un pitido agudo e ininterrumpido resonaba por todas las paredes de piedra.

—¡Víctor, por los dioses del monte! —gritó la Gata Montesa soltando sus apuntes—. ¡Apaga eso antes de que se me revienten los tímpanos!

El Lince tiró del cable apresuradamente. El silencio volvió de golpe a la cueva.

—Es el nuevo avisador acústico para el paso de fauna del arroyo Monterroso —explicó el Lince, recuperando el aliento—. La idea era que avisara cuando un vehículo se acerca de noche.

—¿Y tiene que pitar hasta que se agote la batería de la micro:bit? —preguntó la Gata levantando una ceja—. Los zorros van a mudarse a Marbella a este ritmo.

—Es que he conectado un zumbador pasivo y no sé cómo hacer para que pite un instante y se calle —confesó el Lince mirando la placa con frustración—. Además, quería que la alarma de la pista forestal sonara distinta a la del sendero peatonal.

La Gata Montesa se acercó a la mesa, cogió el módulo entre las garras y sonrió con ironía.

—Víctor, un zumbador pasivo no es una sirena de obra; es como un instrumento musical. No le das corriente y ya está: tienes que decirle a qué frecuencia vibrar y durante cuánto tiempo. Medio segundo de tono es más que suficiente para avisar, y si dejas un segundo de silencio entre avisos, das tiempo a escuchar el entorno.

—¿Y podemos hacer que el botón A toque un tono agudo y el B uno más grave? —preguntó el Lince entusiasmado.

—Exactamente eso. Vamos a programarlo en MakeCode antes de que dejes sorda a toda Sierra Bermeja.

Introducción

En este chisme 155 vas a aprender a programar un zumbador pasivo con micro:bit utilizando la placa de expansión de Keyestudio. Diseñaremos un sistema de avisos acústicos donde cada botón genera una nota de frecuencia diferente durante medio segundo (500 ms) y guarda un segundo de silencio de seguridad.

El problema: El Lince quiere saber cómo emitir señales sonoras de aviso con diferente tono según el evento y para eso usa un zumbador pasivo.

Por qué este chisme

En la industria, la robótica y los sistemas de emergencia, las señales sonoras no se emiten al azar. Un pitido continuo genera fatiga auditiva, satura las baterías y no aporta información sobre qué está ocurriendo.

Usar distintas frecuencias (tonos) permite identificar de un vistazo auditivo si el evento es un aviso genérico (botón A) o una alerta prioritaria (botón B). Además, acotar el sonido a un pulso breve de 0,5 segundos garantiza que el sistema no consuma energía innecesaria.

Cómo funciona un zumbador pasivo

Existen dos tipos de zumbadores (buzzers) en los kits de electrónica:

1. Zumbador activo: Lleva un oscilador interno. Al aplicarle tensión (3,3 V), pita a una sola frecuencia fija. No se puede cambiar su nota.
2. Zumbador pasivo: No tiene oscilador interno. Es un pequeño altavoz piezoeléctrico que necesita una señal de onda cuadrada (PWM) enviada desde la micro:bit. Al cambiar la frecuencia de esa señal (los hercios, Hz), el zumbador emite notas musicales distintas.

La micro:bit genera esta señal enviando pulsos digitales rápidos por el pin P0.

Qué necesitamos

• Una micro:bit V2.
• La placa de expansión Keyestudio (kit ks0361).
• El módulo zumbador pasivo (Keyestudio Passive Buzzer) y su cable de tres hilos.
• Un cable micro-USB.
• Un ordenador con navegador web (Chrome o Edge) para MakeCode.

Conexión

Asegúrate de que el puente de alimentación de la placa de expansión esté colocado en 3,3 V. Con el cable USB desconectado, conecta el zumbador a la fila del pin P0:

Módulo Zumbador Pasivo	Columna de la placa Keyestudio
− (GND)	G (columna negra, fila 0)
+ (VCC)	V (columna roja, fila 0)
S (Señal)	S (columna amarilla, fila 0 / Pin P0)

Nota: Usamos el pin P0 porque es el pin por defecto asignado a la salida de audio analógica/PWM en MakeCode.

El programa

Abre MakeCode

y ensambla los siguientes bloques en español:

Bloques en MakeCode

1. Categoría Básico:
   • En el bloque al iniciar, añade el bloque mostrar ícono [carita feliz].
2. Categoría Entrada:
   • Arrastra un bloque al presionar el botón [ A ].
3. Categoría Música:
   • Dentro de botón A, inserta reproducir tono [ Do alto / C5 (523 Hz) ] durante [ 1/2 pulso ] hasta que termine.
4. Categoría Avanzado → Serie:
   • Añade serial escribir valor [ “tono_A” ] = [ 523 ].
5. Categoría Básico:
   • Añade una pausa (ms) [ 1000 ].
6. Categoría Entrada:
   • Arrastra otro bloque al presionar el botón [ B ].
7. Categoría Música:
   • Dentro de botón B, inserta reproducir tono [ Sol alto / G5 (784 Hz) ] durante [ 1/2 pulso ] hasta que termine.
8. Categoría Avanzado → Serie:
   • Añade serial escribir valor [ “tono_B” ] = [ 784 ].
9. Categoría Básico:
   • Añade una pausa (ms) [ 1000 ].

(Si añades librerías externas de sonido en MakeCode, ten en cuenta que los nombres de los bloques de esas extensiones aparecerán en inglés).

Código JavaScript

Puedes copiar y pegar este código directamente en la pestaña JavaScript de MakeCode:

TypeScript

// Al arrancar, confirmamos funcionamiento
basic.showIcon(IconNames.Happy)

// Evento al pulsar el Botón A: Tono grave/medio (Do5 = 523 Hz)
input.onButtonPressed(Button.A, function () {
    music.play(music.tonePlayable(523, music.beat(BeatFraction.Half)), music.PlaybackMode.UntilDone)
    serial.writeValue("tono_A", 523)
    basic.pause(1000)
})

// Evento al pulsar el Botón B: Tono agudo (Sol5 = 784 Hz)
input.onButtonPressed(Button.B, function () {
    music.play(music.tonePlayable(784, music.beat(BeatFraction.Half)), music.PlaybackMode.UntilDone)
    serial.writeValue("tono_B", 784)
    basic.pause(1000)
})

El simulador

Prueba el comportamiento del programa en el siguiente simulador interactivo en HTML.

HTML

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Chisme 155 - Simulador Zumbador Pasivo micro:bit</title>
    <style>
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background-color: #1e1e2f;
            color: #ffffff;
            display: flex;
            flex-direction: column;
            align-items: center;
            padding: 20px;
            margin: 0;
        }
        .instructions {
            background-color: #2a2a40;
            border-left: 5px solid #4caf50;
            padding: 15px;
            max-width: 600px;
            margin-bottom: 20px;
            border-radius: 4px;
        }
        .instructions h3 { margin-top: 0; color: #4caf50; }
        .microbit-card {
            background: #111;
            border: 4px solid #333;
            border-radius: 20px;
            padding: 25px;
            width: 320px;
            box-shadow: 0 10px 30px rgba(0,0,0,0.5);
            display: flex;
            flex-direction: column;
            align-items: center;
            position: relative;
        }
        .matrix {
            display: grid;
            grid-template-columns: repeat(5, 1fr);
            gap: 8px;
            background: #222;
            padding: 12px;
            border-radius: 8px;
            margin-bottom: 20px;
        }
        .led {
            width: 20px;
            height: 20px;
            background-color: #400;
            border-radius: 50%;
            transition: background-color 0.1s;
        }
        .led.on {
            background-color: #ff2222;
            box-shadow: 0 0 10px #ff0000;
        }
        .controls {
            display: flex;
            justify-content: space-between;
            width: 100%;
            margin-bottom: 20px;
        }
        .btn {
            background: #444;
            color: white;
            border: none;
            width: 60px;
            height: 60px;
            border-radius: 50%;
            font-weight: bold;
            font-size: 18px;
            cursor: pointer;
            box-shadow: 0 4px 0 #222;
        }
        .btn:active {
            transform: translateY(4px);
            box-shadow: none;
        }
        .buzzer-status {
            background: #222;
            border: 2px solid #555;
            border-radius: 8px;
            padding: 10px;
            width: 90%;
            text-align: center;
            font-family: monospace;
        }
        .sound-wave {
            display: inline-block;
            width: 12px;
            height: 12px;
            border-radius: 50%;
            background: #555;
            margin-left: 8px;
        }
        .sound-wave.active {
            background: #00ff00;
            box-shadow: 0 0 10px #00ff00;
        }
        .console {
            margin-top: 20px;
            background: #000;
            color: #00ff00;
            font-family: monospace;
            padding: 10px;
            width: 320px;
            height: 100px;
            overflow-y: auto;
            border-radius: 6px;
            border: 1px solid #333;
        }
    </style>
</head>
<body>

    <div class="instructions">
        <h3>Guía del Simulador: Paso a paso</h3>
        <p><strong>1. Haz esto:</strong> Haz clic sobre el <strong>Botón A</strong> o el <strong>Botón B</strong> en la micro:bit virtual.</p>
        <p><strong>2. Lo que verás/escucharás:</strong> El zumbador emitirá un tono acústico real durante 0,5 segundos. El Botón A emitirá una frecuencia más grave (523 Hz) y el Botón B una más aguda (784 Hz). La pantalla LED mostrará la letra correspondiente y el puerto serie registrará el dato en pantalla.</p>
    </div>

    <div class="microbit-card">
        <div class="matrix" id="matrix"></div>
        
        <div class="controls">
            <button class="btn" id="btnA" onclick="pressButton('A')">A</button>
            <button class="btn" id="btnB" onclick="pressButton('B')">B</button>
        </div>

        <div class="buzzer-status">
            ZUMBADOR P0: <span id="freqDisplay">0 Hz</span>
            <span class="sound-wave" id="waveIndicator"></span>
        </div>
    </div>

    <div class="console" id="serialConsole">
        > Consola Serie lista...<br>
    </div>

    <script>
        // Inicializar Matriz de LEDs 5x5
        const matrixEl = document.getElementById('matrix');
        const leds = [];
        for (let i = 0; i < 25; i++) {
            const led = document.createElement('div');
            led.classList.add('led');
            matrixEl.appendChild(led);
            leds.push(led);
        }

        // Icono de Carita Feliz por defecto
        const happyPattern = [
            0,0,0,0,0,
            0,1,0,1,0,
            0,0,0,0,0,
            1,0,0,0,1,
            0,1,1,1,0
        ];

        const patternA = [
            0,0,1,0,0,
            0,1,0,1,0,
            0,1,1,1,0,
            0,1,0,1,0,
            0,1,0,1,0
        ];

        const patternB = [
            0,1,1,1,0,
            0,1,0,1,0,
            0,1,1,1,0,
            0,1,0,1,0,
            0,1,1,1,0
        ];

        function drawPattern(pattern) {
            for (let i = 0; i < 25; i++) {
                if (pattern[i] === 1) {
                    leds[i].classList.add('on');
                } else {
                    leds[i].classList.remove('on');
                }
            }
        }

        drawPattern(happyPattern);

        // Web Audio API para simulación sonora real
        let audioCtx = null;
        let isBusy = false;

        function playTone(freq, durationMs, callback) {
            if (!audioCtx) {
                audioCtx = new (window.AudioContext || window.webkitAudioContext)();
            }

            const osc = audioCtx.createOscillator();
            const gain = audioCtx.createGain();

            osc.type = 'square'; // Onda cuadrada para imitar el buzzer pasivo
            osc.frequency.value = freq;

            gain.gain.setValueAtTime(0.1, audioCtx.currentTime); // Volumen moderado

            osc.connect(gain);
            gain.connect(audioCtx.destination);

            osc.start();
            
            document.getElementById('freqDisplay').innerText = freq + " Hz";
            document.getElementById('waveIndicator').classList.add('active');

            setTimeout(() => {
                osc.stop();
                document.getElementById('freqDisplay').innerText = "0 Hz";
                document.getElementById('waveIndicator').classList.remove('active');
                if (callback) callback();
            }, durationMs);
        }

        function logSerial(key, value) {
            const consoleEl = document.getElementById('serialConsole');
            consoleEl.innerHTML += `> ${key}: ${value}<br>`;
            consoleEl.scrollTop = consoleEl.scrollHeight;
        }

        function pressButton(btn) {
            if (isBusy) return;
            isBusy = true;

            const btnA = document.getElementById('btnA');
            const btnB = document.getElementById('btnB');
            btnA.disabled = true;
            btnB.disabled = true;

            if (btn === 'A') {
                drawPattern(patternA);
                logSerial("tono_A", 523);
                playTone(523, 500, () => {
                    setTimeout(() => {
                        drawPattern(happyPattern);
                        btnA.disabled = false;
                        btnB.disabled = false;
                        isBusy = false;
                    }, 1000);
                });
            } else if (btn === 'B') {
                drawPattern(patternB);
                logSerial("tono_B", 784);
                playTone(784, 500, () => {
                    setTimeout(() => {
                        drawPattern(happyPattern);
                        btnA.disabled = false;
                        btnB.disabled = false;
                        isBusy = false;
                    }, 1000);
                });
            }
        }
    </script>
</body>
</html>

Cómo probarlo

1. Empareja la micro:bit mediante WebUSB en Chrome/Edge y pulsa Descargar para grabar el programa.
2. Al iniciar, la matriz de LEDs mostrará la carita feliz.
3. Pulsa el Botón A: la micro:bit emitirá una nota media (Do5 / 523 Hz) durante exactos 0,5 segundos y guardará 1 segundo de pausa.
4. Pulsa el Botón B: la micro:bit emitirá una nota más aguda (Sol5 / 784 Hz) durante 0,5 segundos.
5. Abre el monitor serie en MakeCode haciendo clic en Mostrar datos Dispositivo: verás cómo se grafican y registran los valores enviando tono_A = 523 y tono_B = 784.

Qué estamos midiendo realmente

• Magnitud física del sonido: La frecuencia del sonido se mide en hercios (Hz), que representa el número de oscilaciones u ondas completas por segundo que realiza la membrana del piezoeléctrico.
• Unidad de tiempo: Las pausas y duraciones se expresan en milisegundos (ms) ($1000\text{ ms} = 1\text{ segundo}$).
• Incertidumbre y límites del piezoeléctrico: Un zumbador pasivo educativo de bajo coste no es un altavoz de alta fidelidad. Su respuesta en frecuencia no es lineal: responde con mayor volumen en sus frecuencias de resonancia (habitualmente entre $2000\text{ Hz}$ y $4000\text{ Hz}$) y suena mucho más tenue en frecuencias graves por debajo de $300\text{ Hz}$.

Para el aula

• Pregunta de predicción: Si reducimos la pausa de $1000\text{ ms}$ a $100\text{ ms}$ y pulsamos el botón rápidamente, ¿qué le ocurre a la percepción del sonido por parte del oído humano?
• Experimento de resonancia: Prueba a programar frecuencias progresivas desde $100\text{ Hz}$ hasta $5000\text{ Hz}$ en pasos de $500\text{ Hz}$. ¿En qué frecuencia el zumbador emite el sonido más potente sin cambiar el volumen del programa?

Retos por niveles

• 2º ESO: Modifica la nota del Botón A para que toque un tono más grave ($262\text{ Hz}$, Do4) y cambia la duración a 1 pulso completo.
• 3º ESO: Programa un tercer tono distinto utilizando la combinación de pulsación simultánea A + B.
• 4º ESO: Crea una función de alarma progresiva: que el zumbador emita 3 pitidos cortos de $100\text{ ms}$ acelerados antes de la pausa de un segundo.
• 1º Bachillerato: Implementa una melodía de dos tonos alternados (estilo sirena de emergencia) controlando el ciclo de trabajo mediante temporizadores sin bloquear la ejecución con pausas fijas.

Para enseñárselo a los pequeños (versión monitor)

Pídeles que cierren los ojos. Pulsa el Botón A o el Botón B y pregúntales cuál ha sonado: «¿El tono del coche o el tono del camión?». Explícales que los animales de la sierra distinguen las alertas por lo «agudo» o «grave» del sonido, exactamente igual que hacemos nosotros con los instrumentos musicales.

OTROS CHISMES

• Chisme 146 · LED con micro:bit Primer proyecto de la serie para iniciarse en la placa de expansión Keyestudio (kit ks0361). Permite repasar la conexión de actuadores en las columnas G, V y S, así como el control digital de salidas.
• Chisme 149 · Mezcla de colores Proyecto para avanzar en la gestión de actuadores y eventos. Enseña a cambiar los estados de salida del módulo mediante las distintas combinaciones de los botones A, B y gestos de la micro:bit.
• Chisme 154 · Nivel de agua micro:bit Aplica la lógica de avisos acústicos y tonos de alarma (music.play) para indicar estados de alerta cuando un sensor analógico supera umbrales definidos.
• Chisme 147 · Termómetro con micro:bit Profundiza en el envío y representación de datos hacia el ordenador en tiempo real utilizando los bloques serial escribir valor y el emparejamiento por WebUSB.

Qué hemos aprendido

Hemos comprobado la diferencia fundamental entre un actuador todoterreno rígido y un dispositivo modulable. Un zumbador pasivo no requiere combinaciones complejas de hardware para emitir alertas ricas en información: basta con programar la frecuencia en Hz adecuada y controlar estrictamente los tiempos de emisión y silencio.

El Lince de la Noche desconectó la micro:bit y volvió a colocar la placa en su caja de herramientas con una sonrisa de satisfacción.

—Medio segundo de aviso en Do alto para el sendero peatonal y medio segundo en Sol alto para la pista de vehículos —resumió el Lince—. Ni asustamos a los animales ni gastamos la batería en vano.

La Gata Montesa volvió a abrir sus cuadernos de campo mientras guardaba el zumbador en su compartimento.

—Perfecto, Víctor. La tecnología útil es la que se escucha cuando hace falta y se calla el resto del tiempo.