Feature/advanced biamp

components/custom_board/CMakeLists.txt

@@ -2,6 +2,11 @@
 set(COMPONENT_REQUIRES audio_hal audio_board)
 set(COMPONENT_PRIV_REQUIRES esp_peripherals)
 
+# Add tas5805m_settings dependency when TAS5805M DAC is enabled
+if(CONFIG_DAC_TAS5805M)
+  list(APPEND COMPONENT_PRIV_REQUIRES tas5805m_settings)
+endif()
+
 if(CONFIG_AUDIO_BOARD_CUSTOM)
   message(STATUS "Current board name is " CONFIG_AUDIO_BOARD_CUSTOM)
   set(COMPONENT_ADD_INCLUDEDIRS ./generic_board/include)
@@ -49,6 +54,7 @@ if(CONFIG_AUDIO_BOARD_CUSTOM)
   if(CONFIG_DAC_TAS5805M)
 	message(STATUS "Selected DAC is " CONFIG_DAC_TAS5805M)
 	list(APPEND COMPONENT_ADD_INCLUDEDIRS ./tas5805m/include)
+	list(APPEND COMPONENT_ADD_INCLUDEDIRS ../tas5805m_settings/include)
 	list(APPEND COMPONENT_SRCS ./tas5805m/tas5805m.c)
   endif()
 

components/custom_board/tas5805m/tas5805m.c

@@ -30,9 +30,18 @@
 #include "i2c_bus.h"
 #include "tas5805m_reg_cfg.h"
 #include <math.h>
+#include "freertos/semphr.h"
+#include "freertos/portmacro.h"
+
+#if CONFIG_DAC_TAS5805M
+#include "tas5805m_settings.h"
+#endif
 
 static const char *TAG = "TAS5805M";
 
+/* Mutex for thread-safe I2C access */
+static SemaphoreHandle_t tas5805m_i2c_mutex = NULL;
+
 #define TAS5805M_SET_BOOK_AND_PAGE(BOOK, PAGE) \
     do { \
       tas5805m_write_byte(TAS5805M_REG_PAGE_SET, TAS5805M_REG_PAGE_ZERO); \
@@ -157,6 +166,11 @@ void i2c_master_init() {
 
 // Reading of TAS5805M-Register
 esp_err_t tas5805m_read_byte(uint8_t register_name, uint8_t *data) {
+  if (tas5805m_i2c_mutex && xSemaphoreTakeRecursive(tas5805m_i2c_mutex, pdMS_TO_TICKS(1000)) != pdTRUE) {
+    ESP_LOGE(TAG, "%s: Failed to acquire I2C mutex", __func__);
+    return ESP_ERR_TIMEOUT;
+  }
+
   int ret;
   i2c_cmd_handle_t cmd = i2c_cmd_link_create();
   i2c_master_start(cmd);
@@ -179,11 +193,18 @@ esp_err_t tas5805m_read_byte(uint8_t register_name, uint8_t *data) {
   ret = i2c_master_cmd_begin(I2C_TAS5805M_MASTER_NUM, cmd, pdMS_TO_TICKS(1000));
   i2c_cmd_link_delete(cmd);
   ESP_LOGV(TAG, "%s: Read 0x%02x from register 0x%02x", __func__, *data, register_name);
+
+  if (tas5805m_i2c_mutex) xSemaphoreGiveRecursive(tas5805m_i2c_mutex);
   return ret;
 }
 
 // Writing of TAS5805M-Register
 esp_err_t tas5805m_write_byte(uint8_t register_name, uint8_t value) {
+  if (tas5805m_i2c_mutex && xSemaphoreTakeRecursive(tas5805m_i2c_mutex, pdMS_TO_TICKS(1000)) != pdTRUE) {
+    ESP_LOGE(TAG, "%s: Failed to acquire I2C mutex", __func__);
+    return ESP_ERR_TIMEOUT;
+  }
+
   int ret = 0;
   ESP_LOGV(TAG, "%s: Writing 0x%02x to register 0x%02x", __func__, value, register_name);
 
@@ -203,6 +224,92 @@ esp_err_t tas5805m_write_byte(uint8_t register_name, uint8_t value) {
 
   i2c_cmd_link_delete(cmd);
 
+  if (tas5805m_i2c_mutex) xSemaphoreGiveRecursive(tas5805m_i2c_mutex);
+  return ret;
+}
+
+esp_err_t tas5805m_write_bytes(uint8_t *reg,
+                               int regLen, uint8_t *data, int datalen)
+{
+  if (tas5805m_i2c_mutex && xSemaphoreTakeRecursive(tas5805m_i2c_mutex, pdMS_TO_TICKS(1000)) != pdTRUE) {
+    ESP_LOGE(TAG, "%s: Failed to acquire I2C mutex", __func__);
+    return ESP_ERR_TIMEOUT;
+  }
+
+  int ret = ESP_OK;
+  ESP_LOGV(TAG, "%s: 0x%02x <- [%d] bytes", __func__, *reg, datalen);
+  for (int i = 0; i < datalen; i++)
+  {
+    ESP_LOGV(TAG, "%s: 0x%02x", __func__, data[i]);
+  }
+
+  i2c_cmd_handle_t cmd = i2c_cmd_link_create();
+  ret |= i2c_master_start(cmd);
+  ret |= i2c_master_write_byte(cmd, TAS5805M_ADDRESS << 1 | WRITE_BIT, ACK_CHECK_EN);
+  ret |= i2c_master_write(cmd, reg, regLen, ACK_CHECK_EN);
+  ret |= i2c_master_write(cmd, data, datalen, ACK_CHECK_EN);
+  ret |= i2c_master_stop(cmd);
+  ret = i2c_master_cmd_begin(I2C_TAS5805M_MASTER_NUM, cmd, 1000 / portTICK_RATE_MS);
+
+  // Check if ret is OK
+  if (ret != ESP_OK)
+  {
+    ESP_LOGE(TAG, "%s: Error during I2C transmission: %s", __func__, esp_err_to_name(ret));
+  }
+
+  i2c_cmd_link_delete(cmd);
+
+  if (tas5805m_i2c_mutex) xSemaphoreGiveRecursive(tas5805m_i2c_mutex);
+  return ret;
+}
+
+esp_err_t tas5805m_read_bytes(uint8_t *reg, int regLen, uint8_t *data, int datalen)
+{
+  if (tas5805m_i2c_mutex && xSemaphoreTakeRecursive(tas5805m_i2c_mutex, pdMS_TO_TICKS(1000)) != pdTRUE) {
+    ESP_LOGE(TAG, "%s: Failed to acquire I2C mutex", __func__);
+    return ESP_ERR_TIMEOUT;
+  }
+
+  int ret = ESP_OK;
+  ESP_LOGV(TAG, "%s: 0x%02x -> [%d] bytes", __func__, *reg, datalen);
+
+  i2c_cmd_handle_t cmd = i2c_cmd_link_create();
+  ret |= i2c_master_start(cmd);
+  ret |= i2c_master_write_byte(cmd, TAS5805M_ADDRESS << 1 | WRITE_BIT, ACK_CHECK_EN);
+  ret |= i2c_master_write(cmd, reg, regLen, ACK_CHECK_EN);
+  ret |= i2c_master_stop(cmd);
+  ret = i2c_master_cmd_begin(I2C_TAS5805M_MASTER_NUM, cmd, 1000 / portTICK_RATE_MS);
+  i2c_cmd_link_delete(cmd);
+
+  if (ret != ESP_OK) {
+    ESP_LOGE(TAG, "%s: Error during I2C write phase: %s", __func__, esp_err_to_name(ret));
+    if (tas5805m_i2c_mutex) xSemaphoreGiveRecursive(tas5805m_i2c_mutex);
+    return ret;
+  }
+
+  vTaskDelay(1 / portTICK_PERIOD_MS);
+
+  cmd = i2c_cmd_link_create();
+  ret |= i2c_master_start(cmd);
+  ret |= i2c_master_write_byte(cmd, TAS5805M_ADDRESS << 1 | READ_BIT, ACK_CHECK_EN);
+  if (datalen > 1) {
+    ret |= i2c_master_read(cmd, data, datalen - 1, ACK_VAL);
+  }
+  ret |= i2c_master_read_byte(cmd, data + datalen - 1, NACK_VAL);
+  ret |= i2c_master_stop(cmd);
+  ret = i2c_master_cmd_begin(I2C_TAS5805M_MASTER_NUM, cmd, 1000 / portTICK_RATE_MS);
+
+  if (ret != ESP_OK) {
+    ESP_LOGE(TAG, "%s: Error during I2C read phase: %s", __func__, esp_err_to_name(ret));
+  } else {
+    for (int i = 0; i < datalen; i++) {
+      ESP_LOGV(TAG, "%s: [%d] = 0x%02x", __func__, i, data[i]);
+    }
+  }
+
+  i2c_cmd_link_delete(cmd);
+
+  if (tas5805m_i2c_mutex) xSemaphoreGiveRecursive(tas5805m_i2c_mutex);
   return ret;
 }
 
@@ -282,6 +389,17 @@ esp_err_t tas5805m_read_bytes(uint8_t *reg, int regLen, uint8_t *data, int datal
 esp_err_t tas5805m_init() {
   ESP_LOGD(TAG, "%s: Initializing TAS5805M", __func__);
   int ret = 0;
+
+  /* Create I2C mutex if not already created (recursive to allow nested calls).
+   * Safe without locking: called from app_main before concurrent access. */
+  if (tas5805m_i2c_mutex == NULL) {
+    tas5805m_i2c_mutex = xSemaphoreCreateRecursiveMutex();
+    if (tas5805m_i2c_mutex == NULL) {
+      ESP_LOGE(TAG, "%s: Failed to create I2C mutex", __func__);
+      return ESP_ERR_NO_MEM;
+    }
+  }
+
   // Init the I2C-Driver
   i2c_master_init();
 
@@ -346,7 +464,7 @@ esp_err_t tas5805m_init() {
   BaseType_t task_ret = xTaskCreate(
     tas5805m_fault_monitor_task,
     "tas5805m_faults",
-    3 * 1024,
+    4096,
     NULL,
     5,
     &tas5805m_fault_monitor_task_handle
@@ -419,6 +537,10 @@ esp_err_t tas5805m_set_volume(int vol) {
   esp_err_t ret = tas5805m_write_byte(TAS5805M_DIG_VOL_CTRL_REGISTER, reg_val);
   if (ret == ESP_OK) {
     tas5805m_state.volume = vol;
+#if CONFIG_DAC_TAS5805M
+    /* Apply loudness compensation based on new volume level */
+    tas5805m_loudness_apply(vol);
+#endif
   } else {
     ESP_LOGW(TAG, "%s: Failed to write volume (reg 0x%02x): %s", __func__, reg_val, esp_err_to_name(ret));
   }
@@ -1176,36 +1298,42 @@ esp_err_t tas5805m_read_biquad_coefficients(tas5805m_eq_chan_t channel, int band
     return ESP_ERR_INVALID_ARG;
   }
 
-  ESP_LOGD(TAG, "%s: Reading biquad coefficients for channel %d, band %d", 
+  ESP_LOGD(TAG, "%s: Reading biquad coefficients for channel %d, band %d",
            __func__, channel, band);
 
   esp_err_t ret = ESP_OK;
   uint8_t page, offset;
   uint32_t raw_value;
-  
+
   // Read each coefficient
   float *coeffs[] = {b0, b1, b2, a1, a2};
   const char *names[] = {"B0", "B1", "B2", "A1", "A2"};
-  
+
   for (int i = 0; i < TAS5805M_EQ_KOEF_PER_BAND; i++) {
     ret = tas5805m_get_biquad_register(channel, band, i, &page, &offset);
     if (ret != ESP_OK) {
       return ret;
     }
-    
+
     TAS5805M_SET_BOOK_AND_PAGE(TAS5805M_REG_BOOK_EQ, page);
-    
+
     ret = tas5805m_read_bytes(&offset, 1, (uint8_t *)&raw_value, sizeof(raw_value));
     if (ret != ESP_OK) {
-      ESP_LOGE(TAG, "%s: Failed to read coefficient %s: %s", 
+      ESP_LOGE(TAG, "%s: Failed to read coefficient %s: %s",
                __func__, names[i], esp_err_to_name(ret));
       break;
     }
-    
+
     *coeffs[i] = tas5805m_q5_27_to_float(raw_value);
     ESP_LOGD(TAG, "%s: %s = %f (raw: 0x%08X)", __func__, names[i], *coeffs[i], (unsigned int)raw_value);
   }
-
+
+  // TAS5805M uses addition convention for feedback: y = b0*x + b1*x1 + b2*x2 + a1*y1 + a2*y2
+  // Standard DSP uses subtraction: y = b0*x + b1*x1 + b2*x2 - a1*y1 - a2*y2
+  // Negate a1 and a2 to convert from TAS5805M convention back to standard DSP convention
+  *a1 = -(*a1);
+  *a2 = -(*a2);
+
   TAS5805M_SET_BOOK_AND_PAGE(TAS5805M_REG_BOOK_CONTROL_PORT, TAS5805M_REG_PAGE_ZERO);
   return ret;
 }
@@ -1224,7 +1352,10 @@ esp_err_t tas5805m_write_biquad_coefficients(tas5805m_eq_chan_t channel, int ban
   uint8_t page, offset;
   uint32_t raw_value;
 
-  float coeffs[] = {b0, b1, b2, a1, a2};
+  // TAS5805M uses addition convention for feedback: y = b0*x + b1*x1 + b2*x2 + a1*y1 + a2*y2
+  // Standard DSP uses subtraction: y = b0*x + b1*x1 + b2*x2 - a1*y1 - a2*y2
+  // So we negate a1 and a2 to convert from standard DSP convention to TAS5805M convention
+  float coeffs[] = {b0, b1, b2, -a1, -a2};
   const char *names[] = {"B0", "B1", "B2", "A1", "A2"};
 
   for (int i = 0; i < TAS5805M_EQ_KOEF_PER_BAND; i++) {
@@ -1302,8 +1433,8 @@ uint32_t tas5805m_float_to_q5_27(float value)
     int32_t fixed_val = (int32_t)(value * (1 << 27));
     uint32_t le_val = tas5805m_swap_endian_32((uint32_t)fixed_val);
 
-    // ESP_LOGD(TAG, "%s: value=%f -> fixed_val=%d, le_val=0x%08X",
-    //          __func__, value, fixed_val, (unsigned int)le_val);
+    ESP_LOGD(TAG, "%s: value=%f -> fixed_val=%ld, le_val=0x%08lX",
+             __func__, value, (long)fixed_val, (unsigned long)le_val);
 
     return le_val;
 }

components/lightsnapcast/player.c

@@ -582,7 +582,10 @@ int start_player() {
   esp_pm_lock_acquire(player_pm_lock_handle);
 #endif
 
-  if (pcmChkQHdl == NULL) 
+  // create message queue to inform task of changed settings
+  snapcastSettingQueueHandle = xQueueCreate(1, sizeof(uint8_t));
+
+  if (pcmChkQHdl == NULL)
   {
 
     int entries = ceil(((float)scSet->sr / (float)scSet->chkInFrames) *

components/tas5805m_settings/CMakeLists.txt

@@ -1,5 +1,5 @@
 idf_component_register(
-    SRCS "tas5805m_settings.c"
+    SRCS "tas5805m_settings.c" "tas5805m_biamp.c"
     INCLUDE_DIRS "include"
     REQUIRES nvs_flash custom_board json
 )