Add internet radio streaming with runtime API, modernize web UI, remove auto-tune/beep at boot
Streaming (main feature this session): - New WebRadioConfig/WebRadioJson core types, ISecureStore-backed persistence - New webradio::WebRadioService (thread-safe live config) + GET/POST /api/streaming - web_radio_stream task now runtime-toggleable (no reboot), no hardcoded URL - Content-Type diagnostic: warns clearly when a URL is a webpage, not an audio stream Boot cleanup: - Removed boot-time auto FM/DAB tune, auto-beep, and the (now-concluded) Si4684 crystal IBIAS/CTUN empirical sweep from main.cpp — tuning/beep are on-demand via the existing REST API only Web UI: - Modernized styling (cards, gradients, toggle switches, light/dark theme) - New Stream tab wired to /api/streaming Fixes found via real idf.py build (not just clangd): - Restored wrongly-removed si4684/Si4684Tuner.hpp include in main.cpp - Fixed MP3Decode() argument types in web_radio_stream.cpp (unsigned char**/int*) Quality-gate fixes: - Host-test stub headers (esp_log.h, freertos/*) so TunerService.cpp's scanForStation logging/pacing compiles for station_service_test / integration_service_test instead of running stale binaries - Added WifiScanner and WebRadioService manual sections; filled in missing Doxygen docs on BluetoothService, i2s_sdata_probe, test_firmware, Bt1035At - Ignore clangd's .cache/ index directory Also includes prior uncommitted work carried in the tree: Wi-Fi/Bluetooth device scan REST API and UI (WifiScanner, BT scan), SigmaStudio TCP bridge, and the current ADAU1701 SigmaStudio DSP program export. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
Claude Sonnet 5
@@ -220,6 +220,20 @@ public:
|
||||
core::EqBandIndex band, core::GainDb gain, core::FrequencyHz center,
|
||||
float q);
|
||||
|
||||
/**
|
||||
* @brief setBeepEnabled — gate the SigmaStudio Beep1 tone generator.
|
||||
*
|
||||
* @dname setBeepEnabled
|
||||
* @param enabled true unmutes Beep1, false mutes it.
|
||||
* @return Ok on success, or Adau1701Error.
|
||||
* @pubstate writes parameter RAM via safeload (ADDR_BEEP1_ENABLE).
|
||||
*
|
||||
* @author Michele Bigi
|
||||
* @date 2026-08-07
|
||||
*/
|
||||
[[nodiscard]] std::expected<void, Adau1701Error> setBeepEnabled(
|
||||
bool enabled);
|
||||
|
||||
private:
|
||||
[[nodiscard]] std::expected<void, Adau1701Error> ensureBooted() const;
|
||||
[[nodiscard]] std::expected<void, Adau1701Error> safeloadGain(
|
||||
|
||||
@@ -61,6 +61,9 @@ public:
|
||||
core::EqBandIndex band, core::GainDb gain, core::FrequencyHz center,
|
||||
float q) override;
|
||||
|
||||
[[nodiscard]] std::expected<void, core::DspError> setBeepEnabled(
|
||||
bool enabled) override;
|
||||
|
||||
private:
|
||||
[[nodiscard]] static core::DspError mapError(Adau1701Error error) noexcept;
|
||||
|
||||
|
||||
@@ -27,273 +27,345 @@
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
|
||||
extern "C" {
|
||||
extern "C"
|
||||
{
|
||||
|
||||
} // extern "C"
|
||||
|
||||
namespace adau1701 {
|
||||
|
||||
namespace {
|
||||
constexpr char kTag[] = "Adau1701";
|
||||
constexpr int kI2cPort = 0;
|
||||
/** Index 0 is the fixed high-pass band (SigmaStudio band 1); not safeloaded. */
|
||||
constexpr std::uint8_t kFixedHighPassBandIndex = 0U;
|
||||
} // namespace
|
||||
|
||||
Adau1701Driver::Adau1701Driver(Adau1701Pins pins,
|
||||
core::IDspProgramSource& programSource)
|
||||
: pins_(pins)
|
||||
, programSource_(programSource)
|
||||
, booted_(false)
|
||||
, i2cBus_(nullptr)
|
||||
, i2cDev_(nullptr)
|
||||
namespace adau1701
|
||||
{
|
||||
}
|
||||
|
||||
Adau1701Driver::~Adau1701Driver()
|
||||
{
|
||||
auto* dev = static_cast<i2c_master_dev_handle_t>(i2cDev_);
|
||||
auto* bus = static_cast<i2c_master_bus_handle_t>(i2cBus_);
|
||||
if (dev != nullptr) {
|
||||
i2c_master_bus_rm_device(dev);
|
||||
namespace
|
||||
{
|
||||
constexpr char kTag[] = "Adau1701";
|
||||
constexpr int kI2cPort = 0;
|
||||
/** Index 0 is the fixed high-pass band (SigmaStudio band 1); not safeloaded. */
|
||||
constexpr std::uint8_t kFixedHighPassBandIndex = 0U;
|
||||
} // namespace
|
||||
|
||||
Adau1701Driver::Adau1701Driver(Adau1701Pins pins,
|
||||
core::IDspProgramSource &programSource)
|
||||
: pins_(pins), programSource_(programSource), booted_(false), i2cBus_(nullptr), i2cDev_(nullptr)
|
||||
{
|
||||
}
|
||||
if (bus != nullptr) {
|
||||
i2c_del_master_bus(bus);
|
||||
}
|
||||
}
|
||||
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::replayProgram(
|
||||
const core::DspProgram& program)
|
||||
{
|
||||
const unsigned char deviceAddr =
|
||||
static_cast<unsigned char>(pins_.i2cAddr7 << 1);
|
||||
for (const core::RegisterWrite& write : program.writes()) {
|
||||
const auto data = write.data();
|
||||
if (data.empty()) {
|
||||
return std::unexpected(Adau1701Error::DownloadFailed);
|
||||
Adau1701Driver::~Adau1701Driver()
|
||||
{
|
||||
auto *dev = static_cast<i2c_master_dev_handle_t>(i2cDev_);
|
||||
auto *bus = static_cast<i2c_master_bus_handle_t>(i2cBus_);
|
||||
if (dev != nullptr)
|
||||
{
|
||||
i2c_master_bus_rm_device(dev);
|
||||
}
|
||||
if (bus != nullptr)
|
||||
{
|
||||
i2c_del_master_bus(bus);
|
||||
}
|
||||
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())));
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::boot()
|
||||
{
|
||||
if (booted_) {
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::replayProgram(
|
||||
const core::DspProgram &program)
|
||||
{
|
||||
const unsigned char deviceAddr =
|
||||
static_cast<unsigned char>(pins_.i2cAddr7 << 1);
|
||||
for (const core::RegisterWrite &write : program.writes())
|
||||
{
|
||||
const auto data = write.data();
|
||||
if (data.empty())
|
||||
{
|
||||
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())));
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
gpio_config_t resetCfg = {};
|
||||
resetCfg.pin_bit_mask = 1ULL << pins_.resetGpio;
|
||||
resetCfg.mode = GPIO_MODE_OUTPUT;
|
||||
if (gpio_config(&resetCfg) != ESP_OK) {
|
||||
return std::unexpected(Adau1701Error::ResetFailed);
|
||||
}
|
||||
|
||||
gpio_set_level(static_cast<gpio_num_t>(pins_.resetGpio), 0);
|
||||
vTaskDelay(pdMS_TO_TICKS(10));
|
||||
gpio_set_level(static_cast<gpio_num_t>(pins_.resetGpio), 1);
|
||||
vTaskDelay(pdMS_TO_TICKS(10));
|
||||
|
||||
i2c_master_bus_config_t busCfg = {};
|
||||
busCfg.i2c_port = static_cast<i2c_port_num_t>(kI2cPort);
|
||||
busCfg.sda_io_num = static_cast<gpio_num_t>(pins_.i2cSda);
|
||||
busCfg.scl_io_num = static_cast<gpio_num_t>(pins_.i2cScl);
|
||||
busCfg.clk_source = I2C_CLK_SRC_DEFAULT;
|
||||
busCfg.glitch_ignore_cnt = 7;
|
||||
busCfg.flags.enable_internal_pullup = true;
|
||||
|
||||
i2c_master_bus_handle_t bus = nullptr;
|
||||
if (i2c_new_master_bus(&busCfg, &bus) != ESP_OK) {
|
||||
ESP_LOGE(kTag, "i2c_new_master_bus failed");
|
||||
return std::unexpected(Adau1701Error::I2cInitFailed);
|
||||
}
|
||||
i2cBus_ = bus;
|
||||
|
||||
i2c_device_config_t devCfg = {};
|
||||
devCfg.dev_addr_length = I2C_ADDR_BIT_LEN_7;
|
||||
devCfg.device_address = static_cast<uint16_t>(pins_.i2cAddr7);
|
||||
devCfg.scl_speed_hz = 100000;
|
||||
|
||||
i2c_master_dev_handle_t dev = nullptr;
|
||||
if (i2c_master_bus_add_device(bus, &devCfg, &dev) != ESP_OK) {
|
||||
ESP_LOGE(kTag, "i2c_master_bus_add_device failed");
|
||||
return std::unexpected(Adau1701Error::I2cInitFailed);
|
||||
}
|
||||
i2cDev_ = dev;
|
||||
|
||||
sigma_studio_bind_i2c(kI2cPort, static_cast<unsigned char>(pins_.i2cAddr7));
|
||||
sigma_studio_set_device(dev);
|
||||
|
||||
const auto program = programSource_.loadProgram();
|
||||
if (!program) {
|
||||
ESP_LOGE(kTag, "DSP program load failed");
|
||||
return std::unexpected(Adau1701Error::DownloadFailed);
|
||||
}
|
||||
if (auto replay = replayProgram(*program); !replay) {
|
||||
return replay;
|
||||
}
|
||||
|
||||
booted_ = true;
|
||||
ESP_LOGI(kTag, "SigmaStudio program loaded");
|
||||
return {};
|
||||
}
|
||||
|
||||
bool Adau1701Driver::isBooted() const noexcept
|
||||
{
|
||||
return booted_;
|
||||
}
|
||||
|
||||
void* Adau1701Driver::i2cBusHandle() const noexcept
|
||||
{
|
||||
return i2cBus_;
|
||||
}
|
||||
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::ensureBooted() const
|
||||
{
|
||||
if (!booted_) {
|
||||
return std::unexpected(Adau1701Error::NotBooted);
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::safeloadFixpoint(
|
||||
unsigned paramAddr, std::int32_t fixpoint)
|
||||
{
|
||||
if (sigma_safeload_param(paramAddr, fixpoint) != 0) {
|
||||
return std::unexpected(Adau1701Error::SafeloadFailed);
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::safeloadGain(
|
||||
unsigned paramAddr, core::GainDb gain)
|
||||
{
|
||||
return safeloadFixpoint(paramAddr, core::gainDbToLinearFixpoint(gain));
|
||||
}
|
||||
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::setInputVolume(
|
||||
core::MixSource source, core::GainDb left, core::GainDb right)
|
||||
{
|
||||
if (auto ready = ensureBooted(); !ready) {
|
||||
return ready;
|
||||
}
|
||||
if (auto result = safeloadGain(paramAddrInputLeft(source), left); !result) {
|
||||
return result;
|
||||
}
|
||||
return safeloadGain(paramAddrInputRight(source), right);
|
||||
}
|
||||
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::setMasterVolume(
|
||||
core::GainDb left, core::GainDb right)
|
||||
{
|
||||
if (auto ready = ensureBooted(); !ready) {
|
||||
return ready;
|
||||
}
|
||||
if (auto result = safeloadGain(static_cast<unsigned>(ADDR_MULTIPLE1), left);
|
||||
!result) {
|
||||
return result;
|
||||
}
|
||||
return safeloadGain(static_cast<unsigned>(ADDR_MULTIPLE1_1), right);
|
||||
}
|
||||
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::applyMixer(
|
||||
const core::MixerState& mixer)
|
||||
{
|
||||
if (auto ready = ensureBooted(); !ready) {
|
||||
return ready;
|
||||
}
|
||||
if (auto result = setInputVolume(core::MixSource::Si4684, mixer.si4684Left,
|
||||
mixer.si4684Right);
|
||||
!result) {
|
||||
return result;
|
||||
}
|
||||
if (auto result = setInputVolume(core::MixSource::Esp32, mixer.esp32Left,
|
||||
mixer.esp32Right);
|
||||
!result) {
|
||||
return result;
|
||||
}
|
||||
if (auto result =
|
||||
safeloadGain(static_cast<unsigned>(ADDR_STMIXER1_ST0_VOLUME),
|
||||
mixer.mixLeft);
|
||||
!result) {
|
||||
return result;
|
||||
}
|
||||
return safeloadGain(static_cast<unsigned>(ADDR_STMIXER1_ST1_VOLUME),
|
||||
mixer.mixRight);
|
||||
}
|
||||
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::setEqBand(
|
||||
core::EqBandIndex band, core::GainDb gain, core::FrequencyHz center, float q)
|
||||
{
|
||||
if (band.value() == kFixedHighPassBandIndex) {
|
||||
return std::unexpected(Adau1701Error::InvalidParameter);
|
||||
}
|
||||
|
||||
if (auto ready = ensureBooted(); !ready) {
|
||||
return ready;
|
||||
}
|
||||
|
||||
const core::BiquadCoefficients coeffs =
|
||||
core::designPeakingEq(center, gain, q);
|
||||
const auto fixpoints = coeffs.toFixpoint823();
|
||||
const unsigned baseAddr = paramAddrEqBandBase(band.value());
|
||||
|
||||
unsigned addrs[5U];
|
||||
int values[5U];
|
||||
for (unsigned i = 0U; i < 5U; ++i) {
|
||||
addrs[i] = baseAddr + i;
|
||||
values[i] = fixpoints[i];
|
||||
}
|
||||
|
||||
if (sigma_safeload_block(5U, addrs, values) != 0) {
|
||||
return std::unexpected(Adau1701Error::SafeloadFailed);
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::applyEq(
|
||||
const core::EqProfile& eq)
|
||||
{
|
||||
if (auto ready = ensureBooted(); !ready) {
|
||||
return ready;
|
||||
}
|
||||
|
||||
for (std::uint8_t i = 0; i < core::EqBandIndex::kBandCount; ++i) {
|
||||
if (i == kFixedHighPassBandIndex) {
|
||||
continue;
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::boot()
|
||||
{
|
||||
if (booted_)
|
||||
{
|
||||
return {};
|
||||
}
|
||||
const auto index = core::EqBandIndex::tryFromIndex(i);
|
||||
if (!index) {
|
||||
|
||||
gpio_config_t resetCfg = {};
|
||||
resetCfg.pin_bit_mask = 1ULL << pins_.resetGpio;
|
||||
resetCfg.mode = GPIO_MODE_OUTPUT;
|
||||
if (gpio_config(&resetCfg) != ESP_OK)
|
||||
{
|
||||
return std::unexpected(Adau1701Error::ResetFailed);
|
||||
}
|
||||
|
||||
gpio_set_level(static_cast<gpio_num_t>(pins_.resetGpio), 0);
|
||||
vTaskDelay(pdMS_TO_TICKS(10));
|
||||
gpio_set_level(static_cast<gpio_num_t>(pins_.resetGpio), 1);
|
||||
vTaskDelay(pdMS_TO_TICKS(10));
|
||||
|
||||
i2c_master_bus_config_t busCfg = {};
|
||||
busCfg.i2c_port = static_cast<i2c_port_num_t>(kI2cPort);
|
||||
busCfg.sda_io_num = static_cast<gpio_num_t>(pins_.i2cSda);
|
||||
busCfg.scl_io_num = static_cast<gpio_num_t>(pins_.i2cScl);
|
||||
busCfg.clk_source = I2C_CLK_SRC_DEFAULT;
|
||||
busCfg.glitch_ignore_cnt = 7;
|
||||
busCfg.flags.enable_internal_pullup = true;
|
||||
|
||||
i2c_master_bus_handle_t bus = nullptr;
|
||||
if (i2c_new_master_bus(&busCfg, &bus) != ESP_OK)
|
||||
{
|
||||
ESP_LOGE(kTag, "i2c_new_master_bus failed");
|
||||
return std::unexpected(Adau1701Error::I2cInitFailed);
|
||||
}
|
||||
i2cBus_ = bus;
|
||||
|
||||
i2c_device_config_t devCfg = {};
|
||||
devCfg.dev_addr_length = I2C_ADDR_BIT_LEN_7;
|
||||
devCfg.device_address = static_cast<uint16_t>(pins_.i2cAddr7);
|
||||
devCfg.scl_speed_hz = 100000;
|
||||
|
||||
i2c_master_dev_handle_t dev = nullptr;
|
||||
if (i2c_master_bus_add_device(bus, &devCfg, &dev) != ESP_OK)
|
||||
{
|
||||
ESP_LOGE(kTag, "i2c_master_bus_add_device failed");
|
||||
return std::unexpected(Adau1701Error::I2cInitFailed);
|
||||
}
|
||||
i2cDev_ = dev;
|
||||
|
||||
sigma_studio_bind_i2c(kI2cPort, static_cast<unsigned char>(pins_.i2cAddr7));
|
||||
sigma_studio_set_device(dev);
|
||||
|
||||
const auto program = programSource_.loadProgram();
|
||||
if (!program)
|
||||
{
|
||||
ESP_LOGE(kTag, "DSP program load failed");
|
||||
return std::unexpected(Adau1701Error::DownloadFailed);
|
||||
}
|
||||
ESP_LOGI(kTag,
|
||||
"DSP program contains %u writes",
|
||||
static_cast<unsigned>(program->writes().size()));
|
||||
for (const auto &w : program->writes())
|
||||
{
|
||||
ESP_LOGI(kTag,
|
||||
"ADDR=0x%04X LEN=%u",
|
||||
static_cast<unsigned>(w.address()),
|
||||
static_cast<unsigned>(w.data().size()));
|
||||
}
|
||||
if (auto replay = replayProgram(*program); !replay)
|
||||
{
|
||||
return replay;
|
||||
}
|
||||
|
||||
booted_ = true;
|
||||
ESP_LOGI(kTag, "SigmaStudio program loaded");
|
||||
return {};
|
||||
}
|
||||
|
||||
bool Adau1701Driver::isBooted() const noexcept
|
||||
{
|
||||
return booted_;
|
||||
}
|
||||
|
||||
void *Adau1701Driver::i2cBusHandle() const noexcept
|
||||
{
|
||||
return i2cBus_;
|
||||
}
|
||||
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::ensureBooted() const
|
||||
{
|
||||
if (!booted_)
|
||||
{
|
||||
return std::unexpected(Adau1701Error::NotBooted);
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::safeloadFixpoint(
|
||||
unsigned paramAddr, std::int32_t fixpoint)
|
||||
{
|
||||
sigma_studio_lock();
|
||||
const int result = sigma_safeload_param(paramAddr, fixpoint);
|
||||
sigma_studio_unlock();
|
||||
if (result != 0)
|
||||
{
|
||||
return std::unexpected(Adau1701Error::SafeloadFailed);
|
||||
}
|
||||
const core::EqBandSettings& band = eq.band(*index);
|
||||
if (auto result = setEqBand(*index, band.gain, band.center, band.q);
|
||||
!result) {
|
||||
return {};
|
||||
}
|
||||
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::safeloadGain(
|
||||
unsigned paramAddr, core::GainDb gain)
|
||||
{
|
||||
return safeloadFixpoint(paramAddr, core::gainDbToLinearFixpoint(gain));
|
||||
}
|
||||
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::setInputVolume(
|
||||
core::MixSource source, core::GainDb left, core::GainDb right)
|
||||
{
|
||||
if (auto ready = ensureBooted(); !ready)
|
||||
{
|
||||
return ready;
|
||||
}
|
||||
if (auto result = safeloadGain(paramAddrInputLeft(source), left); !result)
|
||||
{
|
||||
return result;
|
||||
}
|
||||
return safeloadGain(paramAddrInputRight(source), right);
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::applyProfile(
|
||||
const core::AudioProfile& profile)
|
||||
{
|
||||
if (auto ready = ensureBooted(); !ready) {
|
||||
return ready;
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::setMasterVolume(
|
||||
core::GainDb left, core::GainDb right)
|
||||
{
|
||||
if (auto ready = ensureBooted(); !ready)
|
||||
{
|
||||
return ready;
|
||||
}
|
||||
if (auto result = safeloadGain(static_cast<unsigned>(ADDR_MULTIPLE1), left);
|
||||
!result)
|
||||
{
|
||||
return result;
|
||||
}
|
||||
return safeloadGain(static_cast<unsigned>(ADDR_MULTIPLE1_1), right);
|
||||
}
|
||||
if (auto result = applyMixer(profile.mixer); !result) {
|
||||
return result;
|
||||
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::applyMixer(
|
||||
const core::MixerState &mixer)
|
||||
{
|
||||
if (auto ready = ensureBooted(); !ready)
|
||||
{
|
||||
return ready;
|
||||
}
|
||||
if (auto result = setInputVolume(core::MixSource::Si4684, mixer.si4684Left,
|
||||
mixer.si4684Right);
|
||||
!result)
|
||||
{
|
||||
return result;
|
||||
}
|
||||
if (auto result = setInputVolume(core::MixSource::Esp32, mixer.esp32Left,
|
||||
mixer.esp32Right);
|
||||
!result)
|
||||
{
|
||||
return result;
|
||||
}
|
||||
if (auto result =
|
||||
safeloadGain(static_cast<unsigned>(ADDR_STMIXER1_ST0_VOLUME),
|
||||
mixer.mixLeft);
|
||||
!result)
|
||||
{
|
||||
return result;
|
||||
}
|
||||
return safeloadGain(static_cast<unsigned>(ADDR_STMIXER1_ST1_VOLUME),
|
||||
mixer.mixRight);
|
||||
}
|
||||
if (auto result = applyEq(profile.eq); !result) {
|
||||
return result;
|
||||
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::setEqBand(
|
||||
core::EqBandIndex band, core::GainDb gain, core::FrequencyHz center, float q)
|
||||
{
|
||||
if (band.value() == kFixedHighPassBandIndex)
|
||||
{
|
||||
return std::unexpected(Adau1701Error::InvalidParameter);
|
||||
}
|
||||
|
||||
if (auto ready = ensureBooted(); !ready)
|
||||
{
|
||||
return ready;
|
||||
}
|
||||
|
||||
const core::BiquadCoefficients coeffs =
|
||||
core::designPeakingEq(center, gain, q);
|
||||
const auto fixpoints = coeffs.toFixpoint823();
|
||||
const unsigned baseAddr = paramAddrEqBandBase(band.value());
|
||||
|
||||
unsigned addrs[5U];
|
||||
int values[5U];
|
||||
for (unsigned i = 0U; i < 5U; ++i)
|
||||
{
|
||||
addrs[i] = baseAddr + i;
|
||||
values[i] = fixpoints[i];
|
||||
}
|
||||
|
||||
sigma_studio_lock();
|
||||
const int result = sigma_safeload_block(5U, addrs, values);
|
||||
sigma_studio_unlock();
|
||||
if (result != 0)
|
||||
{
|
||||
return std::unexpected(Adau1701Error::SafeloadFailed);
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::setBeepEnabled(
|
||||
bool enabled)
|
||||
{
|
||||
if (auto ready = ensureBooted(); !ready)
|
||||
{
|
||||
return ready;
|
||||
}
|
||||
// Beep1 ("Beep - variable gain", ADI Sound Generation toolbox,
|
||||
// DigiRadio.params) ENABLE/KICK: unity fixpoint 0x00800000 = on,
|
||||
// exact zero = off. Not continuous gains, so bypass
|
||||
// safeloadGain/GainDb (whose quietest value is -96 dB, not true
|
||||
// zero) and write the raw fixpoint. KICK is the cell's trigger
|
||||
// input (per its own SigmaStudio parameter name); ENABLE alone
|
||||
// may leave the generator gated shut without it.
|
||||
const std::int32_t value =
|
||||
enabled ? core::gainDbToLinearFixpoint(core::GainDb::zero()) : 0;
|
||||
if (auto result = safeloadFixpoint(
|
||||
static_cast<unsigned>(ADDR_BEEP1_ENABLE), value);
|
||||
!result)
|
||||
{
|
||||
return result;
|
||||
}
|
||||
return safeloadFixpoint(static_cast<unsigned>(ADDR_BEEP1_KICK), value);
|
||||
}
|
||||
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::applyEq(
|
||||
const core::EqProfile &eq)
|
||||
{
|
||||
if (auto ready = ensureBooted(); !ready)
|
||||
{
|
||||
return ready;
|
||||
}
|
||||
|
||||
for (std::uint8_t i = 0; i < core::EqBandIndex::kBandCount; ++i)
|
||||
{
|
||||
if (i == kFixedHighPassBandIndex)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
const auto index = core::EqBandIndex::tryFromIndex(i);
|
||||
if (!index)
|
||||
{
|
||||
return std::unexpected(Adau1701Error::SafeloadFailed);
|
||||
}
|
||||
const core::EqBandSettings &band = eq.band(*index);
|
||||
if (auto result = setEqBand(*index, band.gain, band.center, band.q);
|
||||
!result)
|
||||
{
|
||||
return result;
|
||||
}
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
std::expected<void, Adau1701Error> Adau1701Driver::applyProfile(
|
||||
const core::AudioProfile &profile)
|
||||
{
|
||||
if (auto ready = ensureBooted(); !ready)
|
||||
{
|
||||
return ready;
|
||||
}
|
||||
if (auto result = applyMixer(profile.mixer); !result)
|
||||
{
|
||||
return result;
|
||||
}
|
||||
if (auto result = applyEq(profile.eq); !result)
|
||||
{
|
||||
return result;
|
||||
}
|
||||
return setMasterVolume(profile.masterLeft, profile.masterRight);
|
||||
}
|
||||
return setMasterVolume(profile.masterLeft, profile.masterRight);
|
||||
}
|
||||
|
||||
} // namespace adau1701
|
||||
|
||||
@@ -89,4 +89,12 @@ std::expected<void, core::DspError> Adau1701Dsp::setEqBand(
|
||||
return {};
|
||||
}
|
||||
|
||||
std::expected<void, core::DspError> Adau1701Dsp::setBeepEnabled(bool enabled)
|
||||
{
|
||||
if (auto result = driver_.setBeepEnabled(enabled); !result) {
|
||||
return std::unexpected(mapError(result.error()));
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
} // namespace adau1701
|
||||
|
||||
@@ -18,7 +18,7 @@
|
||||
#include "esp_log.h"
|
||||
#include "esp_partition.h"
|
||||
|
||||
#include <vector>
|
||||
#include <cstdlib>
|
||||
#include <memory>
|
||||
|
||||
namespace adau1701 {
|
||||
@@ -75,26 +75,60 @@ FlashDspProgramSource::loadProgram()
|
||||
return std::unexpected(core::DspProgramError::Empty);
|
||||
}
|
||||
|
||||
// Partizione non vuota: alloca il backing store con new(nothrow), cosi'
|
||||
// un OOM ritorna nullptr invece di abortire (nessuna eccezione).
|
||||
auto* raw = new (std::nothrow) std::uint8_t[part->size];
|
||||
// Determine exact blob size by scanning DRAD write records before
|
||||
// allocating — the full partition (256 KB) exceeds the available heap
|
||||
// on ESP32-S3, and new(nothrow) still invokes __cxa_allocate_exception
|
||||
// when exceptions are disabled, causing abort().
|
||||
|
||||
// Read DRAD header (12 bytes) to get write_count.
|
||||
constexpr std::size_t kHdrSize = 12U;
|
||||
std::uint8_t hdr[kHdrSize] = {};
|
||||
if (esp_partition_read(part, 0, hdr, kHdrSize) != ESP_OK) {
|
||||
return std::unexpected(core::DspProgramError::FlashReadFailed);
|
||||
}
|
||||
// Quick magic/version check (full validation done by parseDspProgramBlob).
|
||||
if (hdr[0] != 'D' || hdr[1] != 'R' || hdr[2] != 'A' || hdr[3] != 'D'
|
||||
|| static_cast<std::uint16_t>(hdr[4] | (hdr[5] << 8)) != 1U) {
|
||||
return std::unexpected(core::DspProgramError::FlashReadFailed);
|
||||
}
|
||||
const auto writeCount =
|
||||
static_cast<std::uint16_t>(hdr[6] | (hdr[7] << 8));
|
||||
if (writeCount == 0U || writeCount > 32U) {
|
||||
return std::unexpected(core::DspProgramError::FlashReadFailed);
|
||||
}
|
||||
|
||||
// Scan write record headers (4 bytes each) to compute total payload size.
|
||||
std::size_t payloadSize = 0U;
|
||||
for (std::uint16_t i = 0U; i < writeCount; ++i) {
|
||||
std::uint8_t rec[4] = {};
|
||||
if (esp_partition_read(part, kHdrSize + payloadSize, rec, 4U)
|
||||
!= ESP_OK) {
|
||||
return std::unexpected(core::DspProgramError::FlashReadFailed);
|
||||
}
|
||||
const auto dataLen =
|
||||
static_cast<std::uint16_t>(rec[2] | (rec[3] << 8));
|
||||
if (dataLen == 0U || dataLen > 16384U) {
|
||||
return std::unexpected(core::DspProgramError::FlashReadFailed);
|
||||
}
|
||||
payloadSize += 4U + dataLen;
|
||||
}
|
||||
|
||||
const std::size_t totalSize = kHdrSize + payloadSize;
|
||||
|
||||
// Use malloc — avoids C++ exception machinery entirely (no nothrow workaround).
|
||||
auto* raw = static_cast<std::uint8_t*>(::malloc(totalSize));
|
||||
if (raw == nullptr) {
|
||||
ESP_LOGE(kTag, "dsp buffer alloc failed (%u byte)",
|
||||
static_cast<unsigned>(part->size));
|
||||
ESP_LOGE(kTag, "dsp buffer alloc failed (%u bytes)",
|
||||
static_cast<unsigned>(totalSize));
|
||||
return std::unexpected(core::DspProgramError::FlashReadFailed);
|
||||
}
|
||||
std::unique_ptr<std::uint8_t[]> guard(raw);
|
||||
std::unique_ptr<std::uint8_t, decltype(&::free)> guard(raw, ::free);
|
||||
|
||||
if (esp_partition_read(part, 0, raw, part->size) != ESP_OK) {
|
||||
if (esp_partition_read(part, 0, raw, totalSize) != ESP_OK) {
|
||||
return std::unexpected(core::DspProgramError::FlashReadFailed);
|
||||
}
|
||||
|
||||
std::span<const std::uint8_t> view(raw, part->size);
|
||||
if (partitionLooksEmpty(view)) {
|
||||
return std::unexpected(core::DspProgramError::Empty);
|
||||
}
|
||||
|
||||
return core::parseDspProgramBlob(view);
|
||||
return core::parseDspProgramBlob({raw, totalSize});
|
||||
}
|
||||
|
||||
std::expected<void, core::DspProgramError>
|
||||
|
||||
@@ -14,10 +14,13 @@
|
||||
#include "SigmaStudioFW.h"
|
||||
|
||||
#include "driver/i2c_master.h"
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/semphr.h"
|
||||
|
||||
#include <string.h>
|
||||
|
||||
static i2c_master_dev_handle_t s_dev = NULL;
|
||||
static SemaphoreHandle_t s_lock = NULL;
|
||||
|
||||
void sigma_studio_bind_i2c(int port, unsigned char addr7)
|
||||
{
|
||||
@@ -28,6 +31,45 @@ void sigma_studio_bind_i2c(int port, unsigned char addr7)
|
||||
void sigma_studio_set_device(void* i2cDevHandle)
|
||||
{
|
||||
s_dev = (i2c_master_dev_handle_t)i2cDevHandle;
|
||||
if (s_lock == NULL) {
|
||||
s_lock = xSemaphoreCreateMutex();
|
||||
}
|
||||
}
|
||||
|
||||
void sigma_studio_lock(void)
|
||||
{
|
||||
if (s_lock != NULL) {
|
||||
xSemaphoreTake(s_lock, portMAX_DELAY);
|
||||
}
|
||||
}
|
||||
|
||||
void sigma_studio_unlock(void)
|
||||
{
|
||||
if (s_lock != NULL) {
|
||||
xSemaphoreGive(s_lock);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* The ADAU1701 memory map is word-indexed with a region-dependent word
|
||||
* width (Param RAM = 4 bytes, Program RAM = 5 bytes, Control regs =
|
||||
* 2 bytes) — confirmed by DigiRadio's own generated export
|
||||
* (DigiRadio_IC_1.h: PROGRAM_ADDR_IC_1=1024/PROGRAM_SIZE_IC_1=5120,
|
||||
* PARAM_ADDR_IC_1=0/PARAM_SIZE_IC_1=4096; DigiRadio_IC_1_REG.h:
|
||||
* REG_COREREGISTER_IC_1_ADDR=0x81C) and independently by the
|
||||
* ADAU1701-TCPi-ESP32 reference project's directWrite(). Chunk
|
||||
* boundaries must land on whole words, or the address advance for the
|
||||
* next I2C transaction (and the data itself, mid-word) is wrong.
|
||||
*/
|
||||
static unsigned int sigmaWordSize(unsigned int address)
|
||||
{
|
||||
if (address >= 0x0400U && address <= 0x07FFU) {
|
||||
return 5U;
|
||||
}
|
||||
if (address >= 0x0800U) {
|
||||
return 2U;
|
||||
}
|
||||
return 4U;
|
||||
}
|
||||
|
||||
void SIGMA_WRITE_REGISTER_BLOCK(unsigned char devAddress,
|
||||
@@ -40,25 +82,45 @@ void SIGMA_WRITE_REGISTER_BLOCK(unsigned char devAddress,
|
||||
return;
|
||||
}
|
||||
|
||||
enum { kChunk = 64U };
|
||||
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;
|
||||
ADI_REG_TYPE* cursor = pData;
|
||||
|
||||
while (remaining > 0U) {
|
||||
const unsigned int chunk =
|
||||
remaining > kChunk ? kChunk : remaining;
|
||||
unsigned char buf[2U + 64U];
|
||||
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);
|
||||
addr += chunk;
|
||||
addr += words;
|
||||
cursor += chunk;
|
||||
remaining -= chunk;
|
||||
}
|
||||
}
|
||||
|
||||
int sigma_i2c_read(unsigned int reg, unsigned char* data, unsigned int length)
|
||||
{
|
||||
if (s_dev == NULL || data == NULL || length == 0U) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
unsigned char addrBuf[2U];
|
||||
addrBuf[0] = (unsigned char)((reg >> 8) & 0xFFU);
|
||||
addrBuf[1] = (unsigned char)(reg & 0xFFU);
|
||||
|
||||
const esp_err_t err = i2c_master_transmit_receive(
|
||||
s_dev, addrBuf, sizeof(addrBuf), data, (size_t)length, 1000);
|
||||
return err == ESP_OK ? 0 : -1;
|
||||
}
|
||||
|
||||
static int sigma_i2c_write(unsigned int reg, const unsigned char* data,
|
||||
unsigned char length)
|
||||
{
|
||||
@@ -66,7 +128,7 @@ static int sigma_i2c_write(unsigned int reg, const unsigned char* data,
|
||||
return -1;
|
||||
}
|
||||
|
||||
unsigned char buf[2U + 4U];
|
||||
unsigned char buf[2U + 5U];
|
||||
if ((size_t)length + 2U > sizeof(buf)) {
|
||||
return -1;
|
||||
}
|
||||
@@ -78,14 +140,25 @@ static int sigma_i2c_write(unsigned int reg, const unsigned char* data,
|
||||
return err == ESP_OK ? 0 : -1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Safeload Data registers are 5 bytes wide (fixed 0x00 qualifier byte +
|
||||
* full sign-extended 32-bit value, MSB first) — confirmed against the
|
||||
* ADAU1701-TCPi-ESP32 reference project's safeloadChunk(), which sends
|
||||
* the identical 5-byte layout. `fixpoint` is a full-range Q8.23
|
||||
* two's-complement value (core::floatToFixpoint823): the previous
|
||||
* 4-byte payload here dropped the top (sign) byte entirely, silently
|
||||
* corrupting every negative coefficient (e.g. biquad a1/b1, routinely
|
||||
* negative for peaking/shelving EQ bands).
|
||||
*/
|
||||
static int sigma_write_fixpoint_reg(unsigned int reg, int fixpoint)
|
||||
{
|
||||
unsigned char payload[4U];
|
||||
unsigned char payload[5U];
|
||||
payload[0] = 0U;
|
||||
payload[1] = (unsigned char)((fixpoint >> 16) & 0xFFU);
|
||||
payload[2] = (unsigned char)((fixpoint >> 8) & 0xFFU);
|
||||
payload[3] = (unsigned char)(fixpoint & 0xFFU);
|
||||
return sigma_i2c_write(reg, payload, 4U);
|
||||
payload[1] = (unsigned char)(((unsigned int)fixpoint >> 24) & 0xFFU);
|
||||
payload[2] = (unsigned char)(((unsigned int)fixpoint >> 16) & 0xFFU);
|
||||
payload[3] = (unsigned char)(((unsigned int)fixpoint >> 8) & 0xFFU);
|
||||
payload[4] = (unsigned char)((unsigned int)fixpoint & 0xFFU);
|
||||
return sigma_i2c_write(reg, payload, 5U);
|
||||
}
|
||||
|
||||
static int sigma_write_param_addr(unsigned int reg, unsigned int paramAddr)
|
||||
@@ -133,3 +206,30 @@ int sigma_safeload_block(unsigned char count, const unsigned int* paramAddrs,
|
||||
|
||||
return sigma_trigger_safeload();
|
||||
}
|
||||
|
||||
int sigma_safeload_raw_block(unsigned char count, const unsigned int* paramAddrs,
|
||||
const unsigned char* rawWords)
|
||||
{
|
||||
if (count == 0U || count > 5U || paramAddrs == NULL || rawWords == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
for (unsigned char i = 0U; i < count; ++i) {
|
||||
const unsigned int dataReg =
|
||||
ADAU1701_SAFELOAD_DATA_BASE + (unsigned int)i;
|
||||
const unsigned int addrReg =
|
||||
ADAU1701_SAFELOAD_ADDR_BASE + (unsigned int)i;
|
||||
|
||||
unsigned char payload[5U];
|
||||
payload[0] = 0U;
|
||||
memcpy(payload + 1U, rawWords + ((unsigned int)i * 4U), 4U);
|
||||
if (sigma_i2c_write(dataReg, payload, 5U) != 0) {
|
||||
return -1;
|
||||
}
|
||||
if (sigma_write_param_addr(addrReg, paramAddrs[i]) != 0) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
return sigma_trigger_safeload();
|
||||
}
|
||||
|
||||
@@ -16,6 +16,7 @@
|
||||
|
||||
#include "core/Bt1035At.hpp"
|
||||
|
||||
#include <cstdint>
|
||||
#include <expected>
|
||||
#include <string>
|
||||
#include <string_view>
|
||||
@@ -36,8 +37,6 @@ namespace bt1035 {
|
||||
struct Bt1035Pins {
|
||||
int uartTx; ///< ESP32 TX -> module RX.
|
||||
int uartRx; ///< ESP32 RX <- module TX.
|
||||
int rtsGpio; ///< RTS (flow control).
|
||||
int ctsGpio; ///< CTS (flow control).
|
||||
int resetGpio; ///< Module RESET (active level per schematic).
|
||||
int sysCtlGpio; ///< SYS_CTL (optional module enable).
|
||||
};
|
||||
@@ -48,7 +47,7 @@ struct Bt1035Pins {
|
||||
* @dname Bt1035Driver
|
||||
* @return n/a (type)
|
||||
* @pubstate Owns UART port after boot(). booted_ true after init sequence
|
||||
* including AT+AUXCFG=3 and AT+I2SCFG=67 (I2S slave from ADAU1701).
|
||||
* including AT+AUXCFG=3 and AT+I2SCFG=35 (I2S slave from ADAU1701).
|
||||
*
|
||||
* @author Michele Bigi
|
||||
* @date 2026-07-06
|
||||
@@ -159,6 +158,22 @@ public:
|
||||
[[nodiscard]] std::expected<core::Bt1035A2dpState, Bt1035Error>
|
||||
queryA2dpState();
|
||||
|
||||
/**
|
||||
* @brief queryA2dpEncoder — read negotiated A2DP codec (AT+A2DPENC).
|
||||
*
|
||||
* @dname queryA2dpEncoder
|
||||
* @return Parsed codec on success, or Bt1035Error. Failing here while
|
||||
* queryA2dpState() reports Streaming means the module has a
|
||||
* link but is not actually encoding audio — a real fault,
|
||||
* not just a quiet source.
|
||||
* @pubstate writes UART; parses +A2DPENC from the reply.
|
||||
*
|
||||
* @author Michele Bigi
|
||||
* @date 2026-08-07
|
||||
*/
|
||||
[[nodiscard]] std::expected<core::Bt1035A2dpCodec, Bt1035Error>
|
||||
queryA2dpEncoder();
|
||||
|
||||
/**
|
||||
* @brief disconnectA2dp — release the active A2DP session (AT+A2DPDISC).
|
||||
*
|
||||
@@ -236,15 +251,115 @@ public:
|
||||
[[nodiscard]] std::expected<std::vector<core::Bt1035PairedDevice>, Bt1035Error>
|
||||
queryPairedList();
|
||||
|
||||
/**
|
||||
* @brief scanNearbyBrEdr — inquiry for nearby A2DP sink devices.
|
||||
*
|
||||
* @dname scanNearbyBrEdr
|
||||
* @param scanSeconds BR/EDR scan duration 1–255 (default 20 in service).
|
||||
* @return Parsed +SCAN entries, or Bt1035Error.
|
||||
* @pubstate sends AT+SCAN=1,n and collects until +SCAN=E.
|
||||
*
|
||||
* @author Michele Bigi
|
||||
* @date 2026-08-05
|
||||
*/
|
||||
[[nodiscard]] std::expected<std::vector<core::Bt1035ScannedDevice>, Bt1035Error>
|
||||
scanNearbyBrEdr(std::uint8_t scanSeconds = 20U);
|
||||
|
||||
/**
|
||||
* @brief stopScan — abort an active AT+SCAN inquiry.
|
||||
*
|
||||
* @dname stopScan
|
||||
* @return Ok on success, or Bt1035Error.
|
||||
* @pubstate sends AT+SCAN=0.
|
||||
*
|
||||
* @author Michele Bigi
|
||||
* @date 2026-08-05
|
||||
*/
|
||||
[[nodiscard]] std::expected<void, Bt1035Error> stopScan();
|
||||
|
||||
/**
|
||||
* @brief prepareForOutgoingConnect — disable auto-link before A2DPCONN.
|
||||
*
|
||||
* @dname prepareForOutgoingConnect
|
||||
* @pubstate sends LINKCFG/AUTOCONN off; does not clear PLIST.
|
||||
*
|
||||
* @author Michele Bigi
|
||||
* @date 2026-08-05
|
||||
*/
|
||||
void prepareForOutgoingConnect();
|
||||
|
||||
/**
|
||||
* @brief waitForA2dpConnected — poll until A2DP link is up.
|
||||
*
|
||||
* @dname waitForA2dpConnected
|
||||
* @param timeoutMs Maximum wait in milliseconds.
|
||||
* @return true when Connected/Streaming/Paused, false on timeout.
|
||||
* @pubstate polls AT+A2DPSTAT.
|
||||
*
|
||||
* @author Michele Bigi
|
||||
* @date 2026-08-05
|
||||
*/
|
||||
[[nodiscard]] bool waitForA2dpConnected(int timeoutMs);
|
||||
|
||||
/**
|
||||
* @brief startA2dpAudio — send AT+A2DPAUDIO=1 (Feasycom §5.3.6).
|
||||
*
|
||||
* @dname startA2dpAudio
|
||||
* @return Ok on module OK, or Bt1035Error.
|
||||
* @pubstate writes UART.
|
||||
*
|
||||
* @author Michele Bigi
|
||||
* @date 2026-08-05
|
||||
*/
|
||||
[[nodiscard]] std::expected<void, Bt1035Error> startA2dpAudio();
|
||||
|
||||
/**
|
||||
* @brief waitForA2dpStreaming — poll until +A2DPSTAT=4 (Streaming).
|
||||
*
|
||||
* @dname waitForA2dpStreaming
|
||||
* @param timeoutMs Maximum wait in milliseconds.
|
||||
* @return true when Streaming, false on timeout.
|
||||
* @pubstate polls AT+A2DPSTAT; sends A2DPAUDIO=1 when stuck at Connected.
|
||||
*
|
||||
* @author Michele Bigi
|
||||
* @date 2026-08-05
|
||||
*/
|
||||
[[nodiscard]] bool waitForA2dpStreaming(int timeoutMs);
|
||||
|
||||
/**
|
||||
* @brief connectA2dp — pair/connect to a remote by MAC (AT+A2DPCONN).
|
||||
*
|
||||
* @dname connectA2dp
|
||||
* @param mac 12-char ASCII MAC from scan results.
|
||||
* @return Ok on success, or Bt1035Error.
|
||||
* @pubstate may take several seconds while the module pairs.
|
||||
*
|
||||
* @author Michele Bigi
|
||||
* @date 2026-08-05
|
||||
*/
|
||||
[[nodiscard]] std::expected<void, Bt1035Error> connectA2dp(
|
||||
std::string_view mac);
|
||||
|
||||
private:
|
||||
[[nodiscard]] std::expected<void, Bt1035Error> ensureBooted() const;
|
||||
[[nodiscard]] std::expected<void, Bt1035Error> runInitSequence();
|
||||
[[nodiscard]] std::expected<std::string, Bt1035Error> transmitAndCollect(
|
||||
std::string_view commandLine, int timeoutMs = kResponseTimeoutMs);
|
||||
[[nodiscard]] std::expected<std::string, Bt1035Error> transmitAndCollectUntil(
|
||||
std::string_view commandLine, std::string_view endMarker, int timeoutMs,
|
||||
std::uint8_t minScanSeconds = 0U);
|
||||
[[nodiscard]] std::expected<void, Bt1035Error> transmitAndExpectOk(
|
||||
std::string_view commandLine);
|
||||
[[nodiscard]] std::expected<void, Bt1035Error> transmitAndExpectOkLogged(
|
||||
std::string_view label, std::string_view commandLine);
|
||||
|
||||
void prepareForInquiryScan();
|
||||
[[nodiscard]] bool waitForA2dpIdle(int timeoutMs);
|
||||
[[nodiscard]] std::expected<std::vector<core::Bt1035ScannedDevice>, Bt1035Error>
|
||||
runInquiryScan(std::uint8_t scanType, std::uint8_t scanSeconds);
|
||||
|
||||
static constexpr int kResponseTimeoutMs = 2000;
|
||||
static constexpr int kConnectTimeoutMs = 15000;
|
||||
|
||||
Bt1035Pins pins_;
|
||||
bool booted_;
|
||||
|
||||
@@ -13,6 +13,7 @@
|
||||
|
||||
#include "bt1035/Bt1035Driver.hpp"
|
||||
|
||||
#include "core/Bt1035ScannedDevice.hpp"
|
||||
#include "driver/gpio.h"
|
||||
#include "driver/uart.h"
|
||||
#include "esp_log.h"
|
||||
@@ -20,6 +21,8 @@
|
||||
#include "freertos/task.h"
|
||||
|
||||
#include <array>
|
||||
#include <algorithm>
|
||||
#include <cstdlib>
|
||||
#include <string>
|
||||
#include <string_view>
|
||||
#include <vector>
|
||||
@@ -30,11 +33,218 @@ namespace {
|
||||
constexpr char kTag[] = "Bt1035";
|
||||
constexpr int kUartPort = 2;
|
||||
constexpr int kBaudRate = 115200;
|
||||
constexpr int kUartRxBuffer = 512;
|
||||
constexpr int kUartRxBuffer = 4096;
|
||||
constexpr int kUartTxBuffer = 256;
|
||||
constexpr int kResponseTimeoutMs = 2000;
|
||||
constexpr int kPostResetMs = 500;
|
||||
constexpr int kPostUartMs = 100;
|
||||
|
||||
void flushUartRx(int uartPort) noexcept
|
||||
{
|
||||
uart_flush_input(static_cast<uart_port_t>(uartPort));
|
||||
std::array<char, 256> discard{};
|
||||
while (uart_read_bytes(static_cast<uart_port_t>(uartPort), discard.data(),
|
||||
discard.size(), 0)
|
||||
> 0) {
|
||||
}
|
||||
}
|
||||
|
||||
constexpr int kBrEdrScanTimeoutMs = 90000;
|
||||
constexpr int kScanProgressLogMs = 5000;
|
||||
constexpr int kScanIdleCompleteMs = 4000;
|
||||
constexpr int kDefaultScanListenSeconds = 25;
|
||||
constexpr unsigned long kDevStatScanComplete = 1U;
|
||||
|
||||
void logAtLine(std::string_view label, std::string_view line) noexcept
|
||||
{
|
||||
std::string sanitized;
|
||||
sanitized.reserve(line.size());
|
||||
for (const char ch : line) {
|
||||
if (ch == '\r') {
|
||||
sanitized.append("\\r");
|
||||
} else if (ch == '\n') {
|
||||
sanitized.append("\\n");
|
||||
} else if (ch >= 0x20 && ch < 0x7F) {
|
||||
sanitized.push_back(ch);
|
||||
} else {
|
||||
sanitized.push_back('.');
|
||||
}
|
||||
}
|
||||
ESP_LOGI(kTag, "%.*s: %s", static_cast<int>(label.size()), label.data(),
|
||||
sanitized.c_str());
|
||||
}
|
||||
|
||||
[[nodiscard]] bool responseHasScanEnd(std::string_view response) noexcept
|
||||
{
|
||||
return response.find("+SCAN=E") != std::string_view::npos
|
||||
|| response.find("+SCAN= E") != std::string_view::npos
|
||||
|| response.find("+SCAN=END") != std::string_view::npos
|
||||
|| response.find("+SCAN= END") != std::string_view::npos;
|
||||
}
|
||||
|
||||
[[nodiscard]] bool responseHasScanEntries(std::string_view response) noexcept
|
||||
{
|
||||
return response.find("+SCAN=") != std::string_view::npos
|
||||
|| response.find("+SCAN =") != std::string_view::npos;
|
||||
}
|
||||
|
||||
[[nodiscard]] bool responseHasDevStatScanComplete(
|
||||
std::string_view response) noexcept
|
||||
{
|
||||
if (!responseHasScanEntries(response)) {
|
||||
return false;
|
||||
}
|
||||
constexpr std::string_view kPrefix = "+DEVSTAT=";
|
||||
std::size_t pos = 0;
|
||||
unsigned long lastValue = 0U;
|
||||
bool found = false;
|
||||
while ((pos = response.find(kPrefix, pos)) != std::string_view::npos) {
|
||||
const std::size_t start = pos + kPrefix.size();
|
||||
char* end = nullptr;
|
||||
const unsigned long raw =
|
||||
std::strtoul(response.data() + start, &end, 10);
|
||||
if (end != response.data() + start) {
|
||||
lastValue = raw;
|
||||
found = true;
|
||||
}
|
||||
pos = start + 1U;
|
||||
}
|
||||
return found && lastValue == kDevStatScanComplete;
|
||||
}
|
||||
|
||||
[[nodiscard]] std::size_t countScanEntries(std::string_view response) noexcept
|
||||
{
|
||||
std::size_t count = 0U;
|
||||
std::size_t pos = 0;
|
||||
while ((pos = response.find("+SCAN=", pos)) != std::string_view::npos) {
|
||||
const std::size_t valueStart = pos + 6U;
|
||||
if (valueStart < response.size() && response[valueStart] != 'E') {
|
||||
++count;
|
||||
}
|
||||
pos = valueStart + 1U;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
enum class ScanCollectReason {
|
||||
EndMarker,
|
||||
DevStatComplete,
|
||||
IdleAfterScan,
|
||||
TimeoutPartial,
|
||||
};
|
||||
|
||||
[[nodiscard]] bool scanCollectionShouldStop(std::string_view response,
|
||||
std::size_t scanEntryCount,
|
||||
TickType_t lastRxTick,
|
||||
TickType_t now,
|
||||
TickType_t started,
|
||||
std::uint8_t minScanSeconds,
|
||||
ScanCollectReason* reason) noexcept
|
||||
{
|
||||
if (!response.empty() && responseHasScanEnd(response)) {
|
||||
if (reason != nullptr) {
|
||||
*reason = ScanCollectReason::EndMarker;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
const int elapsedMs = static_cast<int>(pdTICKS_TO_MS(now - started));
|
||||
const int minListenMs =
|
||||
minScanSeconds > 0U
|
||||
? static_cast<int>(minScanSeconds) * 1000
|
||||
: kDefaultScanListenSeconds * 1000;
|
||||
const bool minListenElapsed = elapsedMs >= minListenMs;
|
||||
|
||||
if (minListenElapsed && responseHasDevStatScanComplete(response)) {
|
||||
if (reason != nullptr) {
|
||||
*reason = ScanCollectReason::DevStatComplete;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
if (minListenElapsed && scanEntryCount > 0U && lastRxTick > 0U
|
||||
&& (now - lastRxTick) >= pdMS_TO_TICKS(kScanIdleCompleteMs)) {
|
||||
if (reason != nullptr) {
|
||||
*reason = ScanCollectReason::IdleAfterScan;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void logScanRawPayload(std::string_view label, std::string_view response) noexcept
|
||||
{
|
||||
if (response.empty()) {
|
||||
ESP_LOGI(kTag, "%.*s (0 bytes)", static_cast<int>(label.size()),
|
||||
label.data());
|
||||
return;
|
||||
}
|
||||
std::string sanitized;
|
||||
sanitized.reserve(std::min(response.size(), std::size_t{512U}));
|
||||
for (const char ch : response) {
|
||||
if (ch == '\r') {
|
||||
sanitized.append("\\r");
|
||||
} else if (ch == '\n') {
|
||||
sanitized.append("\\n");
|
||||
} else if (ch >= 0x20 && ch < 0x7F) {
|
||||
sanitized.push_back(ch);
|
||||
} else {
|
||||
sanitized.push_back('.');
|
||||
}
|
||||
}
|
||||
constexpr std::size_t kChunk = 480U;
|
||||
if (sanitized.size() <= kChunk) {
|
||||
ESP_LOGI(kTag, "%.*s (%d bytes): %s",
|
||||
static_cast<int>(label.size()), label.data(),
|
||||
static_cast<int>(response.size()), sanitized.c_str());
|
||||
return;
|
||||
}
|
||||
ESP_LOGI(kTag, "%.*s (%d bytes, part 1/%u): %.*s",
|
||||
static_cast<int>(label.size()), label.data(),
|
||||
static_cast<int>(response.size()),
|
||||
static_cast<unsigned>(
|
||||
(sanitized.size() + kChunk - 1U) / kChunk),
|
||||
static_cast<int>(kChunk), sanitized.c_str());
|
||||
for (std::size_t off = kChunk; off < sanitized.size(); off += kChunk) {
|
||||
const std::size_t len = std::min(kChunk, sanitized.size() - off);
|
||||
ESP_LOGI(kTag, "%.*s (cont %u): %.*s",
|
||||
static_cast<int>(label.size()), label.data(),
|
||||
static_cast<unsigned>(off / kChunk + 1U),
|
||||
static_cast<int>(len), sanitized.c_str() + off);
|
||||
}
|
||||
}
|
||||
|
||||
void logScanUartChunk(int received, std::string_view chunk) noexcept
|
||||
{
|
||||
const std::string label = "scan UART RX +" + std::to_string(received);
|
||||
logScanRawPayload(label, chunk);
|
||||
}
|
||||
|
||||
[[nodiscard]] const char* scanCollectReasonLabel(
|
||||
ScanCollectReason reason) noexcept
|
||||
{
|
||||
switch (reason) {
|
||||
case ScanCollectReason::EndMarker:
|
||||
return "+SCAN=E/end marker";
|
||||
case ScanCollectReason::DevStatComplete:
|
||||
return "+DEVSTAT=1";
|
||||
case ScanCollectReason::IdleAfterScan:
|
||||
return "UART idle after +SCAN";
|
||||
case ScanCollectReason::TimeoutPartial:
|
||||
return "timeout";
|
||||
}
|
||||
return "unknown";
|
||||
}
|
||||
|
||||
void logScanParsedDevice(const core::Bt1035ScannedDevice& device) noexcept
|
||||
{
|
||||
ESP_LOGI(kTag,
|
||||
"scan device[%u]: mac=%s name=%s rssi=%d dBm class=%s addrType=%u",
|
||||
static_cast<unsigned>(device.index), device.mac.c_str(),
|
||||
device.name.empty() ? "(no name)" : device.name.c_str(),
|
||||
static_cast<int>(device.rssiDbm),
|
||||
device.deviceClass.empty() ? "-" : device.deviceClass.c_str(),
|
||||
static_cast<unsigned>(device.addressType));
|
||||
}
|
||||
} // namespace
|
||||
|
||||
Bt1035Driver::Bt1035Driver(Bt1035Pins pins)
|
||||
@@ -102,6 +312,284 @@ std::expected<std::string, Bt1035Error> Bt1035Driver::transmitAndCollect(
|
||||
return std::unexpected(Bt1035Error::AtTimeout);
|
||||
}
|
||||
|
||||
std::expected<std::string, Bt1035Error> Bt1035Driver::transmitAndCollectUntil(
|
||||
std::string_view commandLine, std::string_view endMarker, int timeoutMs,
|
||||
std::uint8_t minScanSeconds)
|
||||
{
|
||||
logAtLine("scan UART TX", commandLine);
|
||||
|
||||
const int written = uart_write_bytes(static_cast<uart_port_t>(uartPort_),
|
||||
commandLine.data(),
|
||||
commandLine.size());
|
||||
if (written < 0
|
||||
|| static_cast<std::size_t>(written) != commandLine.size()) {
|
||||
ESP_LOGE(kTag, "scan UART TX failed (%d)", written);
|
||||
return std::unexpected(Bt1035Error::UartInitFailed);
|
||||
}
|
||||
|
||||
std::array<char, 512> buffer{};
|
||||
std::string accumulated;
|
||||
accumulated.reserve(8192U);
|
||||
const TickType_t started = xTaskGetTickCount();
|
||||
const TickType_t deadline = started + pdMS_TO_TICKS(timeoutMs);
|
||||
TickType_t lastProgressLog = started;
|
||||
TickType_t lastRxTick = 0;
|
||||
std::size_t scanEntryCount = 0U;
|
||||
ScanCollectReason stopReason = ScanCollectReason::TimeoutPartial;
|
||||
bool stoppedEarly = false;
|
||||
|
||||
ESP_LOGI(kTag, "======== BT scan inquiry begin (min %u s, timeout %d ms) ========",
|
||||
static_cast<unsigned>(minScanSeconds), timeoutMs);
|
||||
|
||||
while (xTaskGetTickCount() < deadline) {
|
||||
const int received = uart_read_bytes(static_cast<uart_port_t>(uartPort_),
|
||||
buffer.data(), buffer.size(),
|
||||
pdMS_TO_TICKS(200));
|
||||
const TickType_t now = xTaskGetTickCount();
|
||||
if (received > 0) {
|
||||
const std::string_view chunk(buffer.data(),
|
||||
static_cast<std::size_t>(received));
|
||||
logScanUartChunk(received, chunk);
|
||||
accumulated.append(buffer.data(), static_cast<std::size_t>(received));
|
||||
lastRxTick = now;
|
||||
|
||||
const std::size_t updatedScanCount =
|
||||
countScanEntries(accumulated);
|
||||
if (updatedScanCount > scanEntryCount) {
|
||||
ESP_LOGI(kTag, "scan +SCAN entry #%u (total %u)",
|
||||
static_cast<unsigned>(updatedScanCount),
|
||||
static_cast<unsigned>(updatedScanCount));
|
||||
scanEntryCount = updatedScanCount;
|
||||
}
|
||||
|
||||
if (!endMarker.empty()
|
||||
&& accumulated.find(endMarker) != std::string::npos) {
|
||||
stopReason = ScanCollectReason::EndMarker;
|
||||
stoppedEarly = true;
|
||||
ESP_LOGI(kTag, "scan end marker %.*s seen",
|
||||
static_cast<int>(endMarker.size()), endMarker.data());
|
||||
break;
|
||||
}
|
||||
if (scanCollectionShouldStop(accumulated, scanEntryCount, lastRxTick,
|
||||
now, started, minScanSeconds,
|
||||
&stopReason)) {
|
||||
stoppedEarly = true;
|
||||
if (stopReason == ScanCollectReason::EndMarker) {
|
||||
ESP_LOGI(kTag, "scan end marker +SCAN=E seen");
|
||||
} else if (stopReason == ScanCollectReason::DevStatComplete) {
|
||||
ESP_LOGI(kTag,
|
||||
"scan complete: +DEVSTAT=1 after %u +SCAN entr(ies)",
|
||||
static_cast<unsigned>(scanEntryCount));
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (core::parseBt1035AtResponse(accumulated)
|
||||
== core::Bt1035AtResponseKind::Error) {
|
||||
logScanRawPayload("scan ERROR response", accumulated);
|
||||
return std::unexpected(Bt1035Error::AtError);
|
||||
}
|
||||
} else if (scanEntryCount > 0U
|
||||
&& scanCollectionShouldStop(accumulated, scanEntryCount,
|
||||
lastRxTick, now, started,
|
||||
minScanSeconds, &stopReason)) {
|
||||
stoppedEarly = true;
|
||||
if (stopReason == ScanCollectReason::IdleAfterScan) {
|
||||
ESP_LOGI(kTag,
|
||||
"scan complete: idle %d ms after last +SCAN (%u entr(ies))",
|
||||
kScanIdleCompleteMs,
|
||||
static_cast<unsigned>(scanEntryCount));
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
if ((now - lastProgressLog) >= pdMS_TO_TICKS(kScanProgressLogMs)) {
|
||||
lastProgressLog = now;
|
||||
const int elapsedMs =
|
||||
static_cast<int>(pdTICKS_TO_MS(now - started));
|
||||
const int minListenMs =
|
||||
minScanSeconds > 0U
|
||||
? static_cast<int>(minScanSeconds) * 1000
|
||||
: kDefaultScanListenSeconds * 1000;
|
||||
ESP_LOGI(kTag,
|
||||
"scan progress: %d ms, %d bytes rx, %u +SCAN, min listen %d ms",
|
||||
elapsedMs, static_cast<int>(accumulated.size()),
|
||||
static_cast<unsigned>(scanEntryCount), minListenMs);
|
||||
}
|
||||
}
|
||||
|
||||
const int elapsedMs =
|
||||
static_cast<int>(pdTICKS_TO_MS(xTaskGetTickCount() - started));
|
||||
if (stoppedEarly) {
|
||||
ESP_LOGI(kTag, "scan stopped: reason=%s, elapsed=%d ms, %u +SCAN entr(ies)",
|
||||
scanCollectReasonLabel(stopReason), elapsedMs,
|
||||
static_cast<unsigned>(scanEntryCount));
|
||||
} else {
|
||||
stopReason = ScanCollectReason::TimeoutPartial;
|
||||
ESP_LOGW(kTag, "scan stopped: reason=%s, elapsed=%d ms, %u +SCAN entr(ies)",
|
||||
scanCollectReasonLabel(stopReason), elapsedMs,
|
||||
static_cast<unsigned>(scanEntryCount));
|
||||
}
|
||||
logScanRawPayload("scan UART full RX", accumulated);
|
||||
|
||||
const bool hasEnd = stoppedEarly
|
||||
|| (!endMarker.empty()
|
||||
? accumulated.find(endMarker)
|
||||
!= std::string::npos
|
||||
: responseHasScanEnd(accumulated));
|
||||
if (!hasEnd) {
|
||||
if (!responseHasScanEntries(accumulated)) {
|
||||
if (accumulated.find("+A2DPSTAT=2") != std::string_view::npos) {
|
||||
ESP_LOGW(kTag,
|
||||
"scan blocked: module auto-connecting A2DP (disable LINKCFG)");
|
||||
}
|
||||
if (accumulated.find("+DEVSTAT=") != std::string_view::npos) {
|
||||
ESP_LOGW(kTag, "scan saw DEVSTAT events but no +SCAN= lines");
|
||||
}
|
||||
ESP_LOGW(kTag, "scan timeout (%d bytes rx, no +SCAN entries)",
|
||||
static_cast<int>(accumulated.size()));
|
||||
(void)transmitAndCollect(core::buildBt1035StopScanLine(), 1000);
|
||||
return std::unexpected(Bt1035Error::AtTimeout);
|
||||
}
|
||||
ESP_LOGW(kTag, "scan timeout but %d bytes contain +SCAN entries — parsing partial",
|
||||
static_cast<int>(accumulated.size()));
|
||||
}
|
||||
|
||||
ESP_LOGI(kTag, "======== BT scan inquiry end ========");
|
||||
return accumulated;
|
||||
}
|
||||
|
||||
std::expected<void, Bt1035Error> Bt1035Driver::transmitAndExpectOkLogged(
|
||||
std::string_view label, std::string_view commandLine)
|
||||
{
|
||||
logAtLine(label, commandLine);
|
||||
auto collected = transmitAndCollect(commandLine);
|
||||
if (collected) {
|
||||
if (!collected->empty()) {
|
||||
const std::string rxLabel = std::string(label) + " RX";
|
||||
logScanRawPayload(rxLabel, *collected);
|
||||
}
|
||||
ESP_LOGI(kTag, "%.*s: OK", static_cast<int>(label.size()), label.data());
|
||||
return {};
|
||||
}
|
||||
if (collected.error() == Bt1035Error::AtTimeout) {
|
||||
ESP_LOGW(kTag, "%.*s: timeout (no response)", static_cast<int>(label.size()),
|
||||
label.data());
|
||||
} else {
|
||||
ESP_LOGW(kTag, "%.*s: failed (%d)", static_cast<int>(label.size()),
|
||||
label.data(), static_cast<int>(collected.error()));
|
||||
}
|
||||
return std::unexpected(collected.error());
|
||||
}
|
||||
|
||||
void Bt1035Driver::prepareForInquiryScan()
|
||||
{
|
||||
ESP_LOGI(kTag, "======== BT scan prep begin ========");
|
||||
flushUartRx(uartPort_);
|
||||
(void)transmitAndExpectOkLogged("scan prep PRINT",
|
||||
core::buildBt1035EnablePrintLine());
|
||||
(void)transmitAndExpectOkLogged("scan prep LINKCFG off",
|
||||
core::buildBt1035DisableAutoLinkLine());
|
||||
(void)transmitAndExpectOkLogged("scan prep AUTOCONN off",
|
||||
core::buildBt1035SetAutoConnLine(0U));
|
||||
(void)transmitAndExpectOkLogged("scan prep PLIST clear",
|
||||
core::buildBt1035ClearPairedListLine());
|
||||
(void)transmitAndExpectOkLogged(
|
||||
"scan prep A2DPDISC",
|
||||
core::buildBt1035AtLine(core::Bt1035AtCommand::A2dpDisconnect));
|
||||
(void)transmitAndExpectOkLogged("scan prep DSCA",
|
||||
core::buildBt1035DisconnectAllLine());
|
||||
(void)transmitAndExpectOkLogged(
|
||||
"scan prep PAIR=0",
|
||||
core::buildBt1035AtLine(core::Bt1035AtCommand::PairHidden));
|
||||
auto stopScan = transmitAndCollect(core::buildBt1035StopScanLine(), 1000);
|
||||
if (stopScan) {
|
||||
logScanRawPayload("scan prep SCAN=0 RX", *stopScan);
|
||||
ESP_LOGI(kTag, "scan prep SCAN=0: OK");
|
||||
} else {
|
||||
ESP_LOGI(kTag, "scan prep SCAN=0: skipped (no active scan)");
|
||||
}
|
||||
flushUartRx(uartPort_);
|
||||
vTaskDelay(pdMS_TO_TICKS(500));
|
||||
if (!waitForA2dpIdle(10000)) {
|
||||
ESP_LOGW(kTag, "scan prep: A2DP still busy — continuing anyway");
|
||||
}
|
||||
if (auto paired = queryPairedList(); paired && !paired->empty()) {
|
||||
ESP_LOGI(kTag, "scan prep: %u paired device(s) on module",
|
||||
static_cast<unsigned>(paired->size()));
|
||||
for (const core::Bt1035PairedDevice& entry : *paired) {
|
||||
ESP_LOGI(kTag, "scan prep paired: %s (%s)",
|
||||
entry.mac.c_str(),
|
||||
entry.name.empty() ? "(no name)" : entry.name.c_str());
|
||||
}
|
||||
}
|
||||
flushUartRx(uartPort_);
|
||||
ESP_LOGI(kTag, "======== BT scan prep end ========");
|
||||
}
|
||||
|
||||
bool Bt1035Driver::waitForA2dpIdle(int timeoutMs)
|
||||
{
|
||||
const TickType_t deadline =
|
||||
xTaskGetTickCount() + pdMS_TO_TICKS(timeoutMs);
|
||||
TickType_t lastDisconnectAttempt = 0;
|
||||
while (xTaskGetTickCount() < deadline) {
|
||||
auto state = queryA2dpState();
|
||||
if (!state) {
|
||||
ESP_LOGW(kTag, "scan prep: A2DPSTAT query failed");
|
||||
return false;
|
||||
}
|
||||
ESP_LOGI(kTag, "scan prep: A2DPSTAT=%u",
|
||||
static_cast<unsigned>(static_cast<std::uint8_t>(*state)));
|
||||
if (*state == core::Bt1035A2dpState::Standby
|
||||
|| *state == core::Bt1035A2dpState::Unsupported) {
|
||||
return true;
|
||||
}
|
||||
const TickType_t now = xTaskGetTickCount();
|
||||
if ((now - lastDisconnectAttempt) >= pdMS_TO_TICKS(1500)) {
|
||||
lastDisconnectAttempt = now;
|
||||
ESP_LOGW(kTag, "scan prep: A2DP busy — sending A2DPDISC+DSCA");
|
||||
(void)transmitAndExpectOk(
|
||||
core::buildBt1035AtLine(core::Bt1035AtCommand::A2dpDisconnect));
|
||||
(void)transmitAndExpectOk(core::buildBt1035DisconnectAllLine());
|
||||
flushUartRx(uartPort_);
|
||||
}
|
||||
vTaskDelay(pdMS_TO_TICKS(400));
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
std::expected<std::vector<core::Bt1035ScannedDevice>, Bt1035Error>
|
||||
Bt1035Driver::runInquiryScan(std::uint8_t scanType, std::uint8_t scanSeconds)
|
||||
{
|
||||
const std::string startLine =
|
||||
core::buildBt1035StartScanLine(scanType, scanSeconds);
|
||||
const int timeoutMs = scanSeconds == 0U
|
||||
? kBrEdrScanTimeoutMs
|
||||
: static_cast<int>(scanSeconds) * 1000 + 30000;
|
||||
flushUartRx(uartPort_);
|
||||
ESP_LOGI(kTag, "scan inquiry: type=%u seconds=%u timeout=%d ms",
|
||||
static_cast<unsigned>(scanType),
|
||||
static_cast<unsigned>(scanSeconds), timeoutMs);
|
||||
auto response = transmitAndCollectUntil(startLine, {}, timeoutMs, scanSeconds);
|
||||
if (!response) {
|
||||
ESP_LOGW(kTag, "scan inquiry failed (type %u)",
|
||||
static_cast<unsigned>(scanType));
|
||||
return std::unexpected(response.error());
|
||||
}
|
||||
|
||||
auto parsed = core::parseBt1035ScanResponse(*response);
|
||||
if (!parsed) {
|
||||
ESP_LOGW(kTag, "scan parse failed (type %u)",
|
||||
static_cast<unsigned>(scanType));
|
||||
return std::unexpected(Bt1035Error::UnexpectedResponse);
|
||||
}
|
||||
ESP_LOGI(kTag, "scan parsed %u device(s)",
|
||||
static_cast<unsigned>(parsed->size()));
|
||||
for (const core::Bt1035ScannedDevice& device : *parsed) {
|
||||
logScanParsedDevice(device);
|
||||
}
|
||||
return *parsed;
|
||||
}
|
||||
|
||||
std::expected<void, Bt1035Error> Bt1035Driver::transmitAndExpectOk(
|
||||
std::string_view commandLine)
|
||||
{
|
||||
@@ -156,6 +644,25 @@ std::expected<core::Bt1035A2dpState, Bt1035Error> Bt1035Driver::queryA2dpState()
|
||||
return *parsed;
|
||||
}
|
||||
|
||||
std::expected<core::Bt1035A2dpCodec, Bt1035Error> Bt1035Driver::queryA2dpEncoder()
|
||||
{
|
||||
if (auto ready = ensureBooted(); !ready) {
|
||||
return std::unexpected(ready.error());
|
||||
}
|
||||
|
||||
auto response = transmitAndCollect(
|
||||
core::buildBt1035AtLine(core::Bt1035AtCommand::A2dpEncoder));
|
||||
if (!response) {
|
||||
return std::unexpected(response.error());
|
||||
}
|
||||
|
||||
auto parsed = core::parseBt1035A2dpEncoderResponse(*response);
|
||||
if (!parsed) {
|
||||
return std::unexpected(Bt1035Error::UnexpectedResponse);
|
||||
}
|
||||
return *parsed;
|
||||
}
|
||||
|
||||
std::expected<void, Bt1035Error> Bt1035Driver::disconnectA2dp()
|
||||
{
|
||||
if (auto ready = ensureBooted(); !ready) {
|
||||
@@ -243,6 +750,133 @@ Bt1035Driver::queryPairedList()
|
||||
return *parsed;
|
||||
}
|
||||
|
||||
std::expected<std::vector<core::Bt1035ScannedDevice>, Bt1035Error>
|
||||
Bt1035Driver::scanNearbyBrEdr(std::uint8_t scanSeconds)
|
||||
{
|
||||
if (auto ready = ensureBooted(); !ready) {
|
||||
return std::unexpected(ready.error());
|
||||
}
|
||||
|
||||
ESP_LOGI(kTag, "======== BT scan session begin (%u s) ========",
|
||||
static_cast<unsigned>(scanSeconds));
|
||||
|
||||
prepareForInquiryScan();
|
||||
|
||||
auto result = runInquiryScan(1U, scanSeconds);
|
||||
|
||||
ESP_LOGI(kTag, "scan post-cleanup: A2DPDISC+DSCA+SCAN=0");
|
||||
(void)transmitAndExpectOkLogged(
|
||||
"scan post A2DPDISC",
|
||||
core::buildBt1035AtLine(core::Bt1035AtCommand::A2dpDisconnect));
|
||||
(void)transmitAndExpectOkLogged("scan post DSCA",
|
||||
core::buildBt1035DisconnectAllLine());
|
||||
(void)transmitAndExpectOkLogged("scan post SCAN=0",
|
||||
core::buildBt1035StopScanLine());
|
||||
|
||||
if (result) {
|
||||
ESP_LOGI(kTag, "======== BT scan session OK: %u device(s) ========",
|
||||
static_cast<unsigned>(result->size()));
|
||||
} else {
|
||||
ESP_LOGW(kTag, "======== BT scan session FAILED ========");
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
std::expected<void, Bt1035Error> Bt1035Driver::stopScan()
|
||||
{
|
||||
if (auto ready = ensureBooted(); !ready) {
|
||||
return ready;
|
||||
}
|
||||
return transmitAndExpectOk(core::buildBt1035StopScanLine());
|
||||
}
|
||||
|
||||
void Bt1035Driver::prepareForOutgoingConnect()
|
||||
{
|
||||
ESP_LOGI(kTag, "connect prep: LINKCFG/AUTOCONN off");
|
||||
(void)transmitAndExpectOk(core::buildBt1035DisableAutoLinkLine());
|
||||
(void)transmitAndExpectOk(core::buildBt1035SetAutoConnLine(0U));
|
||||
flushUartRx(uartPort_);
|
||||
}
|
||||
|
||||
bool Bt1035Driver::waitForA2dpConnected(int timeoutMs)
|
||||
{
|
||||
const TickType_t deadline =
|
||||
xTaskGetTickCount() + pdMS_TO_TICKS(timeoutMs);
|
||||
while (xTaskGetTickCount() < deadline) {
|
||||
auto state = queryA2dpState();
|
||||
if (!state) {
|
||||
return false;
|
||||
}
|
||||
ESP_LOGI(kTag, "connect wait: A2DPSTAT=%u",
|
||||
static_cast<unsigned>(static_cast<std::uint8_t>(*state)));
|
||||
if (*state == core::Bt1035A2dpState::Connected
|
||||
|| *state == core::Bt1035A2dpState::Streaming
|
||||
|| *state == core::Bt1035A2dpState::Paused) {
|
||||
return true;
|
||||
}
|
||||
vTaskDelay(pdMS_TO_TICKS(500));
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
std::expected<void, Bt1035Error> Bt1035Driver::startA2dpAudio()
|
||||
{
|
||||
if (auto ready = ensureBooted(); !ready) {
|
||||
return ready;
|
||||
}
|
||||
ESP_LOGI(kTag, "A2DP audio start (AT+A2DPAUDIO=1)");
|
||||
return transmitAndExpectOk(core::buildBt1035A2dpAudioLine(true));
|
||||
}
|
||||
|
||||
bool Bt1035Driver::waitForA2dpStreaming(int timeoutMs)
|
||||
{
|
||||
const TickType_t deadline =
|
||||
xTaskGetTickCount() + pdMS_TO_TICKS(timeoutMs);
|
||||
TickType_t lastAudioStartAttempt = 0;
|
||||
while (xTaskGetTickCount() < deadline) {
|
||||
auto state = queryA2dpState();
|
||||
if (state) {
|
||||
ESP_LOGI(kTag, "stream wait: A2DPSTAT=%u",
|
||||
static_cast<unsigned>(static_cast<std::uint8_t>(*state)));
|
||||
if (*state == core::Bt1035A2dpState::Streaming) {
|
||||
return true;
|
||||
}
|
||||
const TickType_t now = xTaskGetTickCount();
|
||||
if ((*state == core::Bt1035A2dpState::Connected
|
||||
|| *state == core::Bt1035A2dpState::Paused)
|
||||
&& (lastAudioStartAttempt == 0U
|
||||
|| (now - lastAudioStartAttempt) >= pdMS_TO_TICKS(3000))) {
|
||||
lastAudioStartAttempt = now;
|
||||
if (auto started = startA2dpAudio(); !started) {
|
||||
ESP_LOGW(kTag, "A2DPAUDIO=1 failed (%d)",
|
||||
static_cast<int>(started.error()));
|
||||
}
|
||||
}
|
||||
}
|
||||
vTaskDelay(pdMS_TO_TICKS(500));
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
std::expected<void, Bt1035Error> Bt1035Driver::connectA2dp(std::string_view mac)
|
||||
{
|
||||
if (auto ready = ensureBooted(); !ready) {
|
||||
return ready;
|
||||
}
|
||||
prepareForOutgoingConnect();
|
||||
const std::string line = core::buildBt1035A2dpConnectLine(mac);
|
||||
if (line.empty()) {
|
||||
return std::unexpected(Bt1035Error::UnexpectedResponse);
|
||||
}
|
||||
(void)stopScan();
|
||||
auto response = transmitAndCollect(line, kConnectTimeoutMs);
|
||||
if (!response) {
|
||||
return std::unexpected(response.error());
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
std::expected<void, Bt1035Error> Bt1035Driver::runInitSequence()
|
||||
{
|
||||
for (const core::Bt1035AtCommand command : core::bootInitSequence()) {
|
||||
@@ -314,13 +948,24 @@ std::expected<void, Bt1035Error> Bt1035Driver::boot()
|
||||
uart_flush_input(static_cast<uart_port_t>(uartPort_));
|
||||
vTaskDelay(pdMS_TO_TICKS(kPostUartMs));
|
||||
|
||||
// Best-effort: not gated on OK — some Feasycom firmware acks before
|
||||
// rebooting, some resets silently. Either way, settle and flush before
|
||||
// the mandatory init sequence below, which IS gated.
|
||||
(void)transmitAndExpectOk(core::buildBt1035AtLine(core::Bt1035AtCommand::Reset));
|
||||
vTaskDelay(pdMS_TO_TICKS(kPostResetMs));
|
||||
uart_flush_input(static_cast<uart_port_t>(uartPort_));
|
||||
ESP_LOGI(kTag, "AT+RESET sent");
|
||||
|
||||
if (auto init = runInitSequence(); !init) {
|
||||
ESP_LOGE(kTag, "AT init failed");
|
||||
return init;
|
||||
}
|
||||
|
||||
(void)transmitAndExpectOk(core::buildBt1035DisableAutoLinkLine());
|
||||
ESP_LOGI(kTag, "auto-link disabled (AT+LINKCFG=0,0)");
|
||||
|
||||
booted_ = true;
|
||||
ESP_LOGI(kTag, "I2S slave mode enabled (AT+AUXCFG=3, AT+I2SCFG=67)");
|
||||
ESP_LOGI(kTag, "I2S slave mode enabled (AT+AUXCFG=3, AT+I2SCFG=35)");
|
||||
return {};
|
||||
}
|
||||
|
||||
|
||||
@@ -106,14 +106,21 @@ public:
|
||||
* rail ramp before app_main runs.
|
||||
*
|
||||
* @dname boot
|
||||
* @param band DAB or FM application to load.
|
||||
* @param band DAB or FM application to load.
|
||||
* @param xtalIbias POWER_UP ARG3 IBIAS, 10 uA steps (AN649 §Command
|
||||
* 0x01); default matches the values already
|
||||
* verified live (72 = 720 uA startup bias).
|
||||
* @param xtalCtun POWER_UP ARG8 CTUN, 0-63 (AN649 §Command 0x01);
|
||||
* default matches the values already verified live.
|
||||
* @return Ok on success, or Si4684Error.
|
||||
* @pubstate writes booted_ and loadedBand_ on success.
|
||||
*
|
||||
* @author Michele Bigi
|
||||
* @date 2026-07-06
|
||||
*/
|
||||
[[nodiscard]] std::expected<void, Si4684Error> boot(Si4684Band band);
|
||||
[[nodiscard]] std::expected<void, Si4684Error> boot(
|
||||
Si4684Band band, std::uint8_t xtalIbias = 72U,
|
||||
std::uint8_t xtalCtun = 31U);
|
||||
|
||||
/**
|
||||
* @brief isBooted — query whether boot completed successfully.
|
||||
@@ -387,7 +394,10 @@ private:
|
||||
[[nodiscard]] std::expected<void, Si4684Error> ensureBand(
|
||||
Si4684Band band) const;
|
||||
[[nodiscard]] std::expected<void, Si4684Error> waitCts();
|
||||
[[nodiscard]] std::expected<void, Si4684Error> waitStc();
|
||||
[[nodiscard]] std::expected<void, Si4684Error> waitStc(
|
||||
int maxRetries = 250);
|
||||
[[nodiscard]] std::expected<bool, Si4684Error> pollStc();
|
||||
[[nodiscard]] std::expected<void, Si4684Error> clearFmStc();
|
||||
[[nodiscard]] std::expected<void, Si4684Error> sendCommand(
|
||||
std::span<const std::uint8_t> bytes);
|
||||
[[nodiscard]] std::expected<void, Si4684Error> readRaw(
|
||||
|
||||
@@ -190,10 +190,25 @@ private:
|
||||
*/
|
||||
[[nodiscard]] static core::TunerError mapError(Si4684Error error) noexcept;
|
||||
|
||||
/**
|
||||
* @brief ensureBandLoaded — HOST_LOAD FM/DAB image when band differs.
|
||||
*
|
||||
* @dname ensureBandLoaded
|
||||
* @param band Required application band for the next operation.
|
||||
* @return Ok when the chip runs the requested image.
|
||||
* @pubstate may reload firmware (~1 s) and stop an active DAB service.
|
||||
*
|
||||
* @author Michele Bigi
|
||||
* @date 2026-08-05
|
||||
*/
|
||||
[[nodiscard]] std::expected<void, core::TunerError> ensureBandLoaded(
|
||||
core::TunerBand band);
|
||||
|
||||
Si4684Driver& driver_;
|
||||
std::uint8_t dabIndex_;
|
||||
core::FrequencyKHz fmFrequency_;
|
||||
std::uint8_t volume_;
|
||||
bool fmBandReady_;
|
||||
core::RdsMetadataAccumulator rdsMetadata_;
|
||||
core::DabDynamicLabelAccumulator dabDynamicLabel_;
|
||||
std::optional<std::uint32_t> lastDabServiceId_;
|
||||
|
||||
@@ -18,6 +18,7 @@
|
||||
#include <array>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <optional>
|
||||
#include <vector>
|
||||
|
||||
namespace si4684 {
|
||||
@@ -91,11 +92,11 @@ struct Si4684SysState {
|
||||
* @date 2026-07-06
|
||||
*/
|
||||
struct Si4684FmRsq {
|
||||
core::FrequencyKHz frequency; ///< Tuned centre frequency in kHz.
|
||||
std::int8_t rssiDbuV; ///< RSSI in dBµV.
|
||||
std::int8_t snrDb; ///< SNR in dB.
|
||||
bool valid; ///< RSQ valid flag from the chip.
|
||||
bool stereo; ///< Stereo pilot detected.
|
||||
std::optional<core::FrequencyKHz> frequency; ///< READFREQ when in FM band.
|
||||
std::int8_t rssiDbuV; ///< RSSI in dBµV.
|
||||
std::int8_t snrDb; ///< SNR in dB.
|
||||
bool valid; ///< RSQ valid flag from the chip.
|
||||
bool stereo; ///< Stereo pilot detected.
|
||||
};
|
||||
|
||||
/**
|
||||
|
||||
@@ -35,15 +35,58 @@ constexpr int kCtsPollMs = 2;
|
||||
constexpr int kCtsRetries = 5000;
|
||||
constexpr int kStcRetries = 250;
|
||||
constexpr int kStcPollMs = 20;
|
||||
/** SPI readRaw: byte 0 is a lead-in; STATUS0 is at index 1 (AN649). */
|
||||
constexpr std::size_t kSpiReplyLeadIn = 1U;
|
||||
/** FM_RSQ_STATUS field indices with kSpiReplyLeadIn (AN649 RESP5–10). */
|
||||
constexpr std::size_t kFmRsqOffValid = 6U;
|
||||
constexpr std::size_t kFmRsqOffReadFreq = 7U;
|
||||
constexpr std::size_t kFmRsqOffRssi = 10U;
|
||||
constexpr std::size_t kFmRsqOffSnr = 11U;
|
||||
|
||||
constexpr std::uint16_t kPropDigitalIoOutputSelect = 0x0200U;
|
||||
constexpr std::uint16_t kPropDigitalIoOutputFormat = 0x0202U;
|
||||
constexpr std::uint16_t kPropDigitalIoSampleRate = 0x0201U;
|
||||
/** I2S slave — ADAU1701 is bus master (AN649 property 0x0200, bit15=0). */
|
||||
constexpr std::uint16_t kSi4684I2sSlaveSelect = 0x0000U;
|
||||
/** 24-bit samples in 32-bit I2S slots (SAMPL=0x18, SLOT=0x7, I2S mode). */
|
||||
constexpr std::uint16_t kSi4684I2sOutputFormat = 0x1870U;
|
||||
/** 48000 Hz — matches ADAU1701 48 kHz master clock domain. */
|
||||
constexpr std::uint16_t kSi4684I2sSampleRateHz = 0xBB80U;
|
||||
constexpr std::uint16_t kPropPinConfigEnable = 0x0800U;
|
||||
constexpr std::uint16_t kPropAudioVolume = 0x0300U;
|
||||
constexpr std::uint16_t kPropAudioMute = 0x0301U;
|
||||
constexpr std::uint16_t kPropAudioOutputConfig = 0x0302U;
|
||||
/** AN649 AUDIO_OUTPUT_CONFIG bit1 I2SOUTEN — required for I2S to ADAU1701. */
|
||||
constexpr std::uint16_t kSi4684I2sOutEnable = 0x0002U;
|
||||
/** Si4684 volume: 0=mute, 63=max (AN649 AUDIO_ANALOG_VOLUME). */
|
||||
constexpr std::uint8_t kSi4684VolumeMax = 63U;
|
||||
constexpr std::uint16_t kPropFmRdsConfig = 0x3C02U;
|
||||
/** AN649 FM valid tune properties (defaults RSSI 17 dBµV, SNR 10 dB). */
|
||||
constexpr std::uint16_t kPropFmValidRssiThreshold = 0x3202U;
|
||||
constexpr std::uint16_t kPropFmValidSnrThreshold = 0x3204U;
|
||||
constexpr std::uint16_t kFmValidRssiThresholdDbuV = 0x0005U;
|
||||
constexpr std::uint16_t kFmValidSnrThresholdDb = 0x0003U;
|
||||
/** AN649 FM seek band/spacing (10 kHz units): 87.5–107.9 MHz, 100 kHz steps. */
|
||||
constexpr std::uint16_t kPropFmSeekBandBottom = 0x3100U;
|
||||
constexpr std::uint16_t kPropFmSeekBandTop = 0x3101U;
|
||||
constexpr std::uint16_t kPropFmSeekSpacing = 0x3102U;
|
||||
constexpr std::uint16_t kFmSeekBandBottomChip = 8750U;
|
||||
constexpr std::uint16_t kFmSeekBandTopChip = 10790U;
|
||||
constexpr std::uint16_t kFmSeekSpacingChip = 10U;
|
||||
/** AN851 §"Varactor Tuning Properties" recommended-network table: FM slope/
|
||||
* intercept for 0x1710/0x1711 (Table, "FM" row: 0xEDB5 / 0x01E3). */
|
||||
constexpr std::uint16_t kFmTuneFeVarm = 0xEDB5U;
|
||||
constexpr std::uint16_t kFmTuneFeVarb = 0x01E3U;
|
||||
constexpr std::uint16_t kFmTuneFeCfgEnable = 0x0001U;
|
||||
constexpr std::uint16_t kPropDabTuneFeCfg = 0x1712U;
|
||||
constexpr std::uint16_t kPropFmTuneFeCfg = 0x1712U;
|
||||
constexpr std::uint16_t kPropDabXpadEnable = 0xB400U;
|
||||
constexpr std::uint16_t kPropDigitalServiceIntSource = 0x8100U;
|
||||
/** AN649 INT_CTL_ENABLE / INT_CTL_REPEAT — route STC to INTB until STCACK. */
|
||||
constexpr std::uint16_t kPropIntCtlEnable = 0x0000U;
|
||||
constexpr std::uint16_t kPropIntCtlRepeat = 0x0001U;
|
||||
constexpr std::uint16_t kIntCtlStcEnable = 0x0001U; ///< STCIEN
|
||||
constexpr std::uint16_t kIntCtlStcRepeat = 0x0001U; ///< STCREP
|
||||
|
||||
std::uint16_t readLe16(const std::uint8_t* p)
|
||||
{
|
||||
@@ -140,28 +183,83 @@ std::expected<void, Si4684Error> Si4684Driver::waitCts()
|
||||
return std::unexpected(Si4684Error::CtsTimeout);
|
||||
}
|
||||
|
||||
std::expected<void, Si4684Error> Si4684Driver::waitStc()
|
||||
std::expected<bool, Si4684Error> Si4684Driver::pollStc()
|
||||
{
|
||||
std::array<std::uint8_t, 5> pollTx = {};
|
||||
std::array<std::uint8_t, 5> pollRx = {};
|
||||
|
||||
for (int attempt = 0; attempt < kStcRetries; ++attempt) {
|
||||
vTaskDelay(pdMS_TO_TICKS(kStcPollMs));
|
||||
spi_transaction_t txn = {};
|
||||
txn.length = pollTx.size() * 8U;
|
||||
txn.tx_buffer = pollTx.data();
|
||||
txn.rx_buffer = pollRx.data();
|
||||
if (spi_device_transmit(static_cast<spi_device_handle_t>(spiDevice_),
|
||||
&txn) != ESP_OK) {
|
||||
return std::unexpected(Si4684Error::SpiInitFailed);
|
||||
spi_transaction_t txn = {};
|
||||
txn.length = pollTx.size() * 8U;
|
||||
txn.tx_buffer = pollTx.data();
|
||||
txn.rx_buffer = pollRx.data();
|
||||
if (spi_device_transmit(static_cast<spi_device_handle_t>(spiDevice_),
|
||||
&txn) != ESP_OK) {
|
||||
return std::unexpected(Si4684Error::SpiInitFailed);
|
||||
}
|
||||
// STATUS0 STCINT (AN649 D0) is at pollRx[1] after the SPI lead-in byte.
|
||||
if ((pollRx[1] & 0x01U) != 0U) {
|
||||
return true;
|
||||
}
|
||||
if (pins_.intbGpio >= 0) {
|
||||
const gpio_num_t intb = static_cast<gpio_num_t>(pins_.intbGpio);
|
||||
if (gpio_get_level(intb) == 0) {
|
||||
return true;
|
||||
}
|
||||
if ((pollRx[1] & 0x01U) != 0U) {
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
std::expected<void, Si4684Error> Si4684Driver::waitStc(int maxRetries)
|
||||
{
|
||||
for (int attempt = 0; attempt < maxRetries; ++attempt) {
|
||||
vTaskDelay(pdMS_TO_TICKS(kStcPollMs));
|
||||
auto stc = pollStc();
|
||||
if (!stc) {
|
||||
return std::unexpected(stc.error());
|
||||
}
|
||||
if (*stc) {
|
||||
return {};
|
||||
}
|
||||
}
|
||||
// Diagnostic: dump the final poll so a STC timeout is distinguishable
|
||||
// between "chip replies but STCINT never sets" (register/offset bug)
|
||||
// and "chip stopped replying" (SPI/CTS problem) without guessing.
|
||||
std::array<std::uint8_t, 5> pollTx = {};
|
||||
std::array<std::uint8_t, 5> pollRx = {};
|
||||
spi_transaction_t txn = {};
|
||||
txn.length = pollTx.size() * 8U;
|
||||
txn.tx_buffer = pollTx.data();
|
||||
txn.rx_buffer = pollRx.data();
|
||||
const esp_err_t spiResult = spi_device_transmit(
|
||||
static_cast<spi_device_handle_t>(spiDevice_), &txn);
|
||||
const int intbLevel = pins_.intbGpio >= 0
|
||||
? gpio_get_level(static_cast<gpio_num_t>(pins_.intbGpio))
|
||||
: -1;
|
||||
ESP_LOGW(kTag,
|
||||
"STC timeout: last poll spi_err=%d status=%02x %02x %02x %02x "
|
||||
"%02x INTB=%d",
|
||||
static_cast<int>(spiResult), pollRx[0], pollRx[1], pollRx[2],
|
||||
pollRx[3], pollRx[4], intbLevel);
|
||||
return std::unexpected(Si4684Error::StcTimeout);
|
||||
}
|
||||
|
||||
std::expected<void, Si4684Error> Si4684Driver::clearFmStc()
|
||||
{
|
||||
if (auto band = ensureBand(Si4684Band::Fm); !band) {
|
||||
return band;
|
||||
}
|
||||
// AN649 FM_RSQ_STATUS ARG1 STCACK=1 clears a latched STCINT.
|
||||
const std::uint8_t args[] = {0x01U};
|
||||
if (auto cmd = writeCommand(Command::FmRsqStatus, args, sizeof(args));
|
||||
!cmd) {
|
||||
return cmd;
|
||||
}
|
||||
std::array<std::uint8_t, 23> raw = {};
|
||||
if (auto rd = readRaw(raw); !rd) {
|
||||
return rd;
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
std::expected<void, Si4684Error> Si4684Driver::sendCommand(
|
||||
std::span<const std::uint8_t> bytes)
|
||||
{
|
||||
@@ -314,7 +412,7 @@ std::expected<Si4684PartInfo, Si4684Error> Si4684Driver::getPartInfo()
|
||||
}
|
||||
|
||||
Si4684PartInfo info = {};
|
||||
info.chipId = readLe16(raw.data() + 9);
|
||||
info.chipId = readLe16(raw.data() + 9U);
|
||||
info.firmwareMajor = fnRaw[5];
|
||||
info.firmwareMinor = fnRaw[6];
|
||||
info.firmwareBuild = fnRaw[7];
|
||||
@@ -341,14 +439,21 @@ std::expected<Si4684SysState, Si4684Error> Si4684Driver::getSysState()
|
||||
std::expected<void, Si4684Error> Si4684Driver::configureAfterBoot(
|
||||
Si4684Band band)
|
||||
{
|
||||
if (auto stcEn = setProperty(kPropIntCtlEnable, kIntCtlStcEnable); !stcEn) {
|
||||
return stcEn;
|
||||
}
|
||||
if (auto stcRep = setProperty(kPropIntCtlRepeat, kIntCtlStcRepeat); !stcRep) {
|
||||
return stcRep;
|
||||
}
|
||||
|
||||
if (band == Si4684Band::Dab) {
|
||||
if (auto plan = installDefaultDabFrequencyPlan(); !plan) {
|
||||
return plan;
|
||||
}
|
||||
// AN851 recommended-network table, "DAB" row: 0xF8A9 / 0x01C6.
|
||||
static constexpr std::uint16_t kDabProps[][2] = {
|
||||
{0x0202U, 0x1600U},
|
||||
{0x1710U, 0xFC4AU},
|
||||
{0x1711U, 0x00F8U},
|
||||
{0x1710U, 0xF8A9U},
|
||||
{0x1711U, 0x01C6U},
|
||||
{0x8101U, 0x0064U},
|
||||
{0xB200U, 0x0000U},
|
||||
{0xB201U, 0x0080U},
|
||||
@@ -366,32 +471,92 @@ std::expected<void, Si4684Error> Si4684Driver::configureAfterBoot(
|
||||
if (auto xpad = setProperty(kPropDabXpadEnable, 0x0097U); !xpad) {
|
||||
return xpad;
|
||||
}
|
||||
if (auto dabFe = setProperty(kPropDabTuneFeCfg, 0x0001U); !dabFe) {
|
||||
ESP_LOGW(kTag, "DAB TUNE_FE_CFG (0x1712) failed");
|
||||
return dabFe;
|
||||
}
|
||||
if (auto dsrv = setProperty(kPropDigitalServiceIntSource, 0x0001U);
|
||||
!dsrv) {
|
||||
ESP_LOGW(kTag, "DIGITAL_SERVICE_INT_SOURCE (0x8100) failed");
|
||||
return dsrv;
|
||||
}
|
||||
} else {
|
||||
// FM varactor cal per hitech95/uGreen DTS (not DAB PE5PVB values).
|
||||
static constexpr std::uint16_t kFmFeProps[][2] = {
|
||||
{0x1710U, kFmTuneFeVarm},
|
||||
{0x1711U, kFmTuneFeVarb},
|
||||
};
|
||||
for (const auto& prop : kFmFeProps) {
|
||||
if (auto set = setProperty(prop[0], prop[1]); !set) {
|
||||
return set;
|
||||
}
|
||||
}
|
||||
if (auto feCfg = setProperty(kPropFmTuneFeCfg, kFmTuneFeCfgEnable);
|
||||
!feCfg) {
|
||||
return feCfg;
|
||||
}
|
||||
static constexpr std::uint16_t kFmSeekProps[][2] = {
|
||||
{kPropFmSeekBandBottom, kFmSeekBandBottomChip},
|
||||
{kPropFmSeekBandTop, kFmSeekBandTopChip},
|
||||
{kPropFmSeekSpacing, kFmSeekSpacingChip},
|
||||
};
|
||||
for (const auto& prop : kFmSeekProps) {
|
||||
if (auto set = setProperty(prop[0], prop[1]); !set) {
|
||||
return set;
|
||||
}
|
||||
}
|
||||
if (auto rds = setProperty(kPropFmRdsConfig, 0x0001U); !rds) {
|
||||
return rds;
|
||||
}
|
||||
// AN649 §0x3202/0x3204: lower seek/tune validity for weak lab antennas.
|
||||
if (auto rssi = setProperty(kPropFmValidRssiThreshold,
|
||||
kFmValidRssiThresholdDbuV);
|
||||
!rssi) {
|
||||
return rssi;
|
||||
}
|
||||
if (auto snr = setProperty(kPropFmValidSnrThreshold,
|
||||
kFmValidSnrThresholdDb);
|
||||
!snr) {
|
||||
return snr;
|
||||
}
|
||||
ESP_LOGI(kTag, "FM valid tune: RSSI>=%u dBuV SNR>=%u dB",
|
||||
static_cast<unsigned>(kFmValidRssiThresholdDbuV),
|
||||
static_cast<unsigned>(kFmValidSnrThresholdDb));
|
||||
}
|
||||
|
||||
if (auto i2s = setProperty(kPropDigitalIoOutputSelect, 0x8000U); !i2s) {
|
||||
return i2s;
|
||||
if (auto i2sRole =
|
||||
setProperty(kPropDigitalIoOutputSelect, kSi4684I2sSlaveSelect);
|
||||
!i2sRole) {
|
||||
return i2sRole;
|
||||
}
|
||||
if (auto rate = setProperty(kPropDigitalIoSampleRate, 0xAC44U); !rate) {
|
||||
if (auto i2sFmt =
|
||||
setProperty(kPropDigitalIoOutputFormat, kSi4684I2sOutputFormat);
|
||||
!i2sFmt) {
|
||||
return i2sFmt;
|
||||
}
|
||||
if (auto rate =
|
||||
setProperty(kPropDigitalIoSampleRate, kSi4684I2sSampleRateHz);
|
||||
!rate) {
|
||||
return rate;
|
||||
}
|
||||
if (auto pins = setProperty(kPropPinConfigEnable, 0x0003U); !pins) {
|
||||
return pins;
|
||||
}
|
||||
if (auto dabFe = setProperty(kPropDabTuneFeCfg, 0x0001U); !dabFe) {
|
||||
return dabFe;
|
||||
if (auto mute = setProperty(kPropAudioMute, 0x0000U); !mute) {
|
||||
return mute;
|
||||
}
|
||||
if (auto dsrv = setProperty(kPropDigitalServiceIntSource, 0x0001U);
|
||||
!dsrv) {
|
||||
return dsrv;
|
||||
if (auto outCfg = setProperty(kPropAudioOutputConfig, kSi4684I2sOutEnable);
|
||||
!outCfg) {
|
||||
return outCfg;
|
||||
}
|
||||
if (auto vol = setProperty(kPropAudioVolume, kSi4684VolumeMax); !vol) {
|
||||
return vol;
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
std::expected<void, Si4684Error> Si4684Driver::boot(Si4684Band band)
|
||||
std::expected<void, Si4684Error> Si4684Driver::boot(
|
||||
Si4684Band band, std::uint8_t xtalIbias, std::uint8_t xtalCtun)
|
||||
{
|
||||
if (booted_ && loadedBand_ == band) {
|
||||
return {};
|
||||
@@ -451,12 +616,25 @@ std::expected<void, Si4684Error> Si4684Driver::boot(Si4684Band band)
|
||||
spiDevice_ = dev;
|
||||
}
|
||||
|
||||
if (pins_.intbGpio >= 0) {
|
||||
gpio_config_t intCfg = {};
|
||||
intCfg.pin_bit_mask = 1ULL << pins_.intbGpio;
|
||||
intCfg.mode = GPIO_MODE_INPUT;
|
||||
intCfg.pull_up_en = GPIO_PULLUP_ENABLE;
|
||||
if (gpio_config(&intCfg) != ESP_OK) {
|
||||
return std::unexpected(Si4684Error::SpiInitFailed);
|
||||
}
|
||||
}
|
||||
|
||||
if (auto st = writeCommand(Command::GetSysState, nullptr, 0U); !st) {
|
||||
return st;
|
||||
}
|
||||
|
||||
const std::uint8_t powerUp[] = {
|
||||
0x17, 0x48, 0x00, 0xf8, 0x24, 0x01, 0x1F, 0x10,
|
||||
// ARG2=0x17(CLK_MODE=crystal,TR_SIZE), ARG3=IBIAS, ARG4-7=XTAL_FREQ
|
||||
// 19.2 MHz (0x0124F800), ARG8=CTUN, ARG9=0x10 (fixed bit4=1 per AN649
|
||||
// §Command 0x01), ARG10-15=0 (AN649 POWER_UP argument table).
|
||||
std::uint8_t powerUp[] = {
|
||||
0x17, xtalIbias, 0x00, 0xf8, 0x24, 0x01, xtalCtun, 0x10,
|
||||
0x00, 0x00, 0x00, 0x18, 0x00, 0x00,
|
||||
};
|
||||
if (auto pu = writeCommand(Command::PowerUp, powerUp, sizeof(powerUp));
|
||||
@@ -517,6 +695,9 @@ std::expected<void, Si4684Error> Si4684Driver::tuneFm(
|
||||
if (auto band = ensureBand(Si4684Band::Fm); !band) {
|
||||
return band;
|
||||
}
|
||||
if (auto cleared = clearFmStc(); !cleared) {
|
||||
return cleared;
|
||||
}
|
||||
const std::uint16_t chipFreq = kHzToChipFmFreq(frequency.value());
|
||||
const std::uint8_t args[] = {
|
||||
0x00U,
|
||||
@@ -524,13 +705,38 @@ std::expected<void, Si4684Error> Si4684Driver::tuneFm(
|
||||
static_cast<std::uint8_t>(chipFreq >> 8),
|
||||
0x00U,
|
||||
0x00U,
|
||||
0x00U, // PROG_ID (AN649 ARG6; ignored when DIR_TUNE=0)
|
||||
};
|
||||
if (auto cmd = writeCommand(Command::FmTuneFreq, args, sizeof(args));
|
||||
!cmd) {
|
||||
return std::unexpected(Si4684Error::TuneFailed);
|
||||
}
|
||||
if (auto stc = waitStc(); !stc) {
|
||||
return stc;
|
||||
if (auto stc = waitStc(kStcRetries); !stc) {
|
||||
ESP_LOGW(kTag, "FM tune STC timeout at %u kHz — settling 150 ms",
|
||||
static_cast<unsigned>(frequency.value()));
|
||||
vTaskDelay(pdMS_TO_TICKS(150));
|
||||
} else {
|
||||
(void)clearFmStc();
|
||||
}
|
||||
if (auto rsq = readFmRsq(); rsq) {
|
||||
const std::uint32_t readKhz =
|
||||
rsq->frequency ? rsq->frequency->value() : 0U;
|
||||
if (readKhz != 0U && readKhz != frequency.value()) {
|
||||
ESP_LOGW(kTag,
|
||||
"FM tune READFREQ mismatch: want %u kHz got %u kHz",
|
||||
static_cast<unsigned>(frequency.value()),
|
||||
static_cast<unsigned>(readKhz));
|
||||
}
|
||||
ESP_LOGI(kTag,
|
||||
"FM tuned %u kHz rssi=%d dBuV snr=%d dB valid=%d readfreq=%u",
|
||||
static_cast<unsigned>(frequency.value()),
|
||||
static_cast<int>(rsq->rssiDbuV),
|
||||
static_cast<int>(rsq->snrDb),
|
||||
static_cast<int>(rsq->valid),
|
||||
static_cast<unsigned>(readKhz));
|
||||
} else {
|
||||
ESP_LOGI(kTag, "FM tuned %u kHz (RSQ read failed)",
|
||||
static_cast<unsigned>(frequency.value()));
|
||||
}
|
||||
return {};
|
||||
}
|
||||
@@ -541,27 +747,54 @@ std::expected<core::FrequencyKHz, Si4684Error> Si4684Driver::seekFm(
|
||||
if (auto band = ensureBand(Si4684Band::Fm); !band) {
|
||||
return std::unexpected(band.error());
|
||||
}
|
||||
if (auto cleared = clearFmStc(); !cleared) {
|
||||
return std::unexpected(cleared.error());
|
||||
}
|
||||
std::optional<std::uint32_t> prevKhz;
|
||||
if (auto before = readFmRsq(); before && before->frequency) {
|
||||
prevKhz = before->frequency->value();
|
||||
}
|
||||
const bool seekUp = direction == core::SeekDirection::Up;
|
||||
const bool wrapBand = wrap == SeekBandWrap::Wrap;
|
||||
// AN649 FM_SEEK_START: ARG1=tune/injection, ARG2=SEEKUP|WRAP.
|
||||
const std::uint8_t seekFlags =
|
||||
static_cast<std::uint8_t>(((seekUp ? 1U : 0U) << 1U)
|
||||
| (wrapBand ? 1U : 0U));
|
||||
const std::uint8_t args[] = {
|
||||
0x10U,
|
||||
static_cast<std::uint8_t>(((seekUp ? 1U : 0U) << 1U) | (wrapBand ? 1U : 0U)),
|
||||
0x00U,
|
||||
seekFlags,
|
||||
0x00U,
|
||||
0x00U,
|
||||
0x00U,
|
||||
};
|
||||
if (auto cmd = writeCommand(Command::FmSeekStart, args, sizeof(args));
|
||||
!cmd) {
|
||||
ESP_LOGW(kTag, "FM seek command failed (flags=0x%02x)",
|
||||
static_cast<unsigned>(seekFlags));
|
||||
return std::unexpected(Si4684Error::TuneFailed);
|
||||
}
|
||||
if (auto stc = waitStc(); !stc) {
|
||||
if (auto stc = waitStc(kStcRetries); !stc) {
|
||||
ESP_LOGW(kTag, "FM seek STC timeout (flags=0x%02x)",
|
||||
static_cast<unsigned>(seekFlags));
|
||||
return std::unexpected(stc.error());
|
||||
}
|
||||
(void)clearFmStc();
|
||||
auto rsq = readFmRsq();
|
||||
if (!rsq) {
|
||||
ESP_LOGW(kTag, "FM seek RSQ read failed");
|
||||
return std::unexpected(rsq.error());
|
||||
}
|
||||
return rsq->frequency;
|
||||
if (!rsq->frequency) {
|
||||
ESP_LOGW(kTag, "FM seek READFREQ out of band (valid=%d)",
|
||||
static_cast<int>(rsq->valid));
|
||||
return std::unexpected(Si4684Error::TuneFailed);
|
||||
}
|
||||
if (prevKhz && rsq->frequency->value() == *prevKhz) {
|
||||
ESP_LOGW(kTag, "FM seek READFREQ unchanged at %u kHz",
|
||||
static_cast<unsigned>(*prevKhz));
|
||||
return std::unexpected(Si4684Error::TuneFailed);
|
||||
}
|
||||
return *rsq->frequency;
|
||||
}
|
||||
|
||||
std::expected<Si4684FmRsq, Si4684Error> Si4684Driver::readFmRsq()
|
||||
@@ -579,18 +812,42 @@ std::expected<Si4684FmRsq, Si4684Error> Si4684Driver::readFmRsq()
|
||||
return std::unexpected(rd.error());
|
||||
}
|
||||
|
||||
const auto khz = chipFmFreqToKHz(readLe16(raw.data() + 6));
|
||||
if (auto freq = core::FrequencyKHz::tryFromKhz(khz); freq) {
|
||||
Si4684FmRsq rsq{
|
||||
*freq,
|
||||
static_cast<std::int8_t>(raw[8]),
|
||||
static_cast<std::int8_t>(raw[9]),
|
||||
(raw[4] & 0x01U) != 0U,
|
||||
(raw[4] & 0x02U) != 0U,
|
||||
};
|
||||
return rsq;
|
||||
if (raw.size() < kFmRsqOffSnr + 1U) {
|
||||
return std::unexpected(Si4684Error::ReplyTooShort);
|
||||
}
|
||||
return std::unexpected(Si4684Error::CommandFailed);
|
||||
ESP_LOGI(kTag,
|
||||
"FM RSQ raw: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x "
|
||||
"%02x %02x",
|
||||
raw[0], raw[1], raw[2], raw[3], raw[4], raw[5], raw[6], raw[7],
|
||||
raw[8], raw[9], raw[10], raw[11]);
|
||||
const auto khz =
|
||||
chipFmFreqToKHz(readLe16(raw.data() + kFmRsqOffReadFreq));
|
||||
const auto freq = core::FrequencyKHz::tryFromKhz(khz);
|
||||
const bool freqInBand = static_cast<bool>(freq);
|
||||
const bool chipValid = (raw[kFmRsqOffValid] & 0x01U) != 0U;
|
||||
if (!freqInBand && khz != 0U) {
|
||||
ESP_LOGW(kTag,
|
||||
"FM RSQ out-of-band freq %u kHz (st=%02x %02x %02x %02x "
|
||||
"freq=%02x %02x rssi=%02x snr=%02x)",
|
||||
static_cast<unsigned>(khz), raw[kSpiReplyLeadIn],
|
||||
raw[kSpiReplyLeadIn + 1U],
|
||||
raw[kSpiReplyLeadIn + 2U], raw[kSpiReplyLeadIn + 3U],
|
||||
raw[kFmRsqOffReadFreq], raw[kFmRsqOffReadFreq + 1U],
|
||||
raw[kFmRsqOffRssi], raw[kFmRsqOffSnr]);
|
||||
} else if (khz == 0U && raw[kSpiReplyLeadIn] == 0U
|
||||
&& raw[kSpiReplyLeadIn + 1U] == 0U) {
|
||||
ESP_LOGW(kTag, "FM RSQ empty reply (st=%02x %02x %02x %02x)",
|
||||
raw[kSpiReplyLeadIn], raw[kSpiReplyLeadIn + 1U],
|
||||
raw[kSpiReplyLeadIn + 2U], raw[kSpiReplyLeadIn + 3U]);
|
||||
}
|
||||
Si4684FmRsq rsq{
|
||||
freqInBand ? std::optional<core::FrequencyKHz>{*freq} : std::nullopt,
|
||||
static_cast<std::int8_t>(raw[kFmRsqOffRssi]),
|
||||
static_cast<std::int8_t>(raw[kFmRsqOffSnr]),
|
||||
freqInBand && chipValid,
|
||||
false,
|
||||
};
|
||||
return rsq;
|
||||
}
|
||||
|
||||
std::expected<Si4684FmRdsStatus, Si4684Error> Si4684Driver::readFmRds()
|
||||
@@ -611,10 +868,10 @@ std::expected<Si4684FmRdsStatus, Si4684Error> Si4684Driver::readFmRds()
|
||||
Si4684FmRdsStatus rds = {};
|
||||
rds.received = (raw[4] & 0x01U) != 0U;
|
||||
rds.fifoUsed = raw[10];
|
||||
rds.blockA = readLe16(raw.data() + 12);
|
||||
rds.blockB = readLe16(raw.data() + 14);
|
||||
rds.blockC = readLe16(raw.data() + 16);
|
||||
rds.blockD = readLe16(raw.data() + 18);
|
||||
rds.blockA = readLe16(raw.data() + 12U);
|
||||
rds.blockB = readLe16(raw.data() + 14U);
|
||||
rds.blockC = readLe16(raw.data() + 16U);
|
||||
rds.blockD = readLe16(raw.data() + 18U);
|
||||
return rds;
|
||||
}
|
||||
|
||||
@@ -708,7 +965,7 @@ std::expected<void, Si4684Error> Si4684Driver::tuneDab(std::uint8_t freqIndex)
|
||||
!cmd) {
|
||||
return std::unexpected(Si4684Error::TuneFailed);
|
||||
}
|
||||
if (auto stc = waitStc(); !stc) {
|
||||
if (auto stc = waitStc(kStcRetries); !stc) {
|
||||
return stc;
|
||||
}
|
||||
return {};
|
||||
|
||||
@@ -13,11 +13,16 @@
|
||||
|
||||
#include "si4684/Si4684Tuner.hpp"
|
||||
|
||||
#include "esp_log.h"
|
||||
#include "si4684/Si4684Band.hpp"
|
||||
|
||||
namespace si4684 {
|
||||
|
||||
namespace {
|
||||
constexpr char kTag[] = "Si4684Tuner";
|
||||
constexpr std::uint32_t kFmSeekStepKhz = 100U;
|
||||
constexpr std::uint32_t kFmBandBottomKhz = 87500U;
|
||||
constexpr std::uint32_t kFmBandTopKhz = 107900U;
|
||||
|
||||
[[nodiscard]] core::FrequencyKHz defaultFmFrequency()
|
||||
{
|
||||
@@ -30,7 +35,8 @@ Si4684Tuner::Si4684Tuner(Si4684Driver& driver)
|
||||
: driver_(driver)
|
||||
, dabIndex_(0U)
|
||||
, fmFrequency_(defaultFmFrequency())
|
||||
, volume_(40U)
|
||||
, volume_(63U)
|
||||
, fmBandReady_(false)
|
||||
{
|
||||
}
|
||||
|
||||
@@ -44,6 +50,9 @@ core::TunerError Si4684Tuner::mapError(Si4684Error error) noexcept
|
||||
case Si4684Error::TuneFailed:
|
||||
case Si4684Error::StcTimeout:
|
||||
return core::TunerError::TuneFailed;
|
||||
case Si4684Error::CtsTimeout:
|
||||
case Si4684Error::CommandFailed:
|
||||
return core::TunerError::HardwareFailed;
|
||||
default:
|
||||
return core::TunerError::HardwareFailed;
|
||||
}
|
||||
@@ -68,6 +77,58 @@ std::expected<core::TunerBand, core::TunerError> Si4684Tuner::currentBand() cons
|
||||
: core::TunerBand::Dab;
|
||||
}
|
||||
|
||||
std::expected<void, core::TunerError> Si4684Tuner::ensureBandLoaded(
|
||||
core::TunerBand band)
|
||||
{
|
||||
const Si4684Band hwTarget =
|
||||
(band == core::TunerBand::Fm) ? Si4684Band::Fm : Si4684Band::Dab;
|
||||
if (driver_.isBooted() && driver_.loadedBand() == hwTarget) {
|
||||
if (hwTarget != Si4684Band::Fm || fmBandReady_) {
|
||||
return {};
|
||||
}
|
||||
}
|
||||
|
||||
const bool reloading =
|
||||
!(driver_.isBooted() && driver_.loadedBand() == hwTarget);
|
||||
if (reloading) {
|
||||
ESP_LOGI(kTag, "band switch -> %s",
|
||||
band == core::TunerBand::Fm ? "FM" : "DAB");
|
||||
}
|
||||
|
||||
if (driver_.isBooted() && driver_.loadedBand() == Si4684Band::Dab
|
||||
&& hwTarget == Si4684Band::Fm && lastDabServiceId_
|
||||
&& lastDabComponentId_) {
|
||||
(void)driver_.stopDabService(*lastDabServiceId_, *lastDabComponentId_);
|
||||
lastDabServiceId_.reset();
|
||||
lastDabComponentId_.reset();
|
||||
dabDynamicLabel_.reset();
|
||||
}
|
||||
|
||||
if (auto loaded = boot(band); !loaded) {
|
||||
return loaded;
|
||||
}
|
||||
|
||||
if (auto vol = driver_.setVolume(volume_); !vol) {
|
||||
return std::unexpected(mapError(vol.error()));
|
||||
}
|
||||
|
||||
if (band == core::TunerBand::Fm) {
|
||||
rdsMetadata_.reset();
|
||||
fmFrequency_ = defaultFmFrequency();
|
||||
fmBandReady_ = false;
|
||||
if (auto tuned = driver_.tuneFm(fmFrequency_); !tuned) {
|
||||
return std::unexpected(mapError(tuned.error()));
|
||||
}
|
||||
fmBandReady_ = true;
|
||||
} else {
|
||||
fmBandReady_ = false;
|
||||
dabDynamicLabel_.reset();
|
||||
lastDabServiceId_.reset();
|
||||
lastDabComponentId_.reset();
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
std::expected<core::TunerStatus, core::TunerError> Si4684Tuner::readStatus()
|
||||
{
|
||||
if (!driver_.isBooted()) {
|
||||
@@ -106,11 +167,20 @@ std::expected<core::TunerStatus, core::TunerError> Si4684Tuner::readStatus()
|
||||
status.fmFrequency = fmFrequency_;
|
||||
if (auto rsq = driver_.readFmRsq(); rsq) {
|
||||
status.locked = rsq->valid;
|
||||
status.fmFrequency = rsq->frequency;
|
||||
status.fmRssiDbuV = rsq->rssiDbuV;
|
||||
status.fmSnrDb = rsq->snrDb;
|
||||
status.fmStereo = rsq->stereo;
|
||||
fmFrequency_ = rsq->frequency;
|
||||
status.fmChipReadFrequency = rsq->frequency;
|
||||
// Keep commanded frequency when chip READFREQ is stale (stuck at band
|
||||
// bottom); adopt READFREQ only when valid or it matches our target.
|
||||
status.fmFrequency = fmFrequency_;
|
||||
if (rsq->frequency) {
|
||||
const std::uint32_t chipKhz = rsq->frequency->value();
|
||||
if (rsq->valid || chipKhz == fmFrequency_.value()) {
|
||||
status.fmFrequency = *rsq->frequency;
|
||||
fmFrequency_ = *rsq->frequency;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
return std::unexpected(mapError(rsq.error()));
|
||||
}
|
||||
@@ -118,7 +188,8 @@ std::expected<core::TunerStatus, core::TunerError> Si4684Tuner::readStatus()
|
||||
for (int attempt = 0; attempt < 8; ++attempt) {
|
||||
auto rds = driver_.readFmRds();
|
||||
if (!rds) {
|
||||
return std::unexpected(mapError(rds.error()));
|
||||
ESP_LOGW(kTag, "FM RDS read failed (attempt %d)", attempt);
|
||||
break;
|
||||
}
|
||||
if (!rds->received) {
|
||||
break;
|
||||
@@ -140,6 +211,9 @@ std::expected<core::TunerStatus, core::TunerError> Si4684Tuner::readStatus()
|
||||
std::expected<void, core::TunerError> Si4684Tuner::tuneDab(
|
||||
std::uint8_t freqIndex)
|
||||
{
|
||||
if (auto ready = ensureBandLoaded(core::TunerBand::Dab); !ready) {
|
||||
return ready;
|
||||
}
|
||||
if (auto result = driver_.tuneDab(freqIndex); !result) {
|
||||
return std::unexpected(mapError(result.error()));
|
||||
}
|
||||
@@ -153,14 +227,9 @@ std::expected<void, core::TunerError> Si4684Tuner::tuneDab(
|
||||
std::expected<void, core::TunerError> Si4684Tuner::tuneFm(
|
||||
core::FrequencyKHz frequency)
|
||||
{
|
||||
if (driver_.loadedBand() == Si4684Band::Dab && lastDabServiceId_
|
||||
&& lastDabComponentId_) {
|
||||
(void)driver_.stopDabService(*lastDabServiceId_, *lastDabComponentId_);
|
||||
lastDabServiceId_.reset();
|
||||
lastDabComponentId_.reset();
|
||||
dabDynamicLabel_.reset();
|
||||
if (auto ready = ensureBandLoaded(core::TunerBand::Fm); !ready) {
|
||||
return ready;
|
||||
}
|
||||
|
||||
if (auto result = driver_.tuneFm(frequency); !result) {
|
||||
return std::unexpected(mapError(result.error()));
|
||||
}
|
||||
@@ -172,18 +241,55 @@ std::expected<void, core::TunerError> Si4684Tuner::tuneFm(
|
||||
std::expected<core::FrequencyKHz, core::TunerError> Si4684Tuner::seekFm(
|
||||
core::SeekDirection direction)
|
||||
{
|
||||
const auto result = driver_.seekFm(direction, SeekBandWrap::Wrap);
|
||||
if (!result) {
|
||||
return std::unexpected(mapError(result.error()));
|
||||
if (auto ready = ensureBandLoaded(core::TunerBand::Fm); !ready) {
|
||||
return std::unexpected(ready.error());
|
||||
}
|
||||
fmFrequency_ = *result;
|
||||
rdsMetadata_.reset();
|
||||
return *result;
|
||||
const core::FrequencyKHz before = fmFrequency_;
|
||||
const auto hw = driver_.seekFm(direction, SeekBandWrap::Wrap);
|
||||
if (hw && hw->value() != before.value()) {
|
||||
fmFrequency_ = *hw;
|
||||
rdsMetadata_.reset();
|
||||
return *hw;
|
||||
}
|
||||
|
||||
// hitech95/si468x_dab_receiver uses HW seek + INTB STC; when READFREQ does
|
||||
// not move, step by FM_SEEK_FREQUENCY_SPACING (100 kHz) via FM_TUNE_FREQ.
|
||||
std::uint32_t nextKhz = before.value();
|
||||
if (direction == core::SeekDirection::Up) {
|
||||
nextKhz += kFmSeekStepKhz;
|
||||
if (nextKhz > kFmBandTopKhz) {
|
||||
nextKhz = kFmBandBottomKhz;
|
||||
}
|
||||
} else {
|
||||
nextKhz = (nextKhz > kFmBandBottomKhz + kFmSeekStepKhz)
|
||||
? nextKhz - kFmSeekStepKhz
|
||||
: kFmBandTopKhz;
|
||||
}
|
||||
const auto next = core::FrequencyKHz::tryFromKhz(nextKhz);
|
||||
if (!next) {
|
||||
return std::unexpected(core::TunerError::TuneFailed);
|
||||
}
|
||||
if (auto stepped = tuneFm(*next); !stepped) {
|
||||
return std::unexpected(stepped.error());
|
||||
}
|
||||
if (auto rsq = driver_.readFmRsq(); rsq && rsq->frequency) {
|
||||
ESP_LOGI(kTag, "FM software seek %s -> %u kHz (chip READFREQ)",
|
||||
direction == core::SeekDirection::Up ? "UP" : "DOWN",
|
||||
static_cast<unsigned>(rsq->frequency->value()));
|
||||
return *rsq->frequency;
|
||||
}
|
||||
ESP_LOGI(kTag, "FM software seek %s -> %u kHz",
|
||||
direction == core::SeekDirection::Up ? "UP" : "DOWN",
|
||||
static_cast<unsigned>(nextKhz));
|
||||
return *next;
|
||||
}
|
||||
|
||||
std::expected<std::vector<core::TunerServiceEntry>, core::TunerError>
|
||||
Si4684Tuner::listDabServices()
|
||||
{
|
||||
if (auto ready = ensureBandLoaded(core::TunerBand::Dab); !ready) {
|
||||
return std::unexpected(ready.error());
|
||||
}
|
||||
if (auto events = driver_.readDabEventStatus(); events) {
|
||||
if (!events->serviceListReady) {
|
||||
return std::unexpected(core::TunerError::ServiceListEmpty);
|
||||
@@ -215,6 +321,9 @@ std::expected<void, core::TunerError> Si4684Tuner::playDabService(
|
||||
std::uint32_t serviceId,
|
||||
std::uint32_t componentId)
|
||||
{
|
||||
if (auto ready = ensureBandLoaded(core::TunerBand::Dab); !ready) {
|
||||
return ready;
|
||||
}
|
||||
if (auto result = driver_.startDabService(serviceId, componentId); !result) {
|
||||
return std::unexpected(mapError(result.error()));
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user