Como adelantábamos en un post anterior sobre la emulación del robot Zumo32 con un ATMEGA, en este post vamos a tratar un tema tana atractivo con el sonido usando para ello solo el buzzer emulado (ojo porqeu solo disponemos de un unico bit para obtener toda la funcionalidad).

Para los amigos lectores que se pregunten si es equivalente en ambiente Arduino la instrucción tone (puzzer_pin,nota) por buzzer.playNote(nota,1000,15),  NO son equivalentes exactamente, dado que la primera instrucción corresponde al código nativo de Arduino , y el segundo requiere la librería de Zumo32 y por tanto va condicionada a usar un Zumo32 o en su defecto un Arduino Leonardo ( de modo que en nuestro Atmega32 no podremos usar el segundo a no ser que modifiquemos la librería original.

tone(BUZZER_PIN, nota) y buzzer.playNote(nota, 1000, 15) tienen diferencias funcionales críticas:

Diferencias Técnicas

Aspecto	tone(pin, freq)	buzzer.playNote(freq, duration, octave)
Librería	✅ Nativa Arduino	❌ Zumo32U4Buzzer (solo 32U4)
Duración	Infinita (hasta noTone())	1000ms (automática)
Octava	Ignora parámetro	Octava 15 (frecuencia alterada)
Volumen	Fijo	Variable (polifonía Zumo)
Blocking	✅ No bloquea	❌ Puede bloquear

Por tanto el código  CORRECTO

tone(BUZZER_PIN, notas[notaActual]);  // Reproduce INDEFINIDAMENTE
// ...
noTone(BUZZER_PIN);  // Para manualmente

Funciona perfecto en ATmega328P sin librerías externas.​

buzzer.playNote() Sintaxis Completa

cpp// Zumo32U4Buzzer (SOLO ATmega32U4)
buzzer.playNote(NOTE_C(4), 1000);  // Frecuencia C4, 1000ms

Parámetros:

• nota: NOTE_C(4), NOTE_G(5), etc. (predefinidas)
• duration: ms automático
• octave: 0-8 (no 15, error en tu ejemplo)

Equivalencia Aproximada (No Exacta)

// ANTES (tu código - CORRECTO)
tone(BUZZER_PIN, 262);  // C4 infinito
delay(1000);
noTone(BUZZER_PIN);

// "Similar" a:
buzzer.playNote(NOTE_C(4), 1000);  // C4 x 1s automático

Recomendación para la emulacion de Zumo32 con ATmega328P:

Mantén tone() + noTone() – es más preciso y flexible:

// Tu código actual es ÓPTIMO
if (millis() - tiempoInicio >= 1000) {
  tone(BUZZER_PIN, notas[notaActual]);
  // ... display
  // noTone() en pausas
}

A cambio buzzer.playNote() solo para Zumo32U4 real (no para una emulación con ATmega328P pero si funcional para Arduino Leornardo).

​EJEMPLO PRACTICO CON LA EMULACION DEL ZUMO 32 EN UNA PLACA ARDUINO ATMEGA32

Para comprender la potencia de no trabajar con librerías externas donde se supone que esta todo hecho , pero que a cambio no dejan apenas flexibilidad al programador , vamos a ver un ejemplo de como reproducir tres escalas musicales con la emulación de Zumo usando un ATmega328P o en la práctica cualquier Arduino:

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x3F, 16, 2);

#define BUZZER_PIN 6
#define BUTTON_A_PIN A0
#define BUTTON_B_PIN 4
#define BUTTON_C_PIN A3
#define LED_YELLOW_PIN 13
#define LED_RED_PIN 12

bool ledYellowState = false;
bool lastBtnA = false, lastBtnB = false;

// Escala completa C3 (130Hz) → B5 (1976Hz) - 3 octavas
int notas[] = {
  // C3 (65*2=130), D3(73*2=146), E3(82*2=164), F3(87*2=174), G3(98*2=196), A3(110*2=220), B3(123*2=246)
  130, 146, 164, 174, 196, 220, 246,
  // C4 (262), D4(294), E4(330), F4(349), G4(392), A4(440), B4(494)
  262, 294, 330, 349, 392, 440, 494,
  // C5 (523), D5(587), E5(659), F5(698), G5(784), A5(880), B5(988)
  523, 587, 659, 698, 784, 880, 988
};

String nombres[] = {
  "C3","D3","E3","F3","G3","A3","B3",
  "C4","D4","E4","F4","G4","A4","B4",
  "C5","D5","E5","F5","G5","A5","B5"
};

int numNotas = 21;  // 3 octavas × 7 notas
int escalaActual = 0;  // 0,1,2 (3 escalas)

void setup() {
  Wire.begin();
  lcd.init(); lcd.backlight(); lcd.clear();
  lcd.setCursor(0,0); lcd.print("3 Escalas C3-B5");
  lcd.setCursor(0,1); lcd.print("Iniciando...");
  delay(2000);
  
  pinMode(BUTTON_A_PIN, INPUT_PULLUP);
  pinMode(BUTTON_B_PIN, INPUT_PULLUP);
  pinMode(BUTTON_C_PIN, INPUT_PULLUP);
  pinMode(LED_YELLOW_PIN, OUTPUT);
  pinMode(LED_RED_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
}

void loop() {
  bool btnA = digitalRead(BUTTON_A_PIN) == LOW;
  bool btnB = digitalRead(BUTTON_B_PIN) == LOW;
  bool btnC = digitalRead(BUTTON_C_PIN) == LOW;
  
  // Toggle LED Amarillo
  bool btnA_pressed = btnA && !lastBtnA;
  bool btnB_pressed = btnB && !lastBtnB;
  if (btnA_pressed) ledYellowState = true;
  if (btnB_pressed) ledYellowState = false;
  digitalWrite(LED_YELLOW_PIN, ledYellowState);
  digitalWrite(LED_RED_PIN, !btnA);
  
  // REPRODUCCIÓN 3 ESCALAS COMPLETAS C3→B5
  static int notaActual = 0;
  static unsigned long tiempoInicio = 0;
  static bool reproduciendo = true;
  
  if (reproduciendo && millis() - tiempoInicio >= 1000) {
    tone(BUZZER_PIN, notas[notaActual]);
    
    // Mostrar nota actual
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Escala "); lcd.print(escalaActual + 1);
    lcd.print("/3 Nota:");
    
    lcd.setCursor(0, 1);
    lcd.print(nombres[notaActual]);
    lcd.print(" "); lcd.print(notas[notaActual]);
    lcd.print("Hz ");
    
    notaActual++;
    
    if (notaActual >= 7) {  // Fin de escala (7 notas)
      escalaActual++;
      notaActual = 0;
      noTone(BUZZER_PIN);
      delay(500);  // Pausa entre escalas
    }
    
    if (escalaActual >= 3) {  // 3 escalas completas
      reproduciendo = false;
      lcd.clear();
      lcd.setCursor(0,0); lcd.print("3 ESCALAS OK!");
      lcd.setCursor(0,1); lcd.print("C3-B5 Fin");
      noTone(BUZZER_PIN);
    }
    
    tiempoInicio = millis();
  }
  
  lastBtnA = btnA;
  lastBtnB = btnB;
  delay(10);
}

Este código extiende la emulación del Zumo32U4 añadiendo un buzzer musical que reproduce automáticamente 3 escalas completas (C3-B5) usando la función tone(), mientras mantiene el control de LEDs y pulsadores del ejemplo anterior. En setup() inicializa el LCD I2C (0x3F), configura los pines (A0=A, 4=B, A3=C para botones; 13=amarillo, 12=rojo, 6=buzzer) y muestra «3 Escalas C3-B5». Define dos arrays paralelos: notas[] con 21 frecuencias (130Hz C3 hasta 988Hz B5, 3 octavas × 7 notas diatónicas) y nombres[] con sus identificadores («C3″,»D3″,…,»B5»).​

En loop(), primero gestiona los botones con detección de flanco (anti-rebote): A enciende LED amarillo (latch), B apaga LED amarillo (latch), LED rojo sigue inverso de A instantáneamente. Luego, una máquina de estados automática con variables static (notaActual, tiempoInicio, reproduciendo) reproduce las escalas: cada 1000ms llama tone(6, frecuencia) de la nota actual, actualiza el LCD mostrando «Escala X/3 Nota: Nombre frecuenciaHz», avanza notaActual. Al llegar a la 7ª nota (fin escala), pasa a la siguiente escalaActual, pausa 500ms con noTone() y reinicia notaActual=0. Tras 3 escalas (21 notas total), para con reproduciendo=false y mensaje «3 ESCALAS OK!».

La reproducción es no bloqueante (usa millis() para timing), permitiendo que los botones respondan simultáneamente. El delay(10) final estabiliza lecturas sin interferir con los 1000ms de nota. Emula perfectamente el Zumo32U4Buzzer de Pololu, que usa PWM en pin 6 (PD7) para tonos precisos, demostrando control musical preciso en ATmega328P con pines mapeados equivalentes (pin 6 Uno → pin 6/PD7 Zumo).

En el siguiente video podemos ver el código anterior explicado por el autor que escribe estas líneas https://youtube.com/shorts/QYoSJSKwREc?feature=share

En el siguiente ejemplo ahora podemos ver para la misma funcionalidad (a excepción del LCD y los leds) las grandes diferencias del código anterior con el código para el propio robot usando su librería Zumo32U4 en lugar de código nativo.

#include <Wire.h>
#include <Zumo32U4.h>

Zumo32U4Buzzer buzzer;

void setup() {
}

void loop() {
  buzzer.playFrequency(440, 200, 12);
  delay(1000);

  for (int i = 3; i <= 5; i++) {

    buzzer.playFrequency(NOTE_C(i), 1000, 15);
    while (buzzer.isPlaying()) {}
    delay(1000);

    buzzer.playFrequency(NOTE_D(i), 1000, 15);
    while (buzzer.isPlaying()) {}
    delay(1000);

    buzzer.playFrequency(NOTE_E(i), 1000, 15);
    while (buzzer.isPlaying()) {}
    delay(1000);

    buzzer.playFrequency(NOTE_F(i), 1000, 15);
    while (buzzer.isPlaying()) {}
    delay(1000);

    buzzer.playFrequency(NOTE_G(i), 1000, 15);
    while (buzzer.isPlaying()) {}
    delay(1000);

    buzzer.playFrequency(NOTE_A(i), 1000, 15);
    while (buzzer.isPlaying()) {}
    delay(1000);

    buzzer.playFrequency(NOTE_B(i), 1000, 15);
    while (buzzer.isPlaying()) {}
    delay(1000);
  }
}

Este programa como ya adelantábamos usa la librería del Zumo32U4 para que el robot reproduzca tonos musicales con su zumbador integrado. Primero crea un objeto Zumo32U4Buzzer y, en el loop(), genera un pitido inicial de 440 Hz durante 200 ms con volumen 12 y espera 1 segundo. Después entra en un bucle for que recorre las octavas 3, 4 y 5; en cada octava va llamando a buzzer.playFrequency(NOTE_C(i) ... NOTE_B(i)) para reproducir las siete notas de la escala (Do, Re, Mi, Fa, Sol, La, Si) con duración de 1 segundo y volumen 15, esperando a que termine cada nota con while (buzzer.isPlaying()) {} y añadiendo un segundo de pausa entre ellas, de forma que se escuchan tres escalas ascendentes completas en distintas octavas usando las constantes de nota que proporciona la propia librería del Zumo32U4​.