Playing Simple Scores with a Buzzer Using C Language

1. Working Principle of the Buzzer

Buzzers are generally divided into active buzzers and passive buzzers. Active buzzers have an internal oscillation source and can produce sound continuously as long as the rated voltage is applied; passive buzzers require an external pulse signal of a certain frequency to produce sound. In our project, we typically use a passive buzzer, which allows us to precisely control the sound frequency through the program, thus playing different tones.

2. Basic Hardware Connection

To make the buzzer work under the control of a C language program, we first need to set up the hardware environment. Usually, the positive terminal of the buzzer is connected to a digital output pin of the development board (for example, a GPIO pin of a common microcontroller like STM32), and the negative terminal is grounded. Additionally, to drive the buzzer, a transistor may also need to be connected to amplify the current, ensuring that the buzzer has enough power to sound. However, the specific circuit design may vary slightly between different development boards, so it is essential to refer to the corresponding schematic when setting up the hardware.

3. Implementation of C Language Code

(1) Include Necessary Header Files

First, at the beginning of the C language code, you need to include the hardware-related header files. For example, if using a specific microcontroller’s development environment, like STM32, you need to include the standard peripheral library header file for the corresponding chip, such as “stm32fxxx.h” (where xxx represents the specific model). These header files contain definitions for operations on hardware registers such as GPIO, allowing us to control pin states in the program.

(2) Initialize the Buzzer Pin

// Assume using PA5 pin to connect the buzzer
#define BEEP_PIN GPIO_Pin_5
#define BEEP_GPIO_PORT GPIOA

void BEEP_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;

    // Enable GPIOA clock
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

    // Configure pin as push-pull output mode
    GPIO_InitStructure.GPIO_Pin = BEEP_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(BEEP_GPIO_PORT, &GPIO_InitStructure);
}

This code initializes the pin connected to the buzzer, setting it to push-pull output mode, so it can output high and low levels to drive the buzzer.

(3) Implement Sound Function

Different tones correspond to different frequencies. In the simple score, the frequency of middle “1” (do) is approximately 523Hz. We can calculate the corresponding delay time based on the frequency to control the output pulse period of the pin.

// Generate a square wave of specified frequency to produce sound
void BEEP_PlayTone(uint16_t frequency, uint32_t duration)
{
    uint32_t period = 1000000 / frequency;  // Calculate period in microseconds
    uint32_t halfPeriod = period / 2;

    for (uint32_t i = 0; i < (duration * 1000 / period); i++)
    {
        GPIO_SetBits(BEEP_GPIO_PORT, BEEP_PIN);  // Output high level
        Delay_us(halfPeriod);
        GPIO_ResetBits(BEEP_GPIO_PORT, BEEP_PIN);  // Output low level
        Delay_us(halfPeriod);
    }
}

The <span>Delay_us</span> function here is a custom microsecond-level delay function used to accurately control the pulse width.

(4) Example of Playing Simple Scores

Suppose we want to play a simple score of “Twinkle Twinkle Little Star”: |1 1 | 5 5 | 6 6 | 5 – | 4 4 | 3 3 | 2 2 | 1 – |. The corresponding frequency array and duration array can be defined as follows:

// Frequency array for notes corresponding to the simple score
uint16_t noteFrequencies[] = {523, 523, 784, 784, 880, 880, 784, 784, 698, 698, 587, 587, 523};
// Duration array, 4 represents one beat, 8 represents half a beat, and so on
uint32_t noteDurations[] = {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4};

Then call the play function in the main function:

int main()
{
    BEEP_Init();

    for (int i = 0; i < sizeof(noteFrequencies) / sizeof(noteFrequencies[0]); i++)
    {
        BEEP_PlayTone(noteFrequencies[i], noteDurations[i] * 500);  // 500 microseconds as the unit base, adjust as needed
    }

    return 0;
}

Through the above steps, you can use C language to make the buzzer play the simple melody of “Twinkle Twinkle Little Star”. Of course, to play more complex pieces, you just need to expand the note frequency and duration arrays and continuously optimize the accuracy of the sound function to create more beautiful sounds, injecting vitality into your C language projects.

In summary, mastering the skill of controlling a buzzer to play simple scores using C language opens a door to the fun world of hardware interaction, whether for beginners learning embedded programming or enthusiasts passionate about electronic creative projects. Enjoy the fun of programming and music integration!