Cómo usar un Zumbador Pasivo con Arduino

¡Hola, equipo de futuros ingenieros e ingenieras! Bienvenidos de nuevo a Ingtelecto. Si en nuestro tutorial anterior sobre el zumbador activo aprendimos a generar ruido de forma "manual", encendiendo y apagando un pin, hoy vamos a subir de nivel y convertirnos en verdaderos músicos digitales. 🎸

En esta lección, vamos a dominar el zumbador pasivo. A diferencia de su hermano "activo" que solo sabe gritar un tono, el pasivo es como un instrumento: ¡nosotros decidimos qué nota tocar!

Usaremos la función estrella de Arduino para sonido, tone(), para programar y reproducir la escala musical completa de Do mayor: desde Do (262Hz), Re (294Hz), Mi (330Hz), Fa (349Hz), Sol (392Hz), La (440Hz), Si (494Hz) hasta el Do agudo (524Hz).

Este proyecto es la base para crear melodías de videojuegos, tonos de alarma personalizados, efectos de sonido para tus robots y mucho más. ¡Prepárate para darle voz a tus proyectos!

Materiales Necesarios para el Proyecto

Para esta práctica, solo necesitas 4 componentes básicos. ¡Es el circuito perfecto para empezar!

Nuestros materiales deberán verse así:

⚙️ La Verdadera Magia del Sonido

Antes de conectar, vamos a profundizar en la teoría. Entender esto es la diferencia entre "copiar y pegar" y "saber lo que estás haciendo", te recomiendo analizar cada concepto para que no tengas complicaciones a la hora de hacer la programación requerida.

Repaso Rápido: Activo vs. Pasivo (¡No te confundas!)

Como ya explicamos en detalle en nuestro tutorial sobre el zumbador activo, la diferencia es crítica:

• Zumbador ACTIVO: Tiene un circuito interno (oscilador). Solo necesita energía (digitalWrite(pin, HIGH)) para emitir un único tono fijo. Es un timbre.
• Zumbador PASIVO: Es "tonto". No tiene oscilador. Es solo un diafragma que vibra. Para que suene, debemos enviarle una señal que vibre (una onda cuadrada) a la frecuencia de la nota que queremos tocar. Es un altavoz simple.

Hoy usamos el pasivo, porque queremos controlar la nota.

Del Control Manual al "Profesional" con tone()

En el tutorial anterior, creamos sonido "manualmente" (un método llamado bit-banging) con un código así:

Esto funciona, pero tiene dos problemas gigantes:

1. Es Bloqueante: La función delay() congela el microcontrolador. Mientras suena la nota, el Arduino no puede hacer NADA MÁS (como leer un sensor o un botón).
2. Es Complicado: Tienes que calcular manualmente los microsegundos para cada frecuencia (ej. para 500Hz, el periodo es 1/500 = 0.002s = 2000µs, por lo que usas dos delays de 1000µs). Es un lío.

La Solución: tone() y los Hardware Timers

El microcontrolador de Arduino (el ATmega328P) tiene componentes internos llamados "Timers/Counters". Son como pequeños cronómetros de hardware que pueden funcionar por su cuenta.

La función tone(pin, frecuencia) es un comando de alto nivel que le dice a uno de estos timers: "Oye, empieza a generar una onda cuadrada perfecta (50% de ciclo de trabajo) en este pin, a esta frecuencia, y hazlo en segundo plano".

¡Esto es increíble! El timer se encarga de todo el trabajo de "HIGH-LOW-HIGH-LOW" sin que el bucle principal (void loop()) se detenga. Libera a tu procesador para que haga otras tareas.

Sintaxis de tone() y noTone()

• tone(pin, frecuencia);Toca una nota (frecuencia en Hz) en un pin de forma indefinida.
• tone(pin, frecuencia, duracion);Toca la nota en el pin con esa frecuencia solo durante duracion milisegundos.
• noTone(pin);Detiene inmediatamente cualquier sonido que se esté generando en ese pin.

🔌 Diagrama de Conexiones (Hardware)

Este montaje es uno de los más sencillos en Arduino. ¡Solo dos cables!

Tabla de Conexiones

Diagrama Esquemático

Así se ve el circuito a nivel de componentes.

Diagrama de Montaje (Protoboard)

Y así es como debes conectarlo en tu placa de pruebas.

Explicación Detallada de las Conexiones

Sigue estos pasos con calma. ¡Vamos a explicar el "por qué" de cada cable!

1. Paso 1: Identifica tu Zumbador PasivoToma tu zumbador. La mayoría de los zumbadores (activos o pasivos) tienen polaridad. Busca un símbolo "+" en la carcasa de plástico. Si no lo tiene, fíjate en las patas: la pata más larga es la Positiva (+).
2. Paso 2: Coloca el ZumbadorInserta el zumbador en la protoboard. Asegúrate de que sus dos patas queden en filas (columnas de 5 agujeros) diferentes.
3. Paso 3: Conecta a Tierra (GND)Toma un cable de puente (te recomiendo usar uno negro, por convención). Conecta un extremo a uno de los pines GND (Ground o Tierra) de tu placa Arduino. El otro extremo conéctalo a la fila de la protoboard donde está la pata Negativa (-) (la corta) del zumbador.¿Por qué? El GND es el punto de referencia 0V para todo el circuito. Es el "suelo" eléctrico.
4. Paso 4: Conecta la Señal (Pin 12)Toma otro cable (de cualquier otro color). Conecta un extremo al Pin Digital 12 del Arduino. El otro extremo conéctalo a la fila de la protoboard donde está la pata Positiva (+) (la larga) del zumbador.¿Por qué? Este es el pin desde el cual el Arduino enviará la señal de onda cuadrada (la "vibración" eléctrica) que el zumbador convertirá en sonido. Gracias a tone(), podemos usar casi cualquier pin digital, no solo los PWM.

¡Listo! El hardware está completo.

💻 El Código: Programando la Escala Musical

Ahora, ¡vamos a componer! Abre tu Arduino IDE, crea un nuevo sketch, y pega el siguiente código. Lo hemos limpiado y comentado a fondo para ti.

Recuerda que puedes descargar el código desde nuestro GitHub: Código de Arduino en GitHub

/*Este código demuestra el uso de la función tone()

con el parámetro de duración.

*/
// --- 1. Definición de las Frecuencias (en Hz) ---

// Creamos variables para hacer el código legible.

// Estos son los estándares de la escala temperada.

int Do = 262;

int Re = 294;

int Mi = 330;

int Fa = 349;

int Sol = 392;

int La = 440; // Frecuencia estándar de afinación (La 4)

int Si = 494;

int Do2 = 524; // Do agudo (una octava arriba)
// --- 2. Definición de Pines y Variables ---

int buzz = 12; // Pin digital donde conectamos el zumbador

int wait = 500; // Variable para la DURACIÓN de la nota (en ms)
// --- 3. Configuración Inicial (se ejecuta UNA vez) ---

void setup() {

// Configuramos el pin del zumbador como una SALIDA.

// El Arduino enviará una señal HACIA el zumbador.

pinMode(buzz, OUTPUT);

}
// --- 4. Bucle Principal (se repite indefinidamente) ---

void loop() {
// Tocar la escala nota por nota
// Toca Do (262Hz) por 500ms

tone(buzz, Do, wait);

// Espera 1 segundo ANTES de tocar la siguiente nota

delay(1000);
// Toca Re (294Hz) por 500ms

tone(buzz, Re, wait);

delay(1000); // Espera 1s
// Toca Mi (330Hz) por 500ms

tone(buzz, Mi, wait);

delay(1000); // Espera 1s
// Toca Fa (349Hz) por 500ms

tone(buzz, Fa, wait);

delay(1000); // Espera 1s
// Toca Sol (392Hz) por 500ms

tone(buzz, Sol, wait);

delay(1000); // Espera 1s
// Toca La (440Hz) por 500ms

tone(buzz, La, wait);

delay(1000); // Espera 1s
// Toca Si (494Hz) por 500ms

tone(buzz, Si, wait);

delay(1000); // Espera 1s
// Toca Do Agudo (524Hz) por 500ms

tone(buzz, Do2, wait);

delay(1000); // Espera 1s
// Detenemos cualquier sonido por si acaso.

// Buena práctica antes de que el loop repita.

noTone(buzz);

}

🧠 Explicación Detallada del Código (Línea por Línea)

No te limites a copiar y pegar. ¡Entendamos qué hace cada instrucción!

Definición de Notas (¡Nuestra Partitura!)

• int Do = 262;, int Re = 294;, etc.Declaramos variables de tipo entero (int) para guardar las frecuencias (en Hertz) de cada nota. Esto es una práctica de código limpio. Es mucho más fácil leer tone(buzz, Do, wait); que tone(12, 262, 500);.

Variables Globales

• int buzz = 12;Asignamos el pin 12 a una variable. Si mañana queremos mover el zumbador al pin 8, solo cambiamos este número en un lugar.
• int wait = 500;Esta variable guardará la duración de la nota (medio segundo).

La Configuración: void setup()

• pinMode(buzz, OUTPUT);Esta función, que se ejecuta una sola vez, le dice al Arduino que el pin 12 será una SALIDA. Es decir, enviaremos voltaje desde el Arduino hacia el zumbador.

El Bucle Principal: void loop()

Aquí ocurre toda la acción, repitiéndose para siempre.

La Lógica del Ritmo: tone() + delay()

Esta es la parte más importante y sutil del código. Analicemos el primer compás:

Mucha gente se confunde aquí. Esto es lo que pasa exactamente:

1. Tiempo 0ms: Se ejecuta tone(buzz, Do, 500);. El Arduino le dice al timer de hardware: "Empieza a generar 262Hz en el pin 12. Hazlo por 500ms y luego apágate solo".
2. Tiempo 0.001ms (aprox): El código NO SE ESPERA. Sigue inmediatamente a la siguiente línea.
3. Tiempo 0.002ms (aprox): Se ejecuta delay(1000);. Ahora sí, el programa principal se congela. No hará nada más durante 1000 milisegundos (1 segundo).
4. Mientras tanto... En segundo plano, el timer de hardware sigue tocando la nota "Do".
5. Tiempo 500ms: El timer de hardware termina su tarea. La nota "Do" se apaga automáticamente.
6. Tiempo 501ms a 1000ms: El programa principal SIGUE congelado por el delay(). Como la nota ya se apagó, hay silencio.
7. Tiempo 1001ms: El delay(1000); termina. El programa avanza a la siguiente línea, que es tone(buzz, Re, wait);, y todo el ciclo se repite.

Conclusión: Esta lógica crea un ritmo perfecto de 0.5 segundos de nota, seguido de 0.5 segundos de silencio, antes de pasar a la siguiente nota.

La Parada Final: noTone(buzz);

• noTone(buzz);Al final del loop(), usamos noTone(buzz). Aunque en este código cada nota tiene una duración definida, es una excelente práctica de programación. Asegura que cualquier sonido se detenga por completo antes de que el bucle comience de nuevo.

🚀 Resultado Esperado

Una vez que hayas verificado tu placa y puerto en el menú Herramientas y subido el código a tu Arduino UNO...

¡Deberías escuchar música! El zumbador pasivo comenzará a tocar la escala musical: Do, Re, Mi, Fa, Sol, La, Si, Do Agudo. Cada nota sonará limpiamente durante medio segundo, seguida de medio segundo de silencio, creando un ritmo claro y constante (Do... pausa... Re... pausa...).

🚨 ¿No funciona? Guía Rápida de Solución de Problemas

🚀 ¡Felicidades! Ahora eres un Músico Digital