Simple test

Ensure your device works with this simple test.

examples/tlv320_simpletest.py

# SPDX-FileCopyrightText: 2025 Liz Clark for Adafruit Industries
#
# SPDX-License-Identifier: MIT

import array
import math
import time

import audiobusio
import audiocore
import board
import digitalio

import adafruit_tlv320

# Reset the DAC before use
reset_pin = digitalio.DigitalInOut(board.D12)
reset_pin.direction = digitalio.Direction.OUTPUT
reset_pin.value = False  # Set low to reset
time.sleep(0.1)  # Pause 100ms
reset_pin.value = True  # Set high to release from reset

i2c = board.I2C()
dac = adafruit_tlv320.TLV320DAC3100(i2c)

# set sample rate & bit depth, use bclk
dac.configure_clocks(sample_rate=44100, bit_depth=16)

# use headphones
dac.headphone_output = True
dac.dac_volume = -10  # dB
# or use speaker
# dac.speaker_output = True
# dac.speaker_volume = -20 # dB

if "I2S_BCLK" and "I2S_WS" in dir(board):
    audio = audiobusio.I2SOut(board.I2S_BCLK, board.I2S_WS, board.I2S_DIN)
else:
    audio = audiobusio.I2SOut(board.D9, board.D10, board.D11)
# generate a sine wave
tone_volume = 0.5
frequency = 440
sample_rate = dac.sample_rate
length = sample_rate // frequency
sine_wave = array.array("h", [0] * length)
for i in range(length):
    sine_wave[i] = int((math.sin(math.pi * 2 * i / length)) * tone_volume * (2**15 - 1))
sine_wave_sample = audiocore.RawSample(sine_wave, sample_rate=sample_rate)

while True:
    audio.stop()
    time.sleep(1)
    audio.play(sine_wave_sample, loop=True)
    time.sleep(1)

Full test

Demos advanced features of the library.

examples/tlv320_fulltest.py

# SPDX-FileCopyrightText: 2025 Liz Clark for Adafruit Industries
#
# SPDX-License-Identifier: MIT

"""
Full TLV320DAC3100 Test
Demo all features in the library
Shows advanced control for DAC, headphone and speaker
beyond basic headphone_output & speaker_output helpers
in simpletest.
"""

import time

import board
import digitalio

from adafruit_tlv320 import (
    DAC_PATH_MIXED,
    DAC_PATH_NORMAL,
    DAC_PATH_OFF,
    DAC_PATH_SWAPPED,
    DAC_ROUTE_HP,
    DAC_ROUTE_MIXER,
    DAC_ROUTE_NONE,
    GPIO1_CLKOUT,
    GPIO1_DISABLED,
    GPIO1_GPI,
    GPIO1_GPO,
    GPIO1_INPUT_MODE,
    HP_COMMON_1_35V,
    HP_COMMON_1_50V,
    HP_COMMON_1_65V,
    HP_COMMON_1_80V,
    SPK_GAIN_6DB,
    SPK_GAIN_12DB,
    SPK_GAIN_18DB,
    SPK_GAIN_24DB,
    TLV320DAC3100,
    VOL_INDEPENDENT,
    VOL_LEFT_TO_RIGHT,
    VOL_RIGHT_TO_LEFT,
)

# Reset the DAC before use
reset_pin = digitalio.DigitalInOut(board.D12)
reset_pin.direction = digitalio.Direction.OUTPUT
reset_pin.value = False  # Set low to reset
time.sleep(0.1)  # Pause 100ms
reset_pin.value = True  # Set high to release from reset

print("Initializing I2C and TLV320DAC3100...")
i2c = board.I2C()
dac = TLV320DAC3100(i2c)

# Display basic information
print("\n=== Basic Information ===")
print(f"Sample rate: {dac.sample_rate} Hz")
print(f"Bit depth: {dac.bit_depth}-bit")
print(f"Overtemperature condition: {dac.overtemperature}")

# I2S Config
dac.configure_clocks(sample_rate=44000, bit_depth=16)
print(f"Sample rate: {dac.sample_rate} Hz")
print(f"Bit depth: {dac.bit_depth}-bit")
time.sleep(0.2)

# Headphone Output Setup
print("\n=== Headphone Output Setup ===")
print("Setting up headphone output...")
dac.headphone_output = True  # This conveniently sets up multiple parameters
print(f"Headphone output enabled: {dac.headphone_output}")

# Adjust headphone volume (in dB where 0dB is max, negative values reduce volume)
print("\nAdjusting headphone volume...")
print(f"Current headphone volume: {dac.headphone_volume} dB")
dac.headphone_volume = -10  # Set to -10 dB (moderate volume)
print(f"New headphone volume: {dac.headphone_volume} dB")

# Fine-tune left and right channels individually
print("\nAdjusting left and right headphone gain...")
print(f"Left headphone gain: {dac.headphone_left_gain}")
print(f"Right headphone gain: {dac.headphone_right_gain}")
dac.headphone_left_gain = 3  # Increase left channel gain
dac.headphone_right_gain = 3  # Increase right channel gain
print(f"New left headphone gain: {dac.headphone_left_gain}")
print(f"New right headphone gain: {dac.headphone_right_gain}")

# Mute/unmute the headphones
print("\nDemonstrating headphone mute functionality...")
print(f"Left headphone muted: {dac.headphone_left_mute}")
print(f"Right headphone muted: {dac.headphone_right_mute}")
dac.headphone_left_mute = True  # Mute left channel
dac.headphone_right_mute = False  # Ensure right channel is unmuted
print(f"Left headphone now muted: {dac.headphone_left_mute}")
print(f"Right headphone still unmuted: {dac.headphone_right_mute}")
time.sleep(1)  # Listen to right channel only
dac.headphone_left_mute = False  # Unmute left channel
print(f"Left headphone now unmuted: {dac.headphone_left_mute}")
dac.headphone_output = False  # turn off before speaker test

# Speaker Output Setup
print("\n=== Speaker Output Setup ===")
print("Setting up speaker output...")
dac.speaker_output = True  # This conveniently sets up multiple parameters
print(f"Speaker output enabled: {dac.speaker_output}")

# Adjust speaker volume (in dB where 0dB is max, negative values reduce volume)
print("\nAdjusting speaker volume...")
print(f"Current speaker volume: {dac.speaker_volume} dB")
dac.speaker_volume = -6  # Set to -6 dB (louder than headphones)
print(f"New speaker volume: {dac.speaker_volume} dB")

# Set speaker amplifier gain
print("\nAdjusting speaker gain...")
print(f"Current speaker gain: {dac.speaker_gain}")
dac.speaker_gain = SPK_GAIN_12DB  # 12dB amplification
print(f"New speaker gain: {dac.speaker_gain}")

# Mute/unmute the speaker
print("\nDemonstrating speaker mute functionality...")
print(f"Speaker muted: {dac.speaker_mute}")
dac.speaker_mute = True  # Mute speaker
print(f"Speaker now muted: {dac.speaker_mute}")
time.sleep(1)
dac.speaker_mute = False  # Unmute speaker
print(f"Speaker now unmuted: {dac.speaker_mute}")

# DAC Signal Routing
print("\n=== Advanced DAC Signal Routing ===")
print("\nCurrent DAC Status:")
print(f"Left DAC enabled: {dac.left_dac}")
print(f"Right DAC enabled: {dac.right_dac}")
print(f"Left DAC path: {dac.left_dac_path}")
print(f"Right DAC path: {dac.right_dac_path}")

print("\nSetting up swapped stereo (left and right channels swapped)...")
dac.left_dac_path = DAC_PATH_SWAPPED
dac.right_dac_path = DAC_PATH_SWAPPED
print(f"New left DAC path: {dac.left_dac_path}")
print(f"New right DAC path: {dac.right_dac_path}")

print("\nSetting up mono output (mixed left and right channels)...")
dac.left_dac_path = DAC_PATH_MIXED
dac.right_dac_path = DAC_PATH_MIXED
print(f"New left DAC path: {dac.left_dac_path}")
print(f"New right DAC path: {dac.right_dac_path}")

print("\nRestoring normal stereo...")
dac.left_dac_path = DAC_PATH_NORMAL
dac.right_dac_path = DAC_PATH_NORMAL
print(f"New left DAC path: {dac.left_dac_path}")
print(f"New right DAC path: {dac.right_dac_path}")

# DAC Volume Controls
print("\n=== DAC Volume Control Configuration ===")
print(f"Left DAC muted: {dac.left_dac_mute}")
print(f"Right DAC muted: {dac.right_dac_mute}")
print(f"Volume control mode: {dac.dac_volume_control_mode}")

print("\nSetting volume control mode where left channel controls right...")
dac.dac_volume_control_mode = VOL_LEFT_TO_RIGHT
print(f"New volume control mode: {dac.dac_volume_control_mode}")

print("\nSetting independent volume control mode (default)...")
dac.dac_volume_control_mode = VOL_INDEPENDENT
print(f"New volume control mode: {dac.dac_volume_control_mode}")

# DAC Channel Volume
print("\n=== DAC Channel Volume ===")
print(f"Left DAC channel volume: {dac.left_dac_channel_volume} dB")
print(f"Right DAC channel volume: {dac.right_dac_channel_volume} dB")

print("\nSetting different volumes for left and right channels...")
dac.left_dac_channel_volume = -3
dac.right_dac_channel_volume = -9
print(f"New left DAC channel volume: {dac.left_dac_channel_volume} dB")
print(f"New right DAC channel volume: {dac.right_dac_channel_volume} dB")

# Headphone as Line-Out
print("\n=== Configure Headphone as Line-Out ===")
print(f"Headphone configured as line-out: {dac.headphone_lineout}")

# Safety Features
print("\n=== Safety Features ===")
print(f"Reset speaker on short circuit: {dac.reset_speaker_on_scd}")
print(f"Reset headphone on short circuit: {dac.reset_headphone_on_scd}")

# Getting status flags
print("\n=== Status Information ===")
flags = dac.dac_flags
print(f"Left DAC powered: {flags['left_dac_powered']}")
print(f"Right DAC powered: {flags['right_dac_powered']}")
print(f"Headphone left (HPL) powered: {flags['hpl_powered']}")
print(f"Headphone right (HPR) powered: {flags['hpr_powered']}")
print(f"Left Class-D amplifier powered: {flags['left_classd_powered']}")
print(f"Right Class-D amplifier powered: {flags['right_classd_powered']}")
print(f"Left PGA gain OK: {flags['left_pga_gain_ok']}")
print(f"Right PGA gain OK: {flags['right_pga_gain_ok']}")

# Additional status checks via dedicated properties
print("\nStatus via dedicated properties:")
print(f"Speaker shorted: {dac.speaker_shorted}")
print(f"HPL gain fully applied: {dac.hpl_gain_applied}")
print(f"HPR gain fully applied: {dac.hpr_gain_applied}")
print(f"Speaker gain fully applied: {dac.speaker_gain_applied}")

# Higher-level shortcut methods
print("\n=== Using Higher-Level Shortcuts ===")
print("Demonstrating on/off control of primary outputs:")

print("\nTurning off headphone output...")
dac.headphone_output = False
print(f"Headphone output now: {dac.headphone_output}")

print("\nTurning off speaker output...")
dac.speaker_output = True
print(f"Speaker output now: {dac.speaker_output}")

print("\nSwapping outputs...")
dac.speaker_output = False
dac.headphone_output = True
print(f"Headphone output now: {dac.headphone_output}")
print(f"Speaker output now: {dac.speaker_output}")

# Pop Removal Setting
print("\n=== Headphone Pop Removal Settings ===")
dac.configure_headphone_pop(
    wait_for_powerdown=True,  # Wait for amp powerdown before DAC powerdown
    powerup_time=7,  # Power-on time setting (0-11)
    ramp_time=3,  # Ramp-up step time (0-3)
)
print("Headphone pop removal configured")

# External Settings (like GPIO)
print("\n=== GPIO Configuration ===")
print(f"Current GPIO1 mode: {dac.gpio1_mode}")
dac.gpio1_mode = GPIO1_GPO  # Set GPIO1 as general purpose output
print(f"New GPIO1 mode: {dac.gpio1_mode}")
dac.gpio1_mode = GPIO1_DISABLED  # Disable GPIO1
print(f"Disabled GPIO1 mode: {dac.gpio1_mode}")

# Volume Control ADC
print("\n=== Volume Control ADC ===")
print(f"Volume ADC reading: {dac.vol_adc_db} dB")

print("\nAll examples completed!")

Volume test

Test tone generator with interactive serial console volume controls.

examples/tlv320_volumetest.py

# SPDX-License-Identifier: MIT
# SPDX-FileCopyrightText: Copyright 2025 Sam Blenny
#
import gc
import os
import sys
import time

import displayio
import supervisor
import synthio
from audiobusio import I2SOut
from board import I2C, I2S_BCLK, I2S_DIN, I2S_MCLK, I2S_WS, PERIPH_RESET
from digitalio import DigitalInOut, Direction, Pull
from micropython import const

from adafruit_tlv320 import TLV320DAC3100

# DAC and Synthesis parameters
SAMPLE_RATE = const(11025)
CHAN_COUNT = const(2)
BUFFER_SIZE = const(1024)

# DAC volume limits
DV_MIN = -63.5
DV_MAX = 24.0

# Headphone volume limits
HV_MIN = -78.3
HV_MAX = 0

# Headphone gain limits
HG_MIN = 0
HG_MAX = 9

# Speaker volume limits
SV_MIN = -78.3
SV_MAX = 0

# Speaker amp gain limits
SG_MIN = 6
SG_MAX = 24
SG_STEP = 6


def init_dac_audio_synth(i2c):
    """Configure TLV320 I2S DAC for audio output and make a Synthesizer.

    :param i2c: a reference to board.I2C()
    :return: tuple(dac: TLV320DAC3100, audio: I2SOut, synth: Synthesizer)
    """
    # 1. Reset DAC (reset is active low)
    rst = DigitalInOut(PERIPH_RESET)
    rst.direction = Direction.OUTPUT
    rst.value = False
    time.sleep(0.1)
    rst.value = True
    time.sleep(0.05)
    # 2. Configure sample rate, bit depth, and output port
    dac = TLV320DAC3100(i2c)
    dac.configure_clocks(sample_rate=SAMPLE_RATE, bit_depth=16)
    dac.speaker_output = True
    dac.headphone_output = True
    # 4. Initialize I2S for Fruit Jam rev D
    audio = I2SOut(bit_clock=I2S_BCLK, word_select=I2S_WS, data=I2S_DIN)
    # 5. Configure synthio patch to generate audio
    vca = synthio.Envelope(
        attack_time=0, decay_time=0, sustain_level=1.0, release_time=0, attack_level=1.0
    )
    synth = synthio.Synthesizer(sample_rate=SAMPLE_RATE, channel_count=CHAN_COUNT, envelope=vca)
    return (dac, audio, synth)


def main():  # noqa: PLR0912, PLR0915, allow long function and long if statement
    # Turn off the default DVI display to free up CPU
    displayio.release_displays()
    gc.collect()

    # Set up the audio stuff for a basic synthesizer
    i2c = I2C()
    (dac, audio, synth) = init_dac_audio_synth(i2c)
    audio.play(synth)

    dv = dac.dac_volume  #          default DAC volume
    hv = dac.headphone_volume  #    default headphone analog volume
    hg = dac.headphone_left_gain  # default headphone amp gain
    sv = dac.speaker_volume  #      default speaker analog volume
    sg = dac.speaker_gain  #        default speaker amp gain
    note = 60
    synth.press(note)

    # Check for unbuffered keystroke input on the USB serial console
    print("""
=== TLV320DAC Volume Tester ===

Controls:
 q/z: dac_volume +/- 1
 w/x: headphone_volume +/- 1
 e/c: headphone_left_gain headphone_right_gain +/- 1
 r/v: speaker_volume +/- 1
 t/b: speaker_gain +/- 6
 space: toggle speaker_output (amp power), this will reset volume & gain

For less headphone noise, turn off the speaker amp (spacebar)
""")
    while True:
        time.sleep(0.01)
        if supervisor.runtime.serial_bytes_available:
            while supervisor.runtime.serial_bytes_available:
                c = sys.stdin.read(1)
                if c == "q":
                    # Q = DAC Volume UP
                    dv = min(DV_MAX, max(DV_MIN, dv + 1))
                    dac.dac_volume = dv
                    print(f"dv = {dv:.1f} ({dac.dac_volume:.1f})")
                elif c == "z":
                    # Z = DAC Volume DOWN
                    dv = min(DV_MAX, max(DV_MIN, dv - 1))
                    dac.dac_volume = dv
                    print(f"dv = {dv:.1f} ({dac.dac_volume:.1f})")
                elif c == "w":
                    # W = Headphone Volume UP
                    hv = min(HV_MAX, max(HV_MIN, hv + 1))
                    dac.headphone_volume = hv
                    print(f"hv = {hv:.1f} ({dac.headphone_volume:.1f})")
                elif c == "x":
                    # X = Headphone Volume DOWN
                    hv = min(HV_MAX, max(HV_MIN, hv - 1))
                    dac.headphone_volume = hv
                    print(f"hv = {hv:.1f} ({dac.headphone_volume:.1f})")
                elif c == "e":
                    # E = Headphone Amp Gain UP
                    hg = min(HG_MAX, max(HG_MIN, hg + 1))
                    dac.headphone_left_gain = hg
                    dac.headphone_right_gain = hg
                    print(f"hg = {hg:.1f} ({dac.headphone_left_gain})")
                elif c == "c":
                    # C = Headphone Amp Gain DOWN
                    hg = min(HG_MAX, max(HG_MIN, hg - 1))
                    dac.headphone_left_gain = hg
                    dac.headphone_right_gain = hg
                    print(f"hg = {hg:.1f} ({dac.headphone_left_gain})")

                if c == "r":
                    # R = Speaker Volume UP
                    sv = min(SV_MAX, max(SV_MIN, sv + 1))
                    dac.speaker_volume = sv
                    print(f"sv = {sv:.1f} ({dac.speaker_volume:.1f})")
                elif c == "v":
                    # V = Speaker Volume DOWN
                    sv = min(SV_MAX, max(SV_MIN, sv - 1))
                    dac.speaker_volume = sv
                    print(f"sv = {sv:.1f} ({dac.speaker_volume:.1f})")
                elif c == "t":
                    # T = Speaker Amp Gain UP
                    sg = min(SG_MAX, max(SG_MIN, sg + SG_STEP))
                    dac.speaker_gain = sg
                    print(f"sg = {sg:.1f} ({dac.speaker_gain})")
                elif c == "b":
                    # B = Speaker Amp Gain DOWN
                    sg = min(SG_MAX, max(SG_MIN, sg - SG_STEP))
                    dac.speaker_gain = sg
                    print(f"sg = {sg:.1f} ({dac.speaker_gain})")
                elif c == " ":
                    # Space = Toggle speaker amp enable/disable
                    en = not dac.speaker_output
                    dac.speaker_output = en
                    print(f"speaker_output = {en}")


main()

Fruit Jam sample rates demo

Try different sample rates and PLL clocking options on a Fruit Jam board.

examples/sample_rates_demo.py

# SPDX-License-Identifier: MIT
# SPDX-FileCopyrightText: Copyright 2025 Sam Blenny
#
# WAV file beep demo for Fruit Jam (adjust pins as needed for other boards)
#
import time

import audiocore
from audiobusio import I2SOut
from board import I2C, I2S_BCLK, I2S_DIN, I2S_MCLK, I2S_WS
from digitalio import DigitalInOut, Direction, Pull
from micropython import const
from pwmio import PWMOut

from adafruit_tlv320 import TLV320DAC3100

# I2S MCLK clock frequency
MCLK_HZ = const(15_000_000)


def configure_dac(i2c, sample_rate, mclk_hz):
    # Configure TLV320DAC.
    # When mclk_hz is not None, you must provide a 15 MHz PWMOut clock to the
    # DAC's MCLK pin.

    # 1. Initialize DAC (this includes a soft reset and sets minimum volumes)
    dac = TLV320DAC3100(i2c)

    # 2. Configure headphone/speaker routing and volumes (order matters here)
    #
    #    CAUTION: The TLV320 includes a DSP oversampling filter in the signal
    #    chain before the dac.dac_volume setting is applied. The filter may
    #    boost the gain of loud samples (near 0 dBfs) to the point that they
    #    clip and distort if you have dac.dac_volume set too high. To prevent
    #    clipping, it's best to set dac.dac_volume to no more than -3 or -6 dB.
    #    If you want more gain without distortion, you can turn up the analog
    #    headphone amplifiers with dac.headphone_volume. For line level, try
    #    dac.dac_volume = -3 and dac.headphone_volume = 0.
    #
    dac.speaker_output = False
    dac.headphone_output = True
    dac.dac_volume = -3  # Keep this below 0 to avoid DSP filter clipping
    dac.headphone_volume = 0  # CAUTION! Line level. Too loud for headphones!

    # 3. Configure the right PLL and CODEC settings for our sample rate
    dac.configure_clocks(sample_rate=sample_rate, mclk_freq=MCLK_HZ)

    # 4. Wait for power-on volume ramp-up to finish
    time.sleep(0.35)
    return dac


# Set up I2C and I2S buses
i2c = I2C()
audio = I2SOut(bit_clock=I2S_BCLK, word_select=I2S_WS, data=I2S_DIN)

# To hear how MCLK improves audio when even using PLL_CLKIN=BCLK, uncomment
# the next line and comment out the `if mclk_hz_:` blocks in the loop below.
# mclk_pwm = PWMOut(I2S_MCLK, frequency=MCLK_HZ, duty_cycle=2**15)

# Loop through all the sample rate and clock source options
mclk_rates = (
    (8000, "sinewave_8kHz.wav", 2),  # 8000 gets 2 beeps
    (11025, "sinewave_11kHz.wav", 3),  # 11025 gets 3 beeps
    (22050, "sinewave_22kHz.wav", 4),  # 4 beeps
    (44100, "sinewave_44kHz.wav", 5),  # ...
    (48000, "sinewave_48kHz.wav", 6),
)
while True:
    # First do MCLK = 15 MHz, then do MCLK = None (meaning use BCLK)
    for mclk_hz_ in (MCLK_HZ, None):
        if mclk_hz_:
            # Set up 15 MHz MCLK PWM clock output for less hiss and distortion
            mclk_pwm = PWMOut(I2S_MCLK, frequency=MCLK_HZ, duty_cycle=2**15)

        # Play beeps at all supported sample rates
        print(f"Using MCLK = {mclk_hz_}:")
        for (
            sample_rate,
            filename,
            beeps,
        ) in mclk_rates:
            # Reset and re-configure DAC for the current sample rate
            dac = configure_dac(i2c, sample_rate, mclk_hz_)

            # Load wav file with 650 Hz beep at this sample rate
            sample = audiocore.WaveFile(filename)

            # Play beeps
            print(f" sample rate {sample_rate} Hz: {beeps} beeps...")
            for _ in range(beeps):
                audio.play(sample)
                time.sleep(0.19)

            # Pause before switching to next sample rate
            time.sleep(0.7)

            # Mute before next loop iteration resets DAC (reduce popping noise)
            dac.headphone_left_mute = True
            dac.headphone_right_mute = True
            time.sleep(0.1)

        if mclk_hz_:
            # When switching to BCLK, stop sending the PWM clock signal to MCLK
            mclk_pwm.deinit()

        # Pause before next clock source
        time.sleep(0.8)

    # Pause before starting over
    print()
    time.sleep(3)