michele/DigiRadio
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fix Si4684 pitch distortion: uncalibrated crystal (CTUN/XTAL_FREQ)

Browse Source 
Root cause of FM/DAB "stonata" audio: xtalCtun=31/nominal XTAL_FREQ
defaults were never measured against this board's actual crystal
(Abracon ABM8-19.200MHZ-10-1-U-T, CL=10pF, two external 15pF load
caps). Fixed via CTUN trim by ear (31->0) plus a new live calibration
loop that reads the Si4684's own FM_RSQ FREQOFF field (broadcast
carriers are GPS-locked, so it's a free precision frequency reference)
to trim XTAL_FREQ with no lab equipment. Converged to CTUN=0,
XTAL_FREQ=19199750 Hz, residual -3/-4 ppm cross-checked on two
stations.

New tools/infrastructure (kept, not one-off):
- Si4684Driver::recalibrateXtal() + POST /api/tuner/xtal-calibrate:
  live crystal re-trim without an ESP32 reflash.
- FM_RSQ FREQOFF exposed as "freqoff_ppm" in GET /api/tuner/status.
- tools/si4684_xtal_calibration.py: automates the trim loop.
- tools/si4684_antenna_calibration.py: AN851 Appendix A ANTCAP/VARM/VARB
  sweep tool (same session, separate calibration).
- CONFIG_ESP32_I2S_TEST_TONE (off by default): isolates Si4684-specific
  audio issues from shared-downstream ones by writing a tone directly
  over the I2S bus the Si4684 also uses.
- SIGMA_WRITE_REGISTER_BLOCK/sigma_safeload_block now retry on NACK and
  verify via read-back instead of firing I2C writes blind.
- FM de-emphasis set to European 50us (was left at the US 75us default).
- DAB_ACF_ENABLE restored to its previous 0x0000 with a citation
  explaining why (tested the datasheet default of 0x0003, made things
  audibly worse).

See docs/si4684-rf-investigation-report.md's 2026-08-23 entry for the
full elimination chain and docs/TODO.md for follow-up work (persisting
calibration results to EEPROM instead of requiring a firmware edit).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
michele
2026-08-23 20:30:42 +02:00
co-authored by Claude Sonnet 5
parent a91c63fc31
commit fae2305164
24 changed files with 1309 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Software/components/drivers/adau1701/src/Adau1701Driver.cpp
+83 -9
View File
@@ -68,6 +68,7 @@ namespace adau1701
{
const unsigned char deviceAddr =
static_cast<unsigned char>(pins_.i2cAddr7 << 1);
std::size_t index = 0U;
for (const core::RegisterWrite &write : program.writes())
{
const auto data = write.data();
@@ -75,12 +76,35 @@ namespace adau1701
{
return std::unexpected(Adau1701Error::DownloadFailed);
}
SIGMA_WRITE_REGISTER_BLOCK(
deviceAddr,
write.address(),
static_cast<unsigned int>(data.size()),
const_cast<ADI_REG_TYPE *>(
reinterpret_cast<const ADI_REG_TYPE *>(data.data())));
auto *bytes = const_cast<ADI_REG_TYPE *>(
reinterpret_cast<const ADI_REG_TYPE *>(data.data()));
const auto length = static_cast<unsigned int>(data.size());
if (SIGMA_WRITE_REGISTER_BLOCK(deviceAddr, write.address(), length,
bytes) != 0)
{
ESP_LOGE(kTag,
"program write #%u failed (addr=0x%04X len=%u) "
"after retries",
static_cast<unsigned>(index),
static_cast<unsigned>(write.address()),
static_cast<unsigned>(length));
return std::unexpected(Adau1701Error::DownloadFailed);
}
// Diagnostic only: an ACKed write that still reads back wrong
// would otherwise be invisible (see the SIGMA_WRITE_REGISTER_BLOCK
// comment in SigmaStudioFW.c). Logged, not fatal -- some
// addresses in this range may be self-clearing/status bits
// that legitimately don't read back what was written.
if (sigma_verify_block(write.address(), bytes, length) != 0)
{
ESP_LOGW(kTag,
"program write #%u read-back mismatch (addr=0x%04X "
"len=%u) -- ACKed but did not land as written",
static_cast<unsigned>(index),
static_cast<unsigned>(write.address()),
static_cast<unsigned>(length));
}
++index;
}
return {};
}
@@ -158,19 +182,69 @@ namespace adau1701
return replay;
}
// Diagnostic: log EQ band 0's live Param RAM contents. This band is
// the fixed high-pass (SigmaStudio band 1) and applyEq() always
// skips it -- no runtime code path ever safeloads it, so whatever
// landed here at program-load time is what plays, permanently,
// regardless of the audio-profile API (which reports a fictional
// value for it). Read straight from the chip rather than trusting
// the compiled source, in case the two have ever diverged.
{
const unsigned baseAddr = paramAddrEqBandBase(0U);
for (unsigned i = 0U; i < 5U; ++i)
{
unsigned char raw[4U] = {0U, 0U, 0U, 0U};
if (sigma_i2c_read(baseAddr + i, raw, sizeof(raw)) == 0)
{
const std::int32_t fixpoint =
static_cast<std::int32_t>(
(static_cast<std::uint32_t>(raw[0]) << 24) |
(static_cast<std::uint32_t>(raw[1]) << 16) |
(static_cast<std::uint32_t>(raw[2]) << 8) |
static_cast<std::uint32_t>(raw[3]));
ESP_LOGI(kTag,
"EQ band0 param[%u] addr=0x%04X raw=0x%08X "
"value=%f",
i, baseAddr + i,
static_cast<unsigned>(fixpoint),
static_cast<double>(fixpoint) /
static_cast<double>(1U << 23));
}
else
{
ESP_LOGW(kTag, "EQ band0 param[%u] read-back failed", i);
}
}
}
// SerialInputRegister (0x081F) override: bit3 IBP=1, matching the
// BCLK edge the Si4684's I2S output actually changes data on
// (compiled DSP program default is 0x00 = IBP=0, which produced
// pure static on a strong locked signal). ILP=1 was also tried
// (0x18) and made it worse (pure white noise again) — IBP alone
// (0x08) is the correct override, confirmed live: real, recognizable
// music instead of static/noise on a locked FM station.
// music instead of static/noise on a locked FM station. Redundant
// with the R3_HWCONFIGURATION program write above (SigmaStudio's
// own export already places 0x08 at this address) — kept as a
// belt-and-braces re-assert in case that specific chunk silently
// failed; now checked/verified like everything else instead of
// fire-and-forget.
{
const unsigned char deviceAddr =
static_cast<unsigned char>(pins_.i2cAddr7 << 1);
ADI_REG_TYPE serialInFix = 0x08U;
SIGMA_WRITE_REGISTER_BLOCK(deviceAddr, 0x081FU, 1U,
&serialInFix);
if (SIGMA_WRITE_REGISTER_BLOCK(deviceAddr, 0x081FU, 1U,
&serialInFix) != 0)
{
ESP_LOGE(kTag, "SerialInputRegister override failed after retries");
return std::unexpected(Adau1701Error::DownloadFailed);
}
if (sigma_verify_block(0x081FU, &serialInFix, 1U) != 0)
{
ESP_LOGW(kTag,
"SerialInputRegister read-back mismatch -- ACKed "
"but did not land as 0x08");
}
}
booted_ = true;
Software/components/drivers/adau1701/src/SigmaStudioFW.c
+115 -11
View File
@@ -14,12 +14,14 @@
#include "SigmaStudioFW.h"
#include "driver/i2c_master.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#include "freertos/task.h"
#include <string.h>
static const char* kTag = "SigmaStudioFW";
static i2c_master_dev_handle_t s_dev = NULL;
static SemaphoreHandle_t s_lock = NULL;
@@ -73,14 +75,45 @@ static unsigned int sigmaWordSize(unsigned int address)
return 4U;
}
void SIGMA_WRITE_REGISTER_BLOCK(unsigned char devAddress,
unsigned int address,
unsigned int length,
ADI_REG_TYPE* pData)
/*
* The boot-time program/param replay was previously fire-and-forget: the
* i2c_master_transmit result was discarded outright, so a single transient
* NACK anywhere in the hundreds of chunked writes that make up a DSP
* program load silently left that one chunk (a gain, a filter, a mux)
* at its power-on-reset RAM contents instead of the SigmaStudio-designed
* value -- indistinguishable at the time from a correct load, but capable
* of producing exactly a persistent, localized audio artifact rather than
* gross silence. Give it the same retry-on-NACK reliability the runtime
* safeload path already got in sigma_i2c_write (see its comment) and make
* failure observable instead of silent.
*/
static int sigmaTransmitChunk(unsigned int addr, const ADI_REG_TYPE* payload,
unsigned int chunkBytes)
{
unsigned char buf[2U + 64U];
buf[0] = (unsigned char)((addr >> 8) & 0xFFU);
buf[1] = (unsigned char)(addr & 0xFFU);
memcpy(buf + 2U, payload, chunkBytes);
static const int kMaxAttempts = 3;
for (int attempt = 0; attempt < kMaxAttempts; ++attempt) {
if (i2c_master_transmit(s_dev, buf, (size_t)(2U + chunkBytes), 1000) ==
ESP_OK) {
return 0;
}
vTaskDelay(pdMS_TO_TICKS(2));
}
return -1;
}
int SIGMA_WRITE_REGISTER_BLOCK(unsigned char devAddress,
unsigned int address,
unsigned int length,
ADI_REG_TYPE* pData)
{
(void)devAddress;
if (s_dev == NULL || pData == NULL || length == 0U) {
return;
return -1;
}
enum { kChunkBytesMax = 64U };
@@ -96,15 +129,48 @@ void SIGMA_WRITE_REGISTER_BLOCK(unsigned char devAddress,
const unsigned int chunk =
remaining > chunkBytes ? chunkBytes : remaining;
const unsigned int words = chunk / wordSize;
unsigned char buf[2U + kChunkBytesMax];
buf[0] = (unsigned char)((addr >> 8) & 0xFFU);
buf[1] = (unsigned char)(addr & 0xFFU);
memcpy(buf + 2U, cursor, chunk);
i2c_master_transmit(s_dev, buf, (size_t)(2U + chunk), 1000);
if (sigmaTransmitChunk(addr, cursor, chunk) != 0) {
return -1;
}
addr += words;
cursor += chunk;
remaining -= chunk;
}
return 0;
}
int sigma_verify_block(unsigned int address, const ADI_REG_TYPE* expected,
unsigned int length)
{
if (s_dev == NULL || expected == NULL || length == 0U) {
return -1;
}
enum { kChunkBytesMax = 64U };
const unsigned int wordSize = sigmaWordSize(address);
const unsigned int wordsPerChunk = kChunkBytesMax / wordSize;
const unsigned int chunkBytes = wordsPerChunk * wordSize;
unsigned int addr = address;
unsigned int remaining = length;
const ADI_REG_TYPE* cursor = expected;
while (remaining > 0U) {
const unsigned int chunk =
remaining > chunkBytes ? chunkBytes : remaining;
const unsigned int words = chunk / wordSize;
unsigned char readBack[kChunkBytesMax];
if (sigma_i2c_read(addr, readBack, chunk) != 0) {
return -1;
}
if (memcmp(readBack, cursor, chunk) != 0) {
return -1;
}
addr += words;
cursor += chunk;
remaining -= chunk;
}
return 0;
}
int sigma_i2c_read(unsigned int reg, unsigned char* data, unsigned int length)
@@ -198,6 +264,37 @@ int sigma_safeload_param(unsigned int paramAddr, int fixpoint)
return sigma_safeload_block(1U, addrs, values);
}
/*
* Diagnostic only, mirrors the boot-replay read-back in
* SIGMA_WRITE_REGISTER_BLOCK: a safeload can ACK every transaction and
* still not land as intended (address/data written to the wrong Param RAM
* slot, a stale value left from a previous session's committed-but-later-
* garbled write, etc). This is the runtime path applied on every EQ/gain
* change and on the stored-profile replay at boot -- unlike the one-time
* program load, it was previously unverified. Log-only: some callers pass
* addresses this can't independently confirm are readable Param RAM (vs.
* a write-only control register), so a mismatch here is a strong signal,
* not a hard boot/apply-time failure.
*/
static void sigmaVerifyParam(unsigned int paramAddr, int fixpoint)
{
unsigned char readBack[4U];
if (sigma_i2c_read(paramAddr, readBack, sizeof(readBack)) != 0) {
ESP_LOGW(kTag, "safeload verify: read-back failed for param 0x%04X",
paramAddr);
return;
}
const int actual = (int)(((unsigned int)readBack[0] << 24) |
((unsigned int)readBack[1] << 16) |
((unsigned int)readBack[2] << 8) |
(unsigned int)readBack[3]);
if (actual != fixpoint) {
ESP_LOGW(kTag,
"safeload verify: param 0x%04X mismatch, wrote %d read %d",
paramAddr, fixpoint, actual);
}
}
int sigma_safeload_block(unsigned char count, const unsigned int* paramAddrs,
const int* fixpoints)
{
@@ -218,7 +315,14 @@ int sigma_safeload_block(unsigned char count, const unsigned int* paramAddrs,
}
}
return sigma_trigger_safeload();
if (sigma_trigger_safeload() != 0) {
return -1;
}
for (unsigned char i = 0U; i < count; ++i) {
sigmaVerifyParam(paramAddrs[i], fixpoints[i]);
}
return 0;
}
int sigma_safeload_raw_block(unsigned char count, const unsigned int* paramAddrs,