Jardin de Conocimiento

Arduino · Módulo 07 · Ej 02 — Tocar una melodía simple (una escala ascendente) con un buzzer y…

8 min read

Ejercicio 02 — Tocar una melodía simple (una escala ascendente) con un buzzer y…

Dificultad: verde · Módulo 07 (Actuadores y potencia)

Enunciado

Tocar una melodía simple (una escala ascendente) con un buzzer y tone().

Montaje (Arduino UNO)

Buzzer pasivo: una pata al pin 8, la otra a GND. (Si tu buzzer tiene +/-, el + va al pin 8.) Nota: tone() usa un buzzer PASIVO. Un buzzer ACTIVO ya tiene su tono fijo y solo se enciende/apaga con digitalWrite.

Cómo se resuelve

Un actuador no tiene por qué moverse: el buzzer convierte una señal eléctrica en sonido, y el sonido no es más que una vibración a una frecuencia determinada. tone() genera en un pin una onda cuadrada de la frecuencia que le pidas, y esa onda hace vibrar el disco piezoeléctrico del buzzer. Si la frecuencia es la de una nota, oyes esa nota.

Por eso lo primero del programa es una tabla de frecuencias con nombre:

const int DO  = 262;
const int RE  = 294;
const int MI  = 330;
const int FA  = 349;
const int SOL = 392;
const int LA  = 440;
const int SI  = 494;
const int DO2 = 523;

Son hercios. LA = 440 es el la de referencia con el que se afinan las orquestas, y DO2 = 523 es el do de la octava siguiente al DO = 262 — fíjate en que es casi exactamente el doble, que es lo que significa subir una octava. Escribirlas como constantes con nombre en vez de sembrar números por el código es la misma buena costumbre del const int LED = 8 del módulo 01, solo que aquí además convierte el programa en algo legible: la melodía se lee como música.

Y la melodía es literalmente una lista:

int melodia[] = { DO, RE, MI, FA, SOL, LA, SI, DO2 };
const int N_NOTAS = 8;

Un array con las ocho notas de la escala en orden, más una constante con cuántas hay. Separar la estructura (recorrer una lista y tocar cada elemento) de los datos (qué notas y en qué orden) es lo que hace que puedas cambiar la canción sin tocar el bucle. Si añades notas, recuerda actualizar N_NOTAS.

El setup() está vacío a propósito, y el comentario lo explica: tone() configura el pin internamente, así que aquí no hace falta ningún pinMode. Es una de las pocas funciones de salida de Arduino de las que se puede decir eso.

El loop() es el recorrido:

for (int i = 0; i < N_NOTAS; i++) {
    tone(PIN_BUZZER, melodia[i], 300);
    delay(350);
}
noTone(PIN_BUZZER);
delay(1500);

tone() con tres argumentos recibe el pin, la frecuencia y una duración en milisegundos: aquí, sonar la nota i durante 300 ms. Lo importante es que esa tercera forma no bloquea. tone() arranca el sonido y devuelve el control inmediatamente; el temporizador del chip se encarga de cortarlo a los 300 ms por su cuenta. Es decir, si no pusieras nada detrás, el for avanzaría al instante y las ocho notas se pisarían unas a otras: solo oirías la última.

De ahí el delay(350). Es el que da a cada nota su hueco real en el tiempo: 300 ms sonando más 50 ms de silencio antes de la siguiente. Esos 50 ms de diferencia entre la duración de la nota y la espera son los que hacen que la escala se oiga como ocho notas separadas y no como un glissando continuo. Sube el delay a 600 y la escala se vuelve lenta y picada; bájalo a 300 exactos y las notas se pegan. Es un parámetro musical, no un detalle técnico.

Terminada la escala, noTone(PIN_BUZZER) asegura el silencio. En rigor no hace falta, porque la última nota ya se apagó sola a los 300 ms y delay(350) ha esperado más que eso; está ahí como red de seguridad y como costumbre, porque el día que llames a tone() sin duración el sonido no para hasta que alguien lo pare. Después, delay(1500) deja un segundo y medio de pausa antes de que loop() repita la escala, para que se distinga una repetición de la siguiente.

El montaje es de lo más simple del curso: una pata del buzzer al pin 8 y la otra a GND. Si tu buzzer trae marcado el +, ese es el que va al pin 8.

Y aquí está el punto que decide si el ejercicio funciona o no, y que no está en el código: el buzzer tiene que ser pasivo. Un buzzer pasivo es un piezo desnudo, no suena por sí solo y reproduce la frecuencia que le llegue de fuera; por eso puede tocar una escala. Un buzzer activo lleva su propio oscilador dentro: le das tensión y pita en su única nota, la que trae de fábrica, y tone() no cambia nada. Si al ejecutar esto oyes ocho pitidos idénticos, no busques el error en el for: tienes un buzzer activo. Los activos se manejan con digitalWrite y valen para avisos, no para melodías.

Un último apunte de los que se olvidan y luego dan guerra: tone() usa un temporizador del chip, el mismo del PWM de los pines 3 y 11 en el UNO. Mientras suena algo, analogWrite no funciona en esos dos pines.

Para practicar — cópialo y complétalo

Pega este esqueleto y completa los TODO. Es la mejor forma de aprender: inténtalo antes de mirar la solución.

/*
 * Curso de Arduino — Módulo 07: Actuadores y potencia
 * Ejercicio 02 — PRÁCTICA (rellena los TODO)
 * Enunciado: Tocar una melodía simple (una escala ascendente) con un buzzer y tone().
 * Dificultad: verde
 * Placa: Arduino UNO
 * Montaje: buzzer pasivo: una pata al pin 8, la otra a GND.
 * Correr: Arduino IDE / Wokwi (wokwi/ej02) / arduino-cli (ver README)
 */
const int PIN_BUZZER = 8;
 
const int DO  = 262;
const int RE  = 294;
const int MI  = 330;
const int FA  = 349;
const int SOL = 392;
const int LA  = 440;
const int SI  = 494;
const int DO2 = 523;
 
int melodia[] = { DO, RE, MI, FA, SOL, LA, SI, DO2 };
const int N_NOTAS = 8;
 
void setup() {
    // nada que configurar: tone() prepara el pin solo
}
 
void loop() {
    // TODO: bucle for i de 0 a N_NOTAS-1:
    //         tone(PIN_BUZZER, melodia[i], 300);  // suena la nota i
    //         delay(350);                         // espera (nota + silencio)
    // TODO: noTone(PIN_BUZZER) para silenciar al terminar
    // TODO: delay(1500) antes de repetir
}

Solución — cópiala y ejecútala

/*
 * Curso de Arduino — Módulo 07: Actuadores y potencia
 * Ejercicio 02 — MODELO (resuelto)
 * Enunciado: Tocar una melodía simple (una escala ascendente) con un buzzer y tone().
 * Dificultad: verde
 * Placa: Arduino UNO
 * Montaje: buzzer pasivo: una pata al pin 8, la otra a GND.
 *          (Si tu buzzer tiene +/-, el + va al pin 8.)
 * Nota: tone() usa un buzzer PASIVO. Un buzzer ACTIVO ya tiene su tono fijo
 *       y solo se enciende/apaga con digitalWrite.
 * Correr: Arduino IDE / Wokwi (wokwi/ej02) / arduino-cli (ver README)
 */
const int PIN_BUZZER = 8;
 
// Frecuencias de las notas en Hz (cuarta/quinta octava)
const int DO  = 262;
const int RE  = 294;
const int MI  = 330;
const int FA  = 349;
const int SOL = 392;
const int LA  = 440;
const int SI  = 494;
const int DO2 = 523;
 
// La melodía: lista de notas a tocar en orden
int melodia[] = { DO, RE, MI, FA, SOL, LA, SI, DO2 };
const int N_NOTAS = 8;
 
void setup() {
    // tone() configura el pin internamente; no hace falta pinMode aquí.
}
 
void loop() {
    for (int i = 0; i < N_NOTAS; i++) {
        tone(PIN_BUZZER, melodia[i], 300);  // sonar la nota i durante 300 ms
        delay(350);                         // 300 ms de nota + 50 ms de silencio entre notas
    }
    noTone(PIN_BUZZER);   // asegurar silencio
    delay(1500);          // pausa antes de repetir la melodía
}

Cómo ejecutar la simulación

Sin instalar nada, en el navegador

  1. Abre wokwi.com y crea un proyecto nuevo de la placa que pide el ejercicio.
  2. Pega la solución (o tu intento) en la pestaña sketch.ino.
  3. Abre la pestaña diagram.json, borra lo que haya y pega el circuito de aquí abajo.
  4. Dale al play. Verás el circuito funcionando: LEDs, pantallas y monitor serie.
Circuito del ejercicio (diagram.json) 
{
  "version": 1,
  "author": "ESIBot",
  "editor": "wokwi",
  "parts": [
    { "type": "wokwi-arduino-uno", "id": "uno", "top": 0, "left": 0, "attrs": {} },
    { "type": "wokwi-buzzer", "id": "bz1", "top": -80, "left": 160, "attrs": { "volume": "0.1" } }
  ],
  "connections": [
    [ "bz1:1", "uno:8", "green", [] ],
    [ "bz1:2", "uno:GND.1", "black", [] ]
  ],
  "dependencies": {}
}

En VS Code, con el repo del curso

El paquete de simulación de este ejercicio está en practica/07-actuadores-y-potencia/wokwi/ej02/. Con la extensión Wokwi instalada y la licencia activada (lo cuenta el onboarding del curso):

make sim EJ=07-actuadores-y-potencia/ej02

y después, en VS Code, Ctrl+Shift+P → Wokwi: Start Simulator. La extensión no compila: simula un firmware ya compilado, y de compilarlo se encarga ese make.

Cómo usarlo

Con placa: abre el .ino en el Arduino IDE, elige placa y puerto y pulsa Subir. Sin placa: simulalo en Wokwi con cualquiera de las dos vias de arriba. Antes de mirar la solucion, intenta completar tu el esqueleto: es la mejor forma de aprender.

Conexiones

Graph View

Backlinks