Check if dac is present and add parameters for sample rate and bit depth

Author: relic-se

adafruit_fruitjam/peripherals.py

@@ -27,6 +27,7 @@
 """
 
 import os
+import time
 
 import adafruit_sdcard
 import adafruit_tlv320
@@ -135,15 +136,23 @@ class Peripherals:
     """Peripherals Helper Class for the FruitJam Library
 
     :param audio_output: The audio output interface to use 'speaker' or 'headphone'
-    :param safe_volume_limit: The maximum volume allowed for the audio output. Default is 15
+    :param safe_volume_limit: The maximum volume allowed for the audio output. Default is 12.
         Using higher values can damage some speakers, change at your own risk.
+    :param sample_rate: The sample rate to play back audio data in hertz. Default is 11025.
+    :param bit_depth: The bits per sample of the audio data. Supports 8 and 16 bits. Default is 16.
 
     Attributes:
         neopixels (NeoPxiels): The NeoPixels on the Fruit Jam board.
             See https://circuitpython.readthedocs.io/projects/neopixel/en/latest/api.html
     """
 
-    def __init__(self, audio_output="headphone", safe_volume_limit=12):
+    def __init__(
+        self,
+        audio_output: str = "headphone",
+        safe_volume_limit: int = 12,
+        sample_rate: int = 11025,
+        bit_depth: int = 16,
+    ):
         self.neopixels = NeoPixel(board.NEOPIXEL, 5)
 
         self._buttons = []
@@ -154,19 +163,24 @@ def __init__(self, audio_output="headphone", safe_volume_limit=12):
             self._buttons.append(switch)
 
         i2c = board.I2C()
-        self._dac = adafruit_tlv320.TLV320DAC3100(i2c)
+        while not i2c.try_lock():
+            time.sleep(0.01)
+        self._dac_present = 0x18 in i2c.scan()
 
-        # set sample rate & bit depth
-        self._dac.configure_clocks(sample_rate=11030, bit_depth=16)
+        if self._dac_present:
+            self._dac = adafruit_tlv320.TLV320DAC3100(i2c)
+
+            # set sample rate & bit depth
+            self._dac.configure_clocks(sample_rate=sample_rate, bit_depth=bit_depth)
+
+            self._audio = audiobusio.I2SOut(board.I2S_BCLK, board.I2S_WS, board.I2S_DIN)
 
-        self._audio_output = audio_output
-        self.audio_output = audio_output
-        self._audio = audiobusio.I2SOut(board.I2S_BCLK, board.I2S_WS, board.I2S_DIN)
         if safe_volume_limit < 1 or safe_volume_limit > 20:
             raise ValueError("safe_volume_limit must be between 1 and 20")
         self.safe_volume_limit = safe_volume_limit
-        self._volume = 7
-        self._apply_volume()
+
+        self.audio_output = audio_output
+        self._apply_volume(7)
 
         self._sd_mounted = False
         sd_pins_in_use = False
@@ -227,14 +241,18 @@ def any_button_pressed(self) -> bool:
         return True in [not button.value for (i, button) in enumerate(self._buttons)]
 
     @property
-    def dac(self):
-        return self._dac
+    def dac_present(self) -> bool:
+        return self._dac_present
+
+    @property
+    def dac(self) -> adafruit_tlv320.TLV320DAC3100 | None:
+        return self._dac if self._dac_present else None
 
     @property
-    def audio(self):
-        return self._audio
+    def audio(self) -> audiobusio.I2SOut | None:
+        return self._audio if self._dac_present else None
 
-    def sd_check(self):
+    def sd_check(self) -> bool:
         return self._sd_mounted
 
     def play_file(self, file_name, wait_to_finish=True):
@@ -244,34 +262,36 @@ def play_file(self, file_name, wait_to_finish=True):
         :param bool wait_to_finish: flag to determine if this is a blocking call
 
         """
-
-        # can't use `with` because we need wavefile to remain open after return
-        self.wavfile = open(file_name, "rb")
-        wavedata = audiocore.WaveFile(self.wavfile)
-        self.audio.play(wavedata)
-        if not wait_to_finish:
-            return
-        while self.audio.playing:
-            pass
-        self.wavfile.close()
+        if self._dac_present:
+            # can't use `with` because we need wavefile to remain open after return
+            self.wavfile = open(file_name, "rb")
+            wavedata = audiocore.WaveFile(self.wavfile)
+            self.audio.play(wavedata)
+            if not wait_to_finish:
+                return
+            while self.audio.playing:
+                pass
+            self.wavfile.close()
 
     def play_mp3_file(self, filename):
-        if self._mp3_decoder is None:
-            from audiomp3 import MP3Decoder  # noqa: PLC0415, import outside top-level
+        if self._dac_present:
+            if self._mp3_decoder is None:
+                from audiomp3 import MP3Decoder  # noqa: PLC0415, import outside top-level
 
-            self._mp3_decoder = MP3Decoder(filename)
-        else:
-            self._mp3_decoder.open(filename)
+                self._mp3_decoder = MP3Decoder(filename)
+            else:
+                self._mp3_decoder.open(filename)
 
-        self.audio.play(self._mp3_decoder)
-        while self.audio.playing:
-            pass
+            self.audio.play(self._mp3_decoder)
+            while self.audio.playing:
+                pass
 
     def stop_play(self):
         """Stops playing a wav file."""
-        self.audio.stop()
-        if self.wavfile is not None:
-            self.wavfile.close()
+        if self._dac_present:
+            self.audio.stop()
+            if self.wavfile is not None:
+                self.wavfile.close()
 
     @property
     def volume(self) -> int:
@@ -297,8 +317,7 @@ def volume(self, volume_level: int) -> None:
 for the safe_volume_limit with the constructor or property."""
             )
 
-        self._volume = volume_level
-        self._apply_volume()
+        self._apply_volume(volume_level)
 
     @property
     def audio_output(self) -> str:
@@ -311,22 +330,26 @@ def audio_output(self) -> str:
     @audio_output.setter
     def audio_output(self, audio_output: str) -> None:
         """
-
         :param audio_output: The audio interface to use 'speaker' or 'headphone'.
         :return: None
         """
         if audio_output == "headphone":
-            self._dac.headphone_output = True
-            self._dac.speaker_output = False
+            if self._dac_present:
+                self._dac.headphone_output = True
+                self._dac.speaker_output = False
         elif audio_output == "speaker":
-            self._dac.headphone_output = False
-            self._dac.speaker_output = True
+            if self._dac_present:
+                self._dac.headphone_output = False
+                self._dac.speaker_output = True
         else:
             raise ValueError("audio_output must be either 'headphone' or 'speaker'")
+        self._audio_output = audio_output
 
-    def _apply_volume(self) -> None:
+    def _apply_volume(self, volume_level: int) -> None:
         """
         Map the basic volume level to a db value and set it on the DAC.
         """
-        db_val = map_range(self._volume, 1, 20, -63, 23)
-        self._dac.dac_volume = db_val
+        self._volume = volume_level
+        if self._dac_present:
+            db_val = map_range(self._volume, 1, 20, -63, 23)
+            self._dac.dac_volume = db_val