aeroreyna
131 lines
4.2 KiB
Python
131 lines
4.2 KiB
Python
"""CircuitPython audio helpers for Waveshare ESP32-S3-RLCD-4.2.
|
|
|
|
Ports the ES8311 setup sequence from MicroPython audio_util.py and adds MP3
|
|
playback using CircuitPython's audiomp3 + audiobusio stack.
|
|
"""
|
|
|
|
import time
|
|
|
|
import audiobusio
|
|
import audiomp3
|
|
import digitalio
|
|
import pwmio
|
|
|
|
|
|
class ES8311:
|
|
ADDR = 0x18
|
|
|
|
def __init__(self, i2c):
|
|
self.i2c = i2c
|
|
|
|
def _write(self, register, value):
|
|
# CircuitPython I2CDevice is not used to keep this dependency-free.
|
|
while not self.i2c.try_lock():
|
|
pass
|
|
try:
|
|
self.i2c.writeto(self.ADDR, bytes([register & 0xFF, value & 0xFF]))
|
|
finally:
|
|
self.i2c.unlock()
|
|
|
|
def init(self, sample_rate=44100):
|
|
"""Initialize ES8311 for I2S DAC playback.
|
|
|
|
The register sequence is the existing MicroPython project's known-good
|
|
sequence. The original comments targeted 16 kHz WAV playback, but the
|
|
I2S peripheral is configured with the MP3 decoder sample rate at play
|
|
time. If MP3 output is silent, hardware-test this sequence first with a
|
|
16 kHz WAV/tone and then tune codec dividers for the MP3 sample rate.
|
|
"""
|
|
del sample_rate # Kept for API clarity; sequence currently fixed.
|
|
self._write(0x00, 0x1F)
|
|
time.sleep(0.01)
|
|
self._write(0x00, 0x00)
|
|
time.sleep(0.01)
|
|
self._write(0x01, 0x3F)
|
|
self._write(0x02, 0x48)
|
|
self._write(0x03, 0x10)
|
|
self._write(0x04, 0x20)
|
|
self._write(0x05, 0x00)
|
|
self._write(0x06, 0x03)
|
|
self._write(0x07, 0x00)
|
|
self._write(0x08, 0xFF)
|
|
self._write(0x09, 0x0C)
|
|
self._write(0x0A, 0x0C)
|
|
self._write(0x0D, 0x01)
|
|
self._write(0x0E, 0x02)
|
|
self._write(0x12, 0x00)
|
|
self._write(0x13, 0x10)
|
|
self._write(0x1C, 0x6A)
|
|
self._write(0x37, 0x08)
|
|
self._write(0x32, 0xBF)
|
|
self._write(0x31, 0x00)
|
|
self._write(0x00, 0x80)
|
|
|
|
def set_volume(self, volume):
|
|
volume = max(0, min(100, int(volume)))
|
|
self._write(0x32, int(volume * 255 / 100))
|
|
|
|
|
|
class BoardAudio:
|
|
def __init__(self, i2c, *, bit_clock, word_select, data, mclk, amp):
|
|
self.i2c = i2c
|
|
self.bit_clock_pin = bit_clock
|
|
self.word_select_pin = word_select
|
|
self.data_pin = data
|
|
self.mclk_pin = mclk
|
|
self.amp_pin = amp
|
|
self._mclk = None
|
|
self._amp = digitalio.DigitalInOut(amp)
|
|
self._amp.switch_to_output(value=False)
|
|
self.codec = ES8311(i2c)
|
|
|
|
def start_mclk(self):
|
|
if self._mclk is None:
|
|
# External MCLK for ES8311. CircuitPython I2SOut on ESP32-S3 does
|
|
# not accept a main_clock parameter, so keep this independent.
|
|
self._mclk = pwmio.PWMOut(
|
|
self.mclk_pin,
|
|
frequency=12288000,
|
|
duty_cycle=32768,
|
|
variable_frequency=False,
|
|
)
|
|
|
|
def stop_mclk(self):
|
|
if self._mclk is not None:
|
|
self._mclk.deinit()
|
|
self._mclk = None
|
|
|
|
def play_mp3(self, filename, volume=60):
|
|
"""Play an MP3 file from CIRCUITPY storage over the onboard speaker."""
|
|
self.start_mclk()
|
|
self.codec.init()
|
|
self.codec.set_volume(volume)
|
|
decoder = None
|
|
audio = None
|
|
f = None
|
|
try:
|
|
f = open(filename, "rb")
|
|
decoder = audiomp3.MP3Decoder(f)
|
|
# Use decoder-derived rate if available, else fall back.
|
|
sample_rate = getattr(decoder, "sample_rate", 44100)
|
|
audio = audiobusio.I2SOut(
|
|
bit_clock=self.bit_clock_pin,
|
|
word_select=self.word_select_pin,
|
|
data=self.data_pin,
|
|
)
|
|
self._amp.value = True
|
|
audio.play(decoder)
|
|
while audio.playing:
|
|
time.sleep(0.05)
|
|
return True
|
|
finally:
|
|
self._amp.value = False
|
|
if audio is not None:
|
|
audio.deinit()
|
|
if decoder is not None:
|
|
decoder.deinit()
|
|
if f is not None:
|
|
f.close()
|
|
# Leave MCLK running for repeated playback; call stop_mclk() before
|
|
# deep sleep if power matters.
|