Setting Up a Raspberry Pi for Audio Recording: I2S MEMS Mic Guide

If you want to use a raspberry pi for audio recording with low latency and high fidelity, you must bypass standard USB sound cards and use the hardware I2S (Inter-IC Sound) interface. By wiring a digital MEMS microphone directly to the Pi’s I2S pins, you eliminate the USB polling overhead and analog-to-digital conversion noise inherent in cheap USB dongles. This guide walks through the exact hardware, Bookworm OS configuration, and Python code required to capture studio-grade audio on the bench.

Hardware Selection for Raspberry Pi Audio Recording

Before buying parts, you need to choose your audio input architecture. Many hobbyists default to USB interfaces, but for embedded deployments (like wildlife monitors or room impulse response analyzers), I2S is superior. Below is a data-dense comparison of the three primary methods to get audio into a Raspberry Pi.

For this build, we are using the direct I2S MEMS method. It offers the best balance of cost, size, and signal integrity for embedded projects.

Parts List and I2S Pin Mapping

This guide specifically targets the Raspberry Pi 4 Model B (4GB variant). While the Raspberry Pi 5 is widely available in 2026, its I2S pin routing and HAT specifications changed, making the Pi 4B the most stable and documented platform for raw I2S MEMS integration. We are running Raspberry Pi OS Bookworm (64-bit).

Required Components

• Compute: Raspberry Pi 4 Model B (4GB) (~$55)
• Microphone: Adafruit I2S MEMS Microphone Breakout - SPH0645LM4H (~$7)
• Wiring: 5x Silicone female-to-female jumper wires
• Storage: 32GB+ A2-rated microSD card (Audio writes require sustained I/O)

GPIO Pin Mapping

The BCM2711 SoC on the Pi 4 routes the primary I2S interface (PCM) to specific GPIO pins. You must use these exact pins; I2S cannot be bit-banged reliably on arbitrary GPIOs.

OS Configuration (Raspberry Pi OS Bookworm)

Raspberry Pi OS Bookworm introduced significant changes to audio routing, shifting from pure ALSA to a PipeWire-backed architecture. Furthermore, the boot configuration file moved from /boot/config.txt to /boot/firmware/config.txt. According to the official Raspberry Pi configuration docs, you must enable the I2S overlay before the kernel will map the PCM hardware.

1. Open the configuration file: sudo nano /boot/firmware/config.txt
2. Comment out the default audio PWM line by adding a #: #dtparam=audio=on
3. Enable the I2S interface and load the Google Voice HAT overlay (which natively supports the SPH0645 timing quirk):
   dtparam=i2s=on
dtoverlay=googlevoicehat-soundcard
4. Save, exit, and reboot the Pi: sudo reboot
5. After rebooting, verify ALSA sees the card: arecord -l. You should see card 0: sndrpigooglevoicehat [snd_rpi_googlevoicehat_soundcard].

Complete Python Recording Script with Error Handling

Below is the complete, executable Python script. It uses the sounddevice library (a wrapper around PortAudio) and scipy to write the WAV file. We explicitly define the hardware pins in the comments for documentation, and include robust error handling for common ALSA/PortAudio failures.

import sounddevice as sd
import numpy as np
from scipy.io import wavfile
import sys
import time

# =====================================================================
# TARGET BOARD: Raspberry Pi 4 Model B 4GB
# TARGET OS: Raspberry Pi OS Bookworm (64-bit)
# HARDWARE: Adafruit SPH0645LM4H I2S MEMS Microphone
# =====================================================================
# I2S PIN MAPPING (BCM2711 Hardware PCM pins):
# BCLK (Bit Clock)  -> GPIO 18 (Physical Pin 12)
# LRCLK (Word Sel)  -> GPIO 19 (Physical Pin 35)
# DOUT (Serial Data)-> GPIO 20 (Physical Pin 38)
# =====================================================================

# Audio Configuration
SAMPLE_RATE = 44100
CHANNELS = 1
DURATION = 10  # Recording duration in seconds
OUTPUT_FILE = "i2s_mic_recording.wav"

# The ALSA card name mapped by the googlevoicehat overlay
DEVICE_NAME = "snd_rpi_googlevoicehat_soundcard"

def record_audio():
    print(f"Initializing I2S recording for {DURATION} seconds...")
    
    # Calculate total frames to capture
    num_frames = int(SAMPLE_RATE * DURATION)
    
    try:
        # Open the InputStream using the specific I2S ALSA device
        # The SPH0645 outputs 24-bit data left-justified in a 32-bit word.
        # We capture as 32-bit float, which PortAudio handles natively.
        with sd.InputStream(
            device=DEVICE_NAME,
            samplerate=SAMPLE_RATE,
            channels=CHANNELS,
            dtype='float32',
            blocksize=1024
        ) as stream:
            
            print("Recording... Speak now.")
            # Read the audio block
            audio_data, overflowed = stream.read(num_frames)
            
            if overflowed:
                print("WARNING: Audio buffer overflowed. Data may contain clicks.")
                
            # The SPH0645 hardware quirk: data is shifted left by 1 bit.
            # We must shift it right by 1 to correct the amplitude/phase.
            # Convert float32 to int32 for bitwise operation, then back.
            audio_int32 = (audio_data * 2147483647).astype(np.int32)
            audio_int32 = np.right_shift(audio_int32, 1)
            audio_corrected = audio_int32.astype(np.float32) / 2147483647.0
            
            # Normalize to 16-bit PCM for standard WAV compatibility
            audio_16bit = np.int16(audio_corrected * 32767)
            
            # Write to disk
            wavfile.write(OUTPUT_FILE, SAMPLE_RATE, audio_16bit)
            print(f"Recording saved to {OUTPUT_FILE}")
            
    except sd.PortAudioError as e:
        print(f"CRITICAL PORTAUDIO ERROR: {e}")
        print("Check ALSA configuration and I2S overlay status.")
        sys.exit(1)
    except Exception as e:
        print(f"Unexpected error: {e}")
        sys.exit(1)

if __name__ == "__main__":
    record_audio()

Debugging: ALSA Failures and PortAudio Errors

When working with raw I2S on Linux, ALSA (Advanced Linux Sound Architecture) will inevitably throw cryptic errors. If your script fails, here are the exact error strings you will see and how to fix them.

Exact Error Strings and Ranked Causes

Error 1: sounddevice.PortAudioError: Error opening InputStream: Device unavailable [PaErrorCode -9985]

• Cause A (Most Likely): PipeWire has claimed the audio device exclusively, blocking ALSA direct access. Fix: Stop the PipeWire service temporarily with systemctl --user stop pipewire or configure PipeWire to pass through the I2S device.
• Cause B: The dtoverlay failed to load in config.txt. Fix: Run dmesg | grep i2s to check for device tree compilation errors.

Error 2: ALSA lib pcm_dmix.c:1032:(snd_pcm_dmix_open) unable to open slave

• Cause A: Sample rate mismatch. The SPH0645 hardware clock divider might not support exactly 44100 Hz on your specific Pi 4 silicon revision. Fix: Change SAMPLE_RATE to 48000 in the Python script.
• Cause B: Another process (like pulseaudio or a background voice assistant) is holding the PCM slave open. Fix: Run sudo fuser -v /dev/snd/* to find and kill the offending PID.

The First Three Things to Check When It Fails

Extending and Simplifying the Build

Once you have a clean WAV file, you need to decide where the project goes next. The beauty of the I2S MEMS architecture is its modularity.

How to Simplify the Build

If the I2S device tree overlays and ALSA debugging feel like overkill for your application, simplify by switching to a USB Audio Interface. A basic $12 USB sound card (like the Sabrent USB External Stereo Sound Adapter) will show up as a standard USB audio class device. You won't need to edit config.txt, and sounddevice will find it automatically. You trade latency and embedded elegance for plug-and-play simplicity.

How to Extend the Build

For advanced embedded applications, extend this hardware stack in one of three ways:

• Stereo Beamforming: Wire a second SPH0645LM4H to the I2S bus. The I2S protocol supports left/right channels by toggling the LRCLK pin. By spacing the mics exactly 6cm apart, you can apply delay-and-sum beamforming in Python to isolate sound from a specific direction.
• Edge AI Transcription: Pipe the raw audio buffer directly into ALSA plugins or a local instance of whisper.cpp. Because I2S bypasses USB polling, you can achieve near real-time local transcription on the Pi 4's ARM Cortex-A72 cores.
• MQTT Streaming: Instead of writing to a WAV file, encode the audio_16bit numpy array to Opus format using pyogg and publish it to an MQTT broker for remote monitoring in industrial environments.

By mastering the I2S interface, you transform the Raspberry Pi from a simple desktop computer into a highly capable, low-latency digital signal processing node.