Pin It!

Ever tried getting decent sound from an ESP32? This simple PWM audio method changes everything.

I vividly remember the first time I tried to make an ESP32 sing. I’d built this intricate sensor array, all open hardware, logging data beautifully. But when it came to adding a simple audible alert, I hit a wall. Every tutorial pointed to external DACs or complex audio chips, feeling like overkill for a quick chime or a simple melody. I thought, “There has to be a more direct, FOSS-friendly way to get sound out of this thing!”

My early attempts at PWM audio were… well, let’s just say they sounded more like static than symphonies. It was frustrating to be so close to a complete, self-contained project, only to be bottlenecked by sound. This feeling of limitation, of needing another proprietary black box to achieve something seemingly simple, spurred me to dig deeper into the ESP32’s native capabilities. It turns out, the solution was always there, waiting to be optimized.

This isn’t just about making noise; it’s about liberating your projects from external dependencies and empowering them to create rich, expressive experiences directly from the chip. Ready to transform your silent ESP32 into an audio powerhouse with just a few lines of code? Keep reading to unlock its hidden sonic potential.

---

Table of Contents

Pin It!

Pin It!

• The Heart of the Sound: What is PWM, Anyway?
  • Components Needed
  • Circuit Pinout and Wiring Diagram
  • Wiring Diagram:
• Setting Up PWM on ESP32
  • Generating Different Tones
  • Controlling Volume with Duty Cycle
• Practical Uses of PWM-Based Audio Generation
• Your ESP32, Unleashed and Audible

Pin It!

---

The Heart of the Sound: What is PWM, Anyway?

Before we make our ESP32 sing, let’s clarify the magic behind “PWM.” PWM stands for Pulse Width Modulation, and it’s a wonderfully clever technique that digital microcontrollers like our ESP32 use to simulate an analog signal. Since the ESP32’s pins primarily output either a high (3.3V) or low (0V) signal – a purely digital “on” or “off” – we can’t directly output a smoothly varying analog waveform like an audio signal.

Enter PWM. Imagine a digital switch that can turn a voltage on and off incredibly fast. With PWM, we’re not changing the voltage level itself, but rather the duration of the “on” pulse within a fixed period.

• Pulse Width: This is the amount of time the signal is “on” (high) during one complete cycle.
• Period (or Frequency): This is the total time for one complete “on” and “off” cycle.
• Duty Cycle: This is the ratio of the “on” time (pulse width) to the total period, usually expressed as a percentage (or a value between 0 and 1023 on ESP32 MicroPython, representing 0-100%).

So, to represent a higher “analog” voltage, we make the “on” pulse wider (higher duty cycle). To represent a lower “analog” voltage, we make the “on” pulse narrower (lower duty cycle). If we vary this duty cycle very rapidly, corresponding to the shape of an audio waveform, our ear (or a simple low-pass filter) averages these quick pulses into what sounds like a continuous analog signal.

Think of it like this: if you flick a light switch on and off extremely fast, it might appear dimmer than when held continuously on, even though the light bulb itself is still either fully on or fully off. PWM works on a similar principle, but with electronic signals. This elegant, digital-to-analog conversion method is the core of how your ESP32 generates PWM audio, without needing any specialized DAC (Digital-to-Analog Converter) chip! It’s a true testament to getting more from less, perfectly aligning with our FOSS ethos.

Components Needed

Pin It!

• ESP32 Development Board: The microcontroller that will generate the PWM signals.
• Buzzer or Small Speaker: To produce sound based on the PWM signals. A simple piezo buzzer will work well for basic audio output.
• Resistor (optional): A 100-ohm resistor to limit current for the buzzer (optional, depending on your buzzer’s rating).
• Breadboard and Jumper Wires: For connecting the components together.
• Power Supply: The ESP32 typically operates at 3.3V, but for higher volume, you may need a 5V power supply for the speaker.

Circuit Pinout and Wiring Diagram

Here’s a simple table for the pinout and connections:

Pin It!

Wiring Diagram:

• Step 1: Connect the positive terminal of the buzzer to GPIO 25 (or any other available PWM-capable pin on the ESP32).
• Step 2: Connect the negative terminal of the buzzer to the GND pin on the ESP32.
• Step 3: (Optional) Use a 100-ohm resistor in series with the buzzer to prevent excessive current draw, especially if using a larger speaker.

Note: While the ESP32 operates at 3.3V, you can use a 5V supply for the speaker if you need a higher volume output. In such cases, ensure that the speaker can handle 5V, or use an appropriate amplifier circuit.

Setting Up PWM on ESP32

Before we dive into PWM-based audio generation, let’s first understand how to set up PWM on the ESP32. A PWM signal is essentially a square wave, and by varying its duty cycle, we can control the sound’s volume and frequency. Here’s how you can set up PWM on an ESP32 to generate sound:

from machine import Pin, PWM
import time

# Set up PWM on pin 18
pwm = PWM(Pin(18), freq=1000, duty=512)  # 1 kHz frequency, 50% duty cycle

# Play sound for 1 second
time.sleep(1)

# Stop the sound
pwm.deinit()

This code initializes PWM on pin 25 with a frequency of 1000 Hz, producing a mid-range tone, and a 50% duty cycle to control the volume. The pwm.deinit() method stops the sound after 1 second.

Generating Different Tones

PWM-based audio generation allows you to change the pitch of the sound by adjusting the PWM frequency. The higher the frequency, the higher the pitch. Here’s how you can generate a sequence of tones using different frequencies:

def play_tone(frequency, duration):
    pwm.freq(frequency)
    time.sleep(duration)
    pwm.deinit()

# Set up the PWM signal
pwm = PWM(Pin(18), duty=512)

# Play different tones
play_tone(262, 0.5)  # Middle C
play_tone(294, 0.5)  # D
play_tone(330, 0.5)  # E
play_tone(349, 0.5)  # F
play_tone(392, 0.5)  # G

By adjusting the frequency in the play_tone function, you can produce a variety of notes using PWM-based audio generation on your ESP32.

Controlling Volume with Duty Cycle

The duty cycle of a PWM signal not only controls the frequency but also the volume of the sound produced. A higher duty cycle results in a louder sound, while a lower duty cycle makes the sound quieter. You can use this feature to modify the volume of your audio output.

# Adjust volume with duty cycle
def set_volume(volume):
    pwm.duty(volume)

# Set up the PWM signal
pwm = PWM(Pin(18), freq=1000)

# Play a tone at different volumes
for volume in [1024, 512, 256, 128]:
    set_volume(volume)
    play_tone(440, 1)  # A4 note at different volumes

In this example, we change the duty cycle to control the volume and play the same tone at different loudness levels.

· · ─ ·𖥸· ─ · ·

Practical Uses of PWM-Based Audio Generation

Pin It!

PWM-based audio generation is a versatile tool for various applications, especially in embedded systems and IoT projects. Some practical uses include:

1. Simple Alerts and Alarms: Use PWM to generate alert sounds for notifications or warnings in IoT devices.
2. Games and Interactive Projects: Add simple sound effects to your games or interactive projects.
3. Educational Tools: Teach the basics of sound generation and signal processing through hands-on projects using PWM-based audio generation.

· · ─ ·𖥸· ─ · ·

Your ESP32, Unleashed and Audible

We’ve journeyed from frustrating silence to surprising sound, demonstrating how the ESP32’s built-in capabilities can deliver impressive PWM audio without the need for additional complex hardware. We’ve tapped into the heart of this versatile microcontroller, proving that open hardware, coupled with smart software, can achieve remarkable results.

This isn’t just a technical trick; it’s about realizing the full potential of your FOSS projects, giving them a voice and making them truly interactive and engaging. By leveraging PWM audio, you gain control, reduce complexity, and champion a more self-reliant approach to embedded development.

Eager to explore more ways to push the boundaries of open hardware and software? Don’t miss out on upcoming guides, insights, and breakthroughs that empower you to build smarter, more capable projects. Join our growing community of FOSS enthusiasts and subscribe to the newsletter at https://www.samgalope.dev/newsletter/ today!