6. Chapter Buzzer

In this chapter, we will learn about buzzers and the sounds they make. And in our next project, we will use an active buzzer to make a doorbell and a passive buzzer to make an alarm.

6.1. Project Doorbell

We will make a doorbell with this functionality: when the Push Button Switch is pressed the buzzer sounds and when the button is released, the buzzer stops. This is a momentary switch function.

Raspberry Pi (with 40 GPIO) x1 GPIO Extension Board & Ribbon Cable x1 Breadboard x1
NPN transistorx1 (S8050)		Active buzzer x1
Push Button Switch x1	Resistor 1kΩ x1		Resistor 10kΩ x2
Jumper Wire

6.1.1. Component knowledge

6.1.1.1. Buzzer

A buzzer is an audio component. They are widely used in electronic devices such as calculators, electronic alarm clocks, automobile fault indicators, etc. There are both active and passive types of buzzers. Active buzzers have oscillator inside, these will sound as long as power is supplied. Passive buzzers require an external oscillator signal (generally using PWM with different frequencies) to make a sound.

Active buzzer

Passive buzzer

Active buzzers are easier to use. Generally, they only make a specific sound frequency. Passive buzzers require an external circuit to make sounds, but passive buzzers can be controlled to make sounds of various frequencies. The resonant frequency of the passive buzzer in this Kit is 2kHz, which means the passive buzzer is the loudest when its resonant frequency is 2kHz.

How to identify active and passive buzzer?

1. As a rule, there is a label on an active buzzer covering the hole where sound is emitted, but there are exceptions to this rule.

2. Active buzzers are more complex than passive buzzers in their manufacture. There are many circuits and crystal oscillator elements inside active buzzers; all of this is usually protected with a waterproof coating (and a housing) exposing only its pins from the underside. On the other hand, passive buzzers do not have protective coatings on their underside. From the pin holes, view of a passive buzzer, you can see the circuit board, coils, and a permanent magnet (all or any combination of these components depending on the model.

Passive buzzer

Passive buzzer

6.1.1.2. Transistors

A transistor is required in this project due to the buzzer’s current being so great that GPIO of RPi’s output capability cannot meet the power requirement necessary for operation. A NPN transistor is needed here to amplify the current.

Transistors, full name: semiconductor transistor, is a semiconductor device that controls current think of a transistor as an electronic “amplifying or switching device”. Transistors can be used to amplify weak signals, or to work as a switch. Transistors have three electrodes (PINs): base (b), collector (c) and emitter (e). When there is current passing between “be” then “ce” will have a several-fold current increase (transistor magnification), in this configuration the transistor acts as an amplifier. When current produced by “be” exceeds a certain value, “ce” will limit the current output. at this point the transistor is working in its saturation region and acts like a switch. Transistors are available as two types as shown below: PNP and NPN,

PNP transistor

NPN transistor

Note

In our kit, the PNP transistor is marked with 8550, and the NPN transistor is marked with 8050.

Thanks to the transistor’s characteristics, they are often used as switches in digital circuits. As micro-controllers output current capacity is very weak, we will use a transistor to amplify its current in order to drive components requiring higher current.

When we use a NPN transistor to drive a buzzer, we often use the following method. If GPIO outputs high level, current will flow through R1 (Resistor 1), the transistor conducts current and the buzzer will make sounds. If GPIO outputs low level, no current will flow through R1, the transistor will not conduct currentand buzzer will remain silent (no sounds).

When we use a PNP transistor to drive a buzzer, we often use the following method. If GPIO outputs low level, current will flow through R1. The transistor conducts current and the buzzer will make sounds. If GPIO outputs high level, no current flows through R1, the transistor will not conduct current and buzzer will remain silent (no sounds). Below are the circuit schematics for both a NPN and PNP transistor to power a buzzer.

NPN transistor to drive buzzer	PNP transistor to drive buzzer

6.1.2. Circuit

Schematic diagram with RPi GPIO Extension Shield

Hardware connection. If you need any support,please feel free to contact us via: support@freenove.com

Note

In this circuit, the power supply for the buzzer is 5V, and pull-up resistor of the push button switch is connected to the 3.3V power feed. Actually, the buzzer can work when connected to the 3.3V power feed but this will produce a weak sound from the buzzer (not very loud).

6.1.3. Sketch

In this chapter, we use a button to control the active buzzer. The code is similar to that in Chapter 3.

6.1.3.1. Sketch_06_1_Doorbell

First, enter where the project is located:

$ cd ~/Freenove_Kit/Pi4j/Sketches/Sketch_06_1_Doorbell

Enter the command to run the code.

$ jbang Doorbell.java

During the code running, press the button to sound the buzzer and release the button to stop it.

You can see messages printed on the terminal.

Press Ctrl+C to exit the code.

You can open the code with Geany to view and edit it, with the following command.

$ geany Doorbell.java

Click the icon to run the code.

If the code fails to run, please check Geany Configuration.

The following is program code:

///usr/bin/env jbang "$0" "$@" ; exit $?

//DEPS org.slf4j:slf4j-api:2.0.12
//DEPS org.slf4j:slf4j-simple:2.0.12
//DEPS com.pi4j:pi4j-core:2.6.0
//DEPS com.pi4j:pi4j-plugin-raspberrypi:2.6.0
//DEPS com.pi4j:pi4j-plugin-gpiod:2.6.0

import com.pi4j.Pi4J;
import com.pi4j.io.gpio.digital.DigitalState;
import com.pi4j.util.Console;

public class Doorbell{
    private static final int PIN_BUTTON = 18;
    private static final int PIN_BUZZER = 17; 
    
    public static void myPrintln(String tempText) {  
        Console console = new Console();
        console.println("\u001B[32m" + tempText + "\u001B[0m"); 
    }

    public static void main(String[] args) throws Exception {
        var pi4j = Pi4J.newAutoContext();
        var buzzer = pi4j.dout().create(PIN_BUZZER);  
        var button = pi4j.din().create(PIN_BUTTON);
        
        button.addListener(e -> {
            if (e.state() == DigitalState.LOW) {
                myPrintln("buzzer turned on.  >>>");
                buzzer.high();
            }
            else if(e.state() == DigitalState.HIGH){
                myPrintln("buzzer turned off. >>>");
                buzzer.low();
            }
        });
        
        try{
            while (true) {
                Thread.sleep(500);
            }
        }
        finally{
            pi4j.shutdown();
        }
    }
}

Please note that as the code is similar to that in chapter 3, here we do not explain it again.

In order to make the prompt messages printed by the terminal more conspicuous, we wrote the myprintln function to wrap the console.println function.

    public static void myPrintln(String tempText) {  
        Console console = new Console();
        console.println("\u001B[32m" + tempText + "\u001B[0m"); 
    }

6.2. Project Alertor

Next, we will use a passive buzzer to make an alarm.

The list of components and the circuit is similar to the doorbell project. We only need to take the Doorbell circuit and replace the active buzzer with a passive buzzer.

6.2.1. Sketch

In this chapter, we use button to control the passive buzzer to make sound.

6.2.1.1. Sketch_Alertor

First, enter where the project is located:

$ cd ~/Freenove_Kit/Pi4j/Sketches/Sketch_06_2_Alertor

Enter the command to run the code.

$ jbang Alertor.java

When the code is running, press the button to sound the buzzer and release to stop it.

You can see messages printed on the terminal.

Press ctrl+C to exit the code.

You can open the code with Geany to view and edit it, with the following command.

$ geany Alertor.java

Click the icon to run the code.

If the code fails to run, please check Geany Configuration.

The following is program code:

///usr/bin/env jbang "$0" "$@" ; exit $?

//DEPS org.slf4j:slf4j-api:2.0.12
//DEPS org.slf4j:slf4j-simple:2.0.12
//DEPS com.pi4j:pi4j-core:2.6.0
//DEPS com.pi4j:pi4j-plugin-raspberrypi:2.6.0
//DEPS com.pi4j:pi4j-plugin-gpiod:2.6.0

import com.pi4j.Pi4J;
import com.pi4j.context.Context;
import com.pi4j.io.gpio.digital.DigitalState;
import com.pi4j.io.gpio.digital.DigitalInput;
import com.pi4j.io.gpio.digital.DigitalOutput;
import com.pi4j.util.Console;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

class PWMController implements Runnable {
    private DigitalOutput pwm;
    private int pwmFrequency;
    private double pwmDutyCycle;
    private boolean running = true;
    private long period;
    private long highTime;
    private long lowTime;

    public PWMController(DigitalOutput pwm) {
        this.pwm = pwm;
        this.pwmFrequency = 1000;
        this.pwmDutyCycle = 0.5;
        this.period = (int) (1000000 / pwmFrequency);
        this.highTime = (int) (period * pwmDutyCycle);
        this.lowTime = (int) (period - highTime);
    }

    @Override
    public void run() {
        while (running) {
            if (highTime != 0) {
                pwm.high();
                delayUs(highTime);
            }
            if (lowTime != 0) {
                pwm.low();
                delayUs(lowTime);
            }
        }
    }

    public void setPwmFrequency(int frequency) {
        if (frequency != 0) {
            this.pwmFrequency = frequency;
            this.period = (int) (1000000 / pwmFrequency);
            this.highTime = (int) (period * pwmDutyCycle);
            this.lowTime = (int) (period - highTime);
        } else {
            this.pwmFrequency = 0;
            this.period = (int) (1000);
            this.highTime = (int) (0);
            this.lowTime = (int) (period - highTime);
        }
    }

    public void setPwmDutyCycle(double dutyCycle) {
        this.pwmDutyCycle = dutyCycle;
        this.highTime = (int) (period * pwmDutyCycle);
        this.lowTime = (int) (period - highTime);
    }

    private void delayUs(long us) {
        long startTime = System.nanoTime();
        long endTime = startTime + (us * 1000);
        while (System.nanoTime() < endTime) {
        }
    }

    public void requestStop() {
        running = false;
    }
}

public class Alertor {
    private static final Context pi4j = Pi4J.newAutoContext();
    private static final Map<Integer, PWMController> pwmControllers = new HashMap<>();
    private static volatile int buttonState = 0;
    private static int PIN_BUTTON = 18;
    private static int PIN_BUZZER = 17;

    public static void setPwmConfig(int pin) throws Exception {
        DigitalOutput pwm = pi4j.dout().create(pin);
        PWMController pwmController = new PWMController(pwm);
        Thread pwmThread = new Thread(pwmController, "PWM Controller " + pin);
        pwmControllers.put(pin, pwmController);
        pwmThread.start();
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            pwmController.requestStop();
            try {
                pwmThread.join();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }));
    }

    public static void myPrintln(String tempText) {
        Console console = new Console();
        console.println("\u001B[32m" + tempText + "\u001B[0m");
    }

    public static void main(String[] args) throws Exception {

        DigitalInput button = pi4j.din().create(PIN_BUTTON);
        button.addListener(e -> {
            buttonState = e.state() == DigitalState.LOW ? 1 : 0;
        });

        setPwmConfig(PIN_BUZZER);
        PWMController buzzer = pwmControllers.get(PIN_BUZZER);
        buzzer.setPwmFrequency(0);
        buzzer.setPwmDutyCycle(0.5);

        try {
            while (true) {
                if (buttonState == 1) {
                    myPrintln("buzzer turned on.  >>>");
                    buzzer.setPwmFrequency(1000);
                } else {
                    myPrintln("buzzer turned off. >>>");
                    buzzer.setPwmFrequency(0);
                }
                Thread.sleep(100);
            }
        } 
        finally {
            for (PWMController controller : pwmControllers.values()) {
                controller.requestStop();
            }
            pi4j.shutdown();
        }
    }
}

Create a pi4j context for manipulating the GPIOs, and define the GPIO numbers that control the keys and buzzer.

private static final Context pi4j = Pi4J.newAutoContext();
private static final Map<Integer, PWMController> pwmControllers = new HashMap<>();
private static volatile int buttonState = 0;
private static int PIN_BUTTON = 18;
private static int PIN_BUZZER = 17;

Initialize the button input pin, create a monitoring event, and assign the key value to buttonState when the button state changes.

DigitalInput button = pi4j.din().create(PIN_BUTTON);
button.addListener(e -> {
    buttonState = e.state() == DigitalState.LOW ? 1 : 0;
});

Initialize the PWM pin that controls the passive buzzer.

setPwmConfig(PIN_BUZZER);
PWMController buzzer = pwmControllers.get(PIN_BUZZER);
buzzer.setPwmFrequency(0);
buzzer.setPwmDutyCycle(0.5);

When buttonState is 1, the passive buzzer sounds, and when buttonState is 0, the buzzer sound is turned off. Print the information in the console.

if (buttonState == 1) {
    myPrintln("buzzer turned on.  >>>");
    buzzer.setPwmFrequency(1000);
} else {
    myPrintln("buzzer turned off. >>>");
    buzzer.setPwmFrequency(0);
}