Simple test

Ensure your device works with this simple test.

examples/nau88l21_simpletest.py

# SPDX-FileCopyrightText: Copyright (c) 2026 Tim Cocks for Adafruit Industries
#
# SPDX-License-Identifier: MIT
"""
Play a one-octave scale out the headphone jack with synthio, output only.

There is no microphone capture here, so the codec only needs its DAC side
brought up. The one ordering rule that still applies is the clock one: the FLL
locks to the incoming bit clock, so BCLK has to be running before
``configure_clocks`` is called. Playing the synth is what starts BCLK, so it
goes first; the codec is silent until ``headphone_output`` is enabled a few
lines later, which is why starting playback before configuring is harmless.

Pin names are the Teenage Engineering EP-2350's; adjust for other boards.
"""

import time

import audiobusio
import board
import synthio

import adafruit_nau88l21

RATE = 48000  # frame rate on the wire; also what the codec's FLL locks to

# DAC digital gain, dB. Raising this does not reliably make the jack louder:
# the analog output stage runs out of headroom first, so extra digital gain
# turns into distortion. Measure before trusting a larger number.
DAC_VOLUME = 0
# Headphone analog volume, dB. Only 0, -3, -6 and -9 exist.
HEADPHONE_VOLUME = 0

# MIDI note numbers for a C-major scale, C4 up to C5.
SCALE = (60, 62, 64, 65, 67, 69, 71, 72)
NOTE_SECONDS = 0.4

# CAUTION: this drives the headphone amplifier. Take the headphones off before
# the first run and confirm the level is comfortable before wearing them.

i2s = audiobusio.I2SOut(board.I2S_BIT_CLOCK, board.I2S_WORD_SELECT, board.I2S_DOUT)

synth = synthio.Synthesizer(sample_rate=RATE)

# Playing the synth starts BCLK, which the codec's FLL needs before it can lock.
# The synth streams silence until a note is pressed, so nothing is audible yet.
i2s.play(synth)

codec = adafruit_nau88l21.NAU88L21(board.I2C())
codec.configure_clocks()

# headphone_output is a quickstart that deliberately ends quiet, at -20 dB DAC
# and -9 dB headphone. Set both volumes afterward rather than leaving the defaults
codec.headphone_output = True
codec.dac_volume = DAC_VOLUME
codec.headphone_volume = HEADPHONE_VOLUME

print("playing scale")
try:
    while True:
        for note in SCALE:
            synth.press(note)
            time.sleep(0.25)
            synth.release(note)
            time.sleep(0.125)
finally:
    i2s.stop()
    i2s.deinit()

Microphone passthrough

Full duplex: the microphone feeds the headphone amplifier through a high-pass filter and a gain stage.

examples/nau88l21_passthrough.py

# SPDX-FileCopyrightText: Copyright (c) 2026 Tim Cocks for Adafruit Industries
#
# SPDX-License-Identifier: MIT
"""
Mic -> headphone passthrough for the EP-2350, with a DSP chain in between.
"""

import time

import audiobusio
import audiodelays
import audiofilters
import audioi2sin
import board
import synthio

import adafruit_nau88l21

RATE = 48000  # frame rate on the wire; also what the codec's FLL expects

# --- Hardware effects config ---

# Analog mic gain, dB, -1 .. 36.
MIC_GAIN = 24
# ADC digital gain, dB.
ADC_VOLUME = 0
# DAC digital gain, dB.
DAC_VOLUME = 6
# Headphone analog volume, dB. Only 0/-3/-6/-9 exist.
HEADPHONE_VOLUME = 0

# --- Software effects config ---

# Gain of the software stage, in dB.
PRE_GAIN = 4.0
# High-pass corner, Hz.
HPF_HZ = 120


# The internal clock mode object has to exist first: it generates BCLK/WS, and
# everything in external clock mode syncs to the WS edges it sees. Constructing
# it starts BCLK, which the codec's FLL then has something to lock to.
i2s = audiobusio.I2SOut(board.I2S_BIT_CLOCK, board.I2S_WORD_SELECT, board.I2S_DOUT)

codec = adafruit_nau88l21.NAU88L21(board.I2C())
codec.configure_clocks()

# enable headphone output and set hardware volume
codec.headphone_output = True
codec.dac_volume = DAC_VOLUME
codec.headphone_volume = HEADPHONE_VOLUME

codec.configure_microphone_input(gain_db=MIC_GAIN)
codec.adc_volume = ADC_VOLUME

# left_justified=True is what matches this codec's ADCDAT, which it
# drives one BCLK ahead of what our own internal clock mode TX program emits.
mic = audioi2sin.I2SIn(
    board.I2S_BIT_CLOCK,
    board.I2S_WORD_SELECT,
    board.I2S_DIN,
    sample_rate=RATE,
    bit_depth=16,
    mono=True,
    external_clock=True,
    left_justified=True,
)

common = dict(
    buffer_size=1024, sample_rate=RATE, bits_per_sample=16, samples_signed=True, channel_count=1
)
hpf = audiofilters.Filter(
    filter=synthio.Biquad(synthio.FilterMode.HIGH_PASS, frequency=HPF_HZ, Q=0.7), mix=1.0, **common
)
amp = audiofilters.Distortion(
    pre_gain=PRE_GAIN,
    drive=0.0,
    mode=audiofilters.DistortionMode.LOFI,
    soft_clip=True,
    mix=1.0,
    **common,
)

# WIRING ORDER MATTERS. Work from the output backwards, so the call that
# hands the mic to something is the LAST one:
#
#     i2s.play(amp) -> amp.play(hpf) -> hpf.play(mic)
#
# i2s.play() restarts the internal clock mode state machine, which knocks the
# external clock mode I2SIn off the frame it locked to. The firmware re-syncs
# that I2SIn from its reset_buffer(), which only runs when something
# calls play() *on the mic*. The effects do not propagate reset_buffer() down
# to their own source. So wiring the mic in first (hpf.play(mic) before
# i2s.play(amp)) syncs the mic and then immediately de-syncs it,
# the output is silence or hiss.

i2s.play(amp, loop=True)
amp.play(hpf)
hpf.play(mic)

print(
    f"passthrough running: mic gain {codec.mic_gain:.0f} dB, +{PRE_GAIN:.1f} dB, HPF {HPF_HZ:d} Hz"
)

try:
    while True:
        time.sleep(1)
        # Reading .overflow clears it. It trips if the playback side falls
        # behind the mic, which should not happen here -- both run off the
        # same BCLK -- so a report means something is wrong.
        if mic.overflow:
            print("overflow")
except KeyboardInterrupt:
    i2s.stop()
    i2s.deinit()
    mic.deinit()