Difference between Active and Passive Buzzer? How to create your own music?

Introduction

The buzzer consists of a vibrating blade with the piezoelectric effect.

Piezoelectricity is a property possessed by certain minerals that deform when subjected to an electric field. It allows the transformation of electrical energy into vibration, enabling the production of simple notes and melodies.

Buzzers can be found in alarm devices, computers, timers, and more. There are two types of buzzers: Active and Passive buzzers.

What is the difference between an Active and Passive Buzzer?

There are some fundamental differences between Active and Passive buzzers:

Active Buzzer: It can generate sound when it receives a continuous voltage.

Passive Buzzer: Functions like a speaker, so an audio signal needs to be provided for it to produce sound.

To differentiate between the two, you can apply a continuous voltage to both buzzers. The one that emits sound will be the active buzzer. However, both buzzers operate similarly, which is why the programs we will propose will be the same for both types.

Electronic Symbol of the Buzzer

The electronic symbol of the buzzer is composed of two circles with a plus sign (+).

Library

To make the program work, you need to install the library dedicated to the buzzer. This library contains all the notes playable by the buzzer. The buzzer library is in .zip format, so to install it, click on “Sketch,” then “Include Library,” and “Add .Zip Library.”

If you encounter any problems installing the library, we recommend checking out our dedicated tutorial.

How to do without the library?

There are other types of possible notes that you can play. For this, you can use the library and input the note reference as in the melody list of the program or directly input the frequency.

By directly inputting the frequency, you no longer need to add the library to your code.

Buzzer Programming

As we have just seen, we can program the buzzer with or without the library.

A) Code with the library

Here is the function to program your buzzer with the library:

tone(Pin,Note,Duration);

Pin: The pin to which your buzzer is connected.
Note: The note in frequency Hz.
Duration: The duration you want the note to be played.

You will find an example of using this function in the programs below.

B) Code without the library

Here is the function to program your buzzer without the library:

digitalWrite(Pin_buzzer,HIGH);

Buzzer Pin: The pin number where you have connected the buzzer.
HIGH/LOW: Used to turn on/off the buzzer.

You will find an example of using this function in the programs below.

Buzzer Circuits

Now, let’s see the circuits you need to create to use the programs. All codes work with these circuits.

A) Passive Buzzer

Here is the schema for the passive buzzer:

B) Active Buzzer

Here is the schema for the active buzzer:

To replicate the schema of the active buzzer on Fritzing, you need to install the active buzzer component. We recommend our Fritzing course if you have difficulty installing the component.

Code for the Buzzer

We will present two codes to make your buzzer work. The first one works with the library, and the second one works without it.

Here you have a sequence of notes from low to high using the library:

#include "pitches.h" // Library for the passive buzzer 
 
// note for the melody
int melody[] = {NOTE_C5, NOTE_D5, NOTE_E5, NOTE_F5, NOTE_G5, NOTE_A5, NOTE_B5, NOTE_C6}; // Here is the note included in the Library 
int duration = 500;  // duration for each melody  
 
void setup() {
}
 
void loop() {  
  for (int thisNote = 0; thisNote < 8; thisNote++) { // For all Note of the melody list
    tone(13, melody[thisNote], duration); // duration of the note played
    delay(1000); // New notes after one second of break
  }
  delay(2000);
}

Here you have an alarm without the library:

int buzzer = 13;// Pin of the active buzzer
void setup()
{
 pinMode(buzzer,OUTPUT);//We initialize the pin of the buzzer as an output
}
void loop()
{
 unsigned char i; //  counting each loop 
 while(1) //  Infinite loop
 {
   //first note
   for(i=0;i<80;i++)
   {
    digitalWrite(buzzer,HIGH); // Buzzer on 
    delay(1);//break 
    digitalWrite(buzzer,LOW); // buzzer off
    delay(1);//break
    }
    //Second note
     for(i=0;i<100;i++)
      {
        digitalWrite(buzzer,HIGH); // buzzer on
        delay(2);//break
        digitalWrite(buzzer,LOW); // buzzer offf
        delay(2);//break
      }
  }
}

How to play your own music?

As we have seen, we can play multiple notes with our buzzer. But it’s essential to find a good melody. For this, we recommend translating the notes from a sheet music you have chosen into frequency Hz.

For example, we have translated the song “Jingle Bells” as follows:

#define Pin_buzzer 13

// Jingle Bells

int melody = {
  659, 659, 659,
  659, 659, 659,
  659, 784, 523, 587,
  659,
  698, 698, 698, 698,
  698, 659, 659, 659, 659,
  659, 587, 587, 659,
  587, 784
};

int tempo[] = {
  8, 8, 4,
  8, 8, 4,
  8, 8, 8, 8,
  2,
  8, 8, 8, 8,
  8, 8, 8, 16, 16,
  8, 8, 8, 8,
  4, 4
};

void setup(void) {
  pinMode(13, OUTPUT); // Buzzer
}

void loop() {
 song_func();
}
int song = 0;
void song_func() {
    int size = sizeof(melody) / sizeof(int);
    for (int Note = 0; Note < size; Note++) {
      int duration_note = 1000 / tempo[Note]; // To calculate the duration we divide the seconds by the  type of the note

      buzz(Pin_Buzzer, melody[Note], duration_note); // We call the buzz function 
      delay(duration_note * 1.30); // Break between each notes.
      buzz(Pin_Buzzer, 0, duration_note); // Stop the music

    
  }
}

void buzz(int pin_buzzer, long frequence, long length) {
  long wainting_time = 1000000 / frequency / 2; // We caculate the value between each transition
  long numCycles = frequency * length / 1000; 
  for (long i = 0; i < numCycles; i++) {
    digitalWrite(pin_buzzer, HIGH); // We play the music
    delayMicroseconds(temps_attente); 
    digitalWrite(pin_buzzer, LOW); // We stop the music
    delayMicroseconds(wainting_time); 
  }
}

Buzzer