From 610991455d335663de1dd6c0c6a3e0247ffd46df Mon Sep 17 00:00:00 2001 From: jacqueline Date: Wed, 7 Jun 2023 09:50:25 +1000 Subject: [PATCH] R4 pre-emptive bringup Includes stripping out the IC-specific I2S stuff, and doing more manual volume control using pots --- src/audio/audio_fsm.cpp | 21 +- src/audio/audio_task.cpp | 1 - src/audio/i2s_audio_output.cpp | 102 +++++- src/audio/include/audio_fsm.hpp | 10 +- src/audio/include/audio_sink.hpp | 7 +- src/audio/include/audio_task.hpp | 8 - src/audio/include/i2s_audio_output.hpp | 20 +- src/drivers/CMakeLists.txt | 4 +- src/drivers/dac.cpp | 465 ------------------------- src/drivers/digital_pot.cpp | 85 +++++ src/drivers/i2s_dac.cpp | 202 +++++++++++ src/drivers/include/dac.hpp | 204 ----------- src/drivers/include/digital_pot.hpp | 49 +++ src/drivers/include/gpio_expander.hpp | 24 +- src/drivers/include/i2s_dac.hpp | 78 +++++ src/system_fsm/booting.cpp | 10 +- src/system_fsm/include/system_fsm.hpp | 2 - src/system_fsm/system_fsm.cpp | 1 - src/ui/include/ui_fsm.hpp | 4 +- src/ui/ui_fsm.cpp | 3 +- 20 files changed, 562 insertions(+), 738 deletions(-) delete mode 100644 src/drivers/dac.cpp create mode 100644 src/drivers/digital_pot.cpp create mode 100644 src/drivers/i2s_dac.cpp delete mode 100644 src/drivers/include/dac.hpp create mode 100644 src/drivers/include/digital_pot.hpp create mode 100644 src/drivers/include/i2s_dac.hpp diff --git a/src/audio/audio_fsm.cpp b/src/audio/audio_fsm.cpp index 9c7af6fe..3ab8b6e8 100644 --- a/src/audio/audio_fsm.cpp +++ b/src/audio/audio_fsm.cpp @@ -5,18 +5,20 @@ */ #include "audio_fsm.hpp" +#include #include "audio_decoder.hpp" #include "audio_events.hpp" #include "audio_task.hpp" -#include "dac.hpp" #include "fatfs_audio_input.hpp" #include "i2s_audio_output.hpp" +#include "i2s_dac.hpp" #include "pipeline.hpp" namespace audio { drivers::GpioExpander* AudioState::sGpioExpander; -std::weak_ptr AudioState::sDac; +std::shared_ptr AudioState::sDac; +std::shared_ptr AudioState::sPots; std::weak_ptr AudioState::sDatabase; std::unique_ptr AudioState::sFileSource; @@ -24,14 +26,19 @@ std::unique_ptr AudioState::sI2SOutput; std::vector> AudioState::sPipeline; auto AudioState::Init(drivers::GpioExpander* gpio_expander, - std::weak_ptr dac, - std::weak_ptr database) -> void { + std::weak_ptr database) -> bool { sGpioExpander = gpio_expander; - sDac = dac; + + auto dac = drivers::I2SDac::create(gpio_expander); + if (!dac) { + return false; + } + sDac.reset(dac.value()); + sPots.reset(new drivers::DigitalPot(gpio_expander)); sDatabase = database; sFileSource.reset(new FatfsAudioInput()); - sI2SOutput.reset(new I2SAudioOutput(sGpioExpander, sDac)); + sI2SOutput.reset(new I2SAudioOutput(sGpioExpander, sDac, sPots)); // Perform initial pipeline configuration. // TODO(jacqueline): Factor this out once we have any kind of dynamic @@ -43,6 +50,8 @@ auto AudioState::Init(drivers::GpioExpander* gpio_expander, pipeline->AddInput(sFileSource.get()); task::StartPipeline(pipeline, sI2SOutput.get()); + + return true; } namespace states { diff --git a/src/audio/audio_task.cpp b/src/audio/audio_task.cpp index 343281a7..46d527b5 100644 --- a/src/audio/audio_task.cpp +++ b/src/audio/audio_task.cpp @@ -17,7 +17,6 @@ #include "audio_sink.hpp" #include "cbor.h" -#include "dac.hpp" #include "esp_err.h" #include "esp_heap_caps.h" #include "esp_log.h" diff --git a/src/audio/i2s_audio_output.cpp b/src/audio/i2s_audio_output.cpp index 70304726..aab011d1 100644 --- a/src/audio/i2s_audio_output.cpp +++ b/src/audio/i2s_audio_output.cpp @@ -5,19 +5,21 @@ */ #include "i2s_audio_output.hpp" +#include #include #include #include #include +#include "digital_pot.hpp" #include "esp_err.h" #include "freertos/portmacro.h" #include "audio_element.hpp" -#include "dac.hpp" #include "freertos/projdefs.h" #include "gpio_expander.hpp" +#include "i2s_dac.hpp" #include "result.hpp" #include "stream_info.hpp" @@ -26,16 +28,86 @@ static const char* kTag = "I2SOUT"; namespace audio { I2SAudioOutput::I2SAudioOutput(drivers::GpioExpander* expander, - std::weak_ptr dac) - : expander_(expander), dac_(dac.lock()), current_config_() { - dac_->WriteVolume(127); // for testing + std::weak_ptr dac, + std::weak_ptr pots) + : expander_(expander), + dac_(dac.lock()), + pots_(pots.lock()), + current_config_(), + left_difference_(0), + attenuation_(pots_->GetMaxAttenuation()) { + SetVolume(25); // For testing dac_->SetSource(buffer()); + dac_->Start(); } I2SAudioOutput::~I2SAudioOutput() { + dac_->Stop(); dac_->SetSource(nullptr); } +auto I2SAudioOutput::SetVolumeImbalance(int_fast8_t balance) -> void { + int_fast8_t new_difference = balance - left_difference_; + left_difference_ = balance; + if (attenuation_ + new_difference <= pots_->GetMinAttenuation()) { + // Volume is currently very high, so shift the left channel down. + pots_->SetRelative(drivers::DigitalPot::Channel::kLeft, -new_difference); + } else if (attenuation_ - new_difference >= pots_->GetMaxAttenuation()) { + // Volume is currently very low, so shift the left channel up. + pots_->SetRelative(drivers::DigitalPot::Channel::kLeft, new_difference); + } else { + ESP_LOGE(kTag, "volume imbalance higher than attenuation range"); + } +} + +auto I2SAudioOutput::SetVolume(uint_fast8_t percent) -> void { + percent = 100 - percent; + int_fast8_t target_attenuation = + static_cast(static_cast(GetAdjustedMaxAttenuation()) / + 100.0f * static_cast(percent)); + target_attenuation -= pots_->GetMinAttenuation(); + int_fast8_t difference = target_attenuation - attenuation_; + pots_->SetRelative(difference); + attenuation_ = target_attenuation; + ESP_LOGI(kTag, "adjusting attenuation by %idB to %idB", difference, + attenuation_); +} + +auto I2SAudioOutput::GetVolume() -> uint_fast8_t { + // Convert to percentage. + uint_fast8_t percent = static_cast( + static_cast(attenuation_) / + static_cast(GetAdjustedMaxAttenuation()) * 100.0f); + // Invert to get from attenuation to volume. + return 100 - percent; +} + +auto I2SAudioOutput::GetAdjustedMaxAttenuation() -> int_fast8_t { + // Clip to account for imbalance. + int_fast8_t adjusted_max = + pots_->GetMaxAttenuation() - std::abs(left_difference_); + // Shift to be zero minimum. + adjusted_max -= pots_->GetMinAttenuation(); + + return adjusted_max; +} + +auto I2SAudioOutput::AdjustVolumeUp() -> void { + if (attenuation_ + left_difference_ <= pots_->GetMinAttenuation()) { + return; + } + attenuation_--; + pots_->SetRelative(-1); +} + +auto I2SAudioOutput::AdjustVolumeDown() -> void { + if (attenuation_ - left_difference_ >= pots_->GetMaxAttenuation()) { + return; + } + attenuation_++; + pots_->SetRelative(1); +} + auto I2SAudioOutput::Configure(const StreamInfo::Format& format) -> bool { if (!std::holds_alternative(format)) { ESP_LOGI(kTag, "ignoring non-pcm stream (%d)", format.index()); @@ -52,29 +124,29 @@ auto I2SAudioOutput::Configure(const StreamInfo::Format& format) -> bool { ESP_LOGI(kTag, "incoming audio stream: %u bpp @ %lu Hz", pcm.bits_per_sample, pcm.sample_rate); - drivers::AudioDac::BitsPerSample bps; + drivers::I2SDac::BitsPerSample bps; switch (pcm.bits_per_sample) { case 16: - bps = drivers::AudioDac::BPS_16; + bps = drivers::I2SDac::BPS_16; break; case 24: - bps = drivers::AudioDac::BPS_24; + bps = drivers::I2SDac::BPS_24; break; case 32: - bps = drivers::AudioDac::BPS_32; + bps = drivers::I2SDac::BPS_32; break; default: ESP_LOGE(kTag, "dropping stream with unknown bps"); return false; } - drivers::AudioDac::SampleRate sample_rate; + drivers::I2SDac::SampleRate sample_rate; switch (pcm.sample_rate) { case 44100: - sample_rate = drivers::AudioDac::SAMPLE_RATE_44_1; + sample_rate = drivers::I2SDac::SAMPLE_RATE_44_1; break; case 48000: - sample_rate = drivers::AudioDac::SAMPLE_RATE_48; + sample_rate = drivers::I2SDac::SAMPLE_RATE_48; break; default: ESP_LOGE(kTag, "dropping stream with unknown rate"); @@ -93,12 +165,4 @@ auto I2SAudioOutput::Send(const cpp::span& data) -> void { dac_->WriteData(data); } -auto I2SAudioOutput::Log() -> void { - dac_->LogStatus(); -} - -auto I2SAudioOutput::SetVolume(uint8_t volume) -> void { - dac_->WriteVolume(volume); -} - } // namespace audio diff --git a/src/audio/include/audio_fsm.hpp b/src/audio/include/audio_fsm.hpp index 7368cfc8..6274041c 100644 --- a/src/audio/include/audio_fsm.hpp +++ b/src/audio/include/audio_fsm.hpp @@ -5,15 +5,17 @@ */ #pragma once + #include +#include #include "audio_events.hpp" -#include "dac.hpp" #include "database.hpp" #include "display.hpp" #include "fatfs_audio_input.hpp" #include "gpio_expander.hpp" #include "i2s_audio_output.hpp" +#include "i2s_dac.hpp" #include "storage.hpp" #include "tinyfsm.hpp" @@ -24,8 +26,7 @@ namespace audio { class AudioState : public tinyfsm::Fsm { public: static auto Init(drivers::GpioExpander* gpio_expander, - std::weak_ptr, - std::weak_ptr) -> void; + std::weak_ptr) -> bool; virtual ~AudioState() {} @@ -41,7 +42,8 @@ class AudioState : public tinyfsm::Fsm { protected: static drivers::GpioExpander* sGpioExpander; - static std::weak_ptr sDac; + static std::shared_ptr sDac; + static std::shared_ptr sPots; static std::weak_ptr sDatabase; static std::unique_ptr sFileSource; diff --git a/src/audio/include/audio_sink.hpp b/src/audio/include/audio_sink.hpp index 331105af..2cc706ff 100644 --- a/src/audio/include/audio_sink.hpp +++ b/src/audio/include/audio_sink.hpp @@ -40,9 +40,14 @@ class IAudioSink { free(metadata_); } + virtual auto SetVolumeImbalance(int_fast8_t balance) -> void = 0; + virtual auto SetVolume(uint_fast8_t percent) -> void = 0; + virtual auto GetVolume() -> uint_fast8_t = 0; + virtual auto AdjustVolumeUp() -> void = 0; + virtual auto AdjustVolumeDown() -> void = 0; + virtual auto Configure(const StreamInfo::Format& format) -> bool = 0; virtual auto Send(const cpp::span& data) -> void = 0; - virtual auto Log() -> void {} auto buffer() -> StreamBufferHandle_t { return handle_; } }; diff --git a/src/audio/include/audio_task.hpp b/src/audio/include/audio_task.hpp index 298bd591..f997caee 100644 --- a/src/audio/include/audio_task.hpp +++ b/src/audio/include/audio_task.hpp @@ -6,16 +6,8 @@ #pragma once -#include -#include -#include - -#include "audio_element.hpp" #include "audio_sink.hpp" -#include "dac.hpp" -#include "freertos/portmacro.h" #include "pipeline.hpp" -#include "stream_buffer.hpp" namespace audio { diff --git a/src/audio/include/i2s_audio_output.hpp b/src/audio/include/i2s_audio_output.hpp index 46c3ada8..20980573 100644 --- a/src/audio/include/i2s_audio_output.hpp +++ b/src/audio/include/i2s_audio_output.hpp @@ -15,8 +15,9 @@ #include "chunk.hpp" #include "result.hpp" -#include "dac.hpp" +#include "digital_pot.hpp" #include "gpio_expander.hpp" +#include "i2s_dac.hpp" #include "stream_info.hpp" namespace audio { @@ -24,23 +25,32 @@ namespace audio { class I2SAudioOutput : public IAudioSink { public: I2SAudioOutput(drivers::GpioExpander* expander, - std::weak_ptr dac); + std::weak_ptr dac, + std::weak_ptr pots); ~I2SAudioOutput(); + auto SetVolumeImbalance(int_fast8_t balance) -> void override; + auto SetVolume(uint_fast8_t percent) -> void override; + auto GetVolume() -> uint_fast8_t override; + auto AdjustVolumeUp() -> void override; + auto AdjustVolumeDown() -> void override; + auto Configure(const StreamInfo::Format& format) -> bool override; auto Send(const cpp::span& data) -> void override; - auto Log() -> void override; I2SAudioOutput(const I2SAudioOutput&) = delete; I2SAudioOutput& operator=(const I2SAudioOutput&) = delete; private: - auto SetVolume(uint8_t volume) -> void; + auto GetAdjustedMaxAttenuation() -> int_fast8_t; drivers::GpioExpander* expander_; - std::shared_ptr dac_; + std::shared_ptr dac_; + std::shared_ptr pots_; std::optional current_config_; + int_fast8_t left_difference_; + uint_fast8_t attenuation_; }; } // namespace audio diff --git a/src/drivers/CMakeLists.txt b/src/drivers/CMakeLists.txt index 82acab3d..fff61f5f 100644 --- a/src/drivers/CMakeLists.txt +++ b/src/drivers/CMakeLists.txt @@ -3,8 +3,8 @@ # SPDX-License-Identifier: GPL-3.0-only idf_component_register( - SRCS "touchwheel.cpp" "dac.cpp" "gpio_expander.cpp" "battery.cpp" "storage.cpp" "i2c.cpp" - "spi.cpp" "display.cpp" "display_init.cpp" "samd.cpp" "relative_wheel.cpp" + SRCS "touchwheel.cpp" "i2s_dac.cpp" "gpio_expander.cpp" "battery.cpp" "storage.cpp" "i2c.cpp" + "spi.cpp" "display.cpp" "display_init.cpp" "samd.cpp" "relative_wheel.cpp" "digital_pot.cpp" INCLUDE_DIRS "include" REQUIRES "esp_adc" "fatfs" "result" "lvgl" "span" "tasks") target_compile_options(${COMPONENT_LIB} PRIVATE ${EXTRA_WARNINGS}) diff --git a/src/drivers/dac.cpp b/src/drivers/dac.cpp deleted file mode 100644 index 3d8e0702..00000000 --- a/src/drivers/dac.cpp +++ /dev/null @@ -1,465 +0,0 @@ -/* - * Copyright 2023 jacqueline - * - * SPDX-License-Identifier: GPL-3.0-only - */ - -#include "dac.hpp" - -#include -#include - -#include "assert.h" -#include "driver/i2c.h" -#include "driver/i2s_common.h" -#include "driver/i2s_std.h" -#include "esp_attr.h" -#include "esp_err.h" -#include "esp_log.h" -#include "freertos/portmacro.h" -#include "freertos/projdefs.h" -#include "hal/gpio_types.h" -#include "hal/i2c_types.h" - -#include "gpio_expander.hpp" -#include "hal/i2s_types.h" -#include "i2c.hpp" -#include "soc/clk_tree_defs.h" -#include "sys/_stdint.h" - -namespace drivers { - -static const char* kTag = "AUDIODAC"; -static const uint8_t kPcm5122Address = 0x4C; -static const i2s_port_t kI2SPort = I2S_NUM_0; - -auto AudioDac::create(GpioExpander* expander) -> cpp::result { - // TODO: tune. - i2s_chan_handle_t i2s_handle; - i2s_chan_config_t channel_config = - I2S_CHANNEL_DEFAULT_CONFIG(kI2SPort, I2S_ROLE_MASTER); - // Use the maximum possible DMA buffer size, since a smaller number of large - // copies is faster than a large number of small copies. - channel_config.dma_frame_num = 1024; - // Triple buffering should be enough to keep samples flowing smoothly. - // TODO(jacqueline): verify this with 192kHz 32bps. - channel_config.dma_desc_num = 4; - // channel_config.auto_clear = true; - - ESP_ERROR_CHECK(i2s_new_channel(&channel_config, &i2s_handle, NULL)); - // - // First, instantiate the instance so it can do all of its power on - // configuration. - std::unique_ptr dac = - std::make_unique(expander, i2s_handle); - - // Whilst we wait for the initial boot, we can work on installing the I2S - // driver. - i2s_std_config_t i2s_config = { - .clk_cfg = dac->clock_config_, - .slot_cfg = dac->slot_config_, - .gpio_cfg = {.mclk = GPIO_NUM_0, - .bclk = GPIO_NUM_26, - .ws = GPIO_NUM_27, - .dout = GPIO_NUM_5, - .din = I2S_GPIO_UNUSED, - .invert_flags = - { - .mclk_inv = false, - .bclk_inv = false, - .ws_inv = true, - }}, - }; - - // gpio_set_direction(GPIO_NUM_0, GPIO_MODE_OUTPUT); - // gpio_set_level(GPIO_NUM_0, 0); - - if (esp_err_t err = - i2s_channel_init_std_mode(i2s_handle, &i2s_config) != ESP_OK) { - ESP_LOGE(kTag, "failed to initialise i2s channel %x", err); - return cpp::fail(Error::FAILED_TO_INSTALL_I2S); - } - - // Make sure the DAC has booted before sending commands to it. - bool is_booted = dac->WaitForPowerState( - [](bool booted, PowerState state) { return booted; }); - if (!is_booted) { - ESP_LOGE(kTag, "Timed out waiting for boot"); - return cpp::fail(Error::FAILED_TO_BOOT); - } - - // The DAC should be booted but in power down mode, but it might not be if we - // didn't shut down cleanly. Reset it to ensure it is in a consistent state. - dac->WriteRegister(pcm512x::POWER, 1 << 4); - dac->WriteRegister(pcm512x::RESET, 0b10001); - - // Use BCK for the internal PLL. - // dac->WriteRegister(Register::PLL_CLOCK_SOURCE, 1 << 4); - // dac->WriteRegister(Register::DAC_CLOCK_SOURCE, 0b11 << 5); - - // dac->WriteRegister(Register::PLL_ENABLE, 0); - // dac->WriteRegister(Register::DAC_CLOCK_SOURCE, 0b0110000); - // dac->WriteRegister(Register::CLOCK_ERRORS, 0b01000001); - // dac->WriteRegister(Register::I2S_FORMAT, 0b110000); - // dac->WriteRegister(Register::INTERPOLATION, 1 << 4); - - dac->Reconfigure(BPS_16, SAMPLE_RATE_44_1); - - // Now configure the DAC for standard auto-clock SCK mode. - - // Enable auto clocking, and do your best to carry on despite errors. - // dac->WriteRegister(Register::CLOCK_ERRORS, 0b1111101); - - // i2s_channel_enable(dac->i2s_handle_); - - dac->WaitForPowerState([](bool booted, PowerState state) { - return state == RUN || state == STANDBY; - }); - - return dac.release(); -} - -AudioDac::AudioDac(GpioExpander* gpio, i2s_chan_handle_t i2s_handle) - : gpio_(gpio), - i2s_handle_(i2s_handle), - i2s_active_(false), - active_page_(), - clock_config_(I2S_STD_CLK_DEFAULT_CONFIG(44100)), - slot_config_(I2S_STD_MSB_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_16BIT, - I2S_SLOT_MODE_STEREO)) { - clock_config_.clk_src = I2S_CLK_SRC_PLL_160M; - gpio_->set_pin(GpioExpander::AMP_EN, true); - gpio_->Write(); -} - -AudioDac::~AudioDac() { - i2s_channel_disable(i2s_handle_); - i2s_del_channel(i2s_handle_); - gpio_->set_pin(GpioExpander::AMP_EN, false); - gpio_->Write(); -} - -void AudioDac::WriteVolume(uint8_t volume) { - // Left channel. - WriteRegister(pcm512x::DIGITAL_VOLUME_2, volume); - // Right channel. - WriteRegister(pcm512x::DIGITAL_VOLUME_3, volume); -} - -std::pair AudioDac::ReadPowerState() { - uint8_t result = ReadRegister(pcm512x::POWER_STATE); - bool is_booted = result >> 7; - PowerState detail = (PowerState)(result & 0b1111); - return std::pair(is_booted, detail); -} - -bool AudioDac::WaitForPowerState( - std::function predicate) { - bool has_matched = false; - for (int i = 0; i < 10; i++) { - std::pair result = ReadPowerState(); - has_matched = predicate(result.first, result.second); - if (has_matched) { - break; - } else { - ESP_LOGI(kTag, "Waiting for power state (was %d 0x%x)", result.first, - (uint8_t)result.second); - vTaskDelay(pdMS_TO_TICKS(250)); - } - } - return has_matched; -} - -auto AudioDac::Reconfigure(BitsPerSample bps, SampleRate rate) -> void { - if (i2s_active_) { - WriteRegister(pcm512x::MUTE, 0b10001); - vTaskDelay(1); - WriteRegister(pcm512x::POWER, 1 << 4); - i2s_channel_disable(i2s_handle_); - } - - // I2S reconfiguration. - uint8_t bps_bits = 0; - switch (bps) { - case BPS_16: - slot_config_.data_bit_width = I2S_DATA_BIT_WIDTH_16BIT; - bps_bits = 0; - break; - case BPS_24: - slot_config_.data_bit_width = I2S_DATA_BIT_WIDTH_24BIT; - bps_bits = 0b10; - break; - case BPS_32: - slot_config_.data_bit_width = I2S_DATA_BIT_WIDTH_32BIT; - bps_bits = 0b11; - break; - } - ESP_ERROR_CHECK(i2s_channel_reconfig_std_slot(i2s_handle_, &slot_config_)); - - clock_config_.sample_rate_hz = rate; - // If we have an MCLK/SCK, then it must be a multiple of both the sample rate - // and the bit clock. At 24 BPS, we therefore have to change the MCLK multiple - // to avoid issues at some sample rates. (e.g. 48KHz) - clock_config_.mclk_multiple = - bps == BPS_24 ? I2S_MCLK_MULTIPLE_384 : I2S_MCLK_MULTIPLE_256; - ESP_ERROR_CHECK(i2s_channel_reconfig_std_clock(i2s_handle_, &clock_config_)); - - // DAC reconfiguration. - // Inspired heavily by https://github.com/tommag/PCM51xx_Arduino (MIT). - - // Check that the bit clock (PLL input) is between 1MHz and 50MHz. It always - // should be. - uint32_t bckFreq = rate * bps * 2; - if (bckFreq < 1000000 || bckFreq > 50000000) { - ESP_LOGE(kTag, "bck freq out of range"); - return; - } - - // 24 bits is not supported for 44.1kHz and 48kHz. - if ((rate == SAMPLE_RATE_44_1 || rate == SAMPLE_RATE_48) && bps == BPS_24) { - // TODO(jacqueline): I think this *can* be implemented, but requires a bunch - // of maths. - ESP_LOGE(kTag, "sample rate and bps mismatch"); - return; - } - - // Initialize system clock from the I2S BCK input - // Disable clock autoset and ignore SCK detection - WriteRegister(pcm512x::ERROR_DETECT, 0x1A); - // Set PLL clock source to BCK - WriteRegister(pcm512x::PLL_REF, 0x10); - // Set DAC clock source to PLL output - WriteRegister(pcm512x::DAC_REF, 0x10); - - // PLL configuration - int p, j, d, r; - - // Clock dividers - int nmac, ndac, ncp, dosr, idac; - - if (rate == SAMPLE_RATE_11_025 || rate == SAMPLE_RATE_22_05 || - rate == SAMPLE_RATE_44_1) { - // 44.1kHz and derivatives. - // P = 1, R = 2, D = 0 for all supported combinations. - // Set J to have PLL clk = 90.3168 MHz - p = 1; - r = 2; - j = 90316800 / bckFreq / r; - d = 0; - - // Derive clocks from the 90.3168MHz PLL - nmac = 2; - ndac = 16; - ncp = 4; - dosr = 8; - idac = 1024; // DSP clock / sample rate - } else { - // 8kHz and multiples. - // PLL config for a 98.304 MHz PLL clk - if (bps == BPS_24 && bckFreq > 1536000) { - p = 3; - } else if (bckFreq > 12288000) { - p = 2; - } else { - p = 1; - } - - r = 2; - j = 98304000 / (bckFreq / p) / r; - d = 0; - - // Derive clocks from the 98.304MHz PLL - switch (rate) { - case SAMPLE_RATE_16: - nmac = 6; - break; - case SAMPLE_RATE_32: - nmac = 3; - break; - default: - nmac = 2; - break; - } - - ndac = 16; - ncp = 4; - dosr = 384000 / rate; - idac = 98304000 / nmac / rate; // DSP clock / sample rate - } - - // Configure PLL - WriteRegister(pcm512x::PLL_COEFF_0, p - 1); - WriteRegister(pcm512x::PLL_COEFF_1, j); - WriteRegister(pcm512x::PLL_COEFF_2, (d >> 8) & 0x3F); - WriteRegister(pcm512x::PLL_COEFF_3, d & 0xFF); - WriteRegister(pcm512x::PLL_COEFF_4, r - 1); - - // Clock dividers - WriteRegister(pcm512x::DSP_CLKDIV, nmac - 1); - WriteRegister(pcm512x::DAC_CLKDIV, ndac - 1); - WriteRegister(pcm512x::NCP_CLKDIV, ncp - 1); - WriteRegister(pcm512x::OSR_CLKDIV, dosr - 1); - - // IDAC (nb of DSP clock cycles per sample) - WriteRegister(pcm512x::IDAC_1, (idac >> 8) & 0xFF); - WriteRegister(pcm512x::IDAC_2, idac & 0xFF); - - // FS speed mode - int speedMode; - if (rate <= SAMPLE_RATE_48) { - speedMode = 0; - } else if (rate <= SAMPLE_RATE_96) { - speedMode = 1; - } else if (rate <= SAMPLE_RATE_192) { - speedMode = 2; - } else { - speedMode = 3; - } - WriteRegister(pcm512x::FS_SPEED_MODE, speedMode); - - WriteRegister(pcm512x::I2S_1, (0b11 << 4) | bps_bits); - WriteRegister(pcm512x::I2S_2, 0); - - // Configuration is all done, so we can now bring the DAC and I2S stream back - // up. I2S first, since otherwise the DAC will see that there's no clocks and - // shut itself down. - ESP_ERROR_CHECK(i2s_channel_enable(i2s_handle_)); - WriteRegister(pcm512x::POWER, 0); - - if (i2s_active_) { - vTaskDelay(1); - WriteRegister(pcm512x::MUTE, 0); - } - i2s_active_ = true; -} - -auto AudioDac::WriteData(const cpp::span& data) -> void { - std::size_t bytes_written = 0; - esp_err_t err = i2s_channel_write(i2s_handle_, data.data(), data.size_bytes(), - &bytes_written, portMAX_DELAY); - if (err != ESP_ERR_TIMEOUT) { - ESP_ERROR_CHECK(err); - } -} - -extern "C" IRAM_ATTR auto callback(i2s_chan_handle_t handle, - i2s_event_data_t* event, - void* user_ctx) -> bool { - if (event == nullptr || user_ctx == nullptr) { - return false; - } - if (event->data == nullptr || event->size == 0) { - return false; - } - uint8_t** buf = reinterpret_cast(event->data); - StreamBufferHandle_t src = reinterpret_cast(user_ctx); - BaseType_t ret = false; - std::size_t bytes_received = - xStreamBufferReceiveFromISR(src, *buf, event->size, &ret); - if (bytes_received < event->size) { - memset(*buf + bytes_received, 0, event->size - bytes_received); - } - return ret; -} - -auto AudioDac::SetSource(StreamBufferHandle_t buffer) -> void { - if (i2s_active_) { - ESP_ERROR_CHECK(i2s_channel_disable(i2s_handle_)); - } - i2s_event_callbacks_t callbacks{ - .on_recv = NULL, - .on_recv_q_ovf = NULL, - .on_sent = NULL, - .on_send_q_ovf = NULL, - }; - if (buffer != nullptr) { - callbacks.on_sent = &callback; - } - i2s_channel_register_event_callback(i2s_handle_, &callbacks, buffer); - if (i2s_active_) { - ESP_ERROR_CHECK(i2s_channel_enable(i2s_handle_)); - } -} - -auto AudioDac::Stop() -> void { - LogStatus(); - WriteRegister(pcm512x::POWER, 1 << 4); - i2s_channel_disable(i2s_handle_); -} - -#define BYTE_TO_BINARY_PATTERN "%c%c%c%c%c%c%c%c" -#define BYTE_TO_BINARY(byte) \ - (byte & 0x80 ? '1' : '0'), (byte & 0x40 ? '1' : '0'), \ - (byte & 0x20 ? '1' : '0'), (byte & 0x10 ? '1' : '0'), \ - (byte & 0x08 ? '1' : '0'), (byte & 0x04 ? '1' : '0'), \ - (byte & 0x02 ? '1' : '0'), (byte & 0x01 ? '1' : '0') - -auto AudioDac::LogStatus() -> void { - uint8_t res; - - res = ReadRegister(pcm512x::RATE_DET_1); - ESP_LOGI(kTag, "detected sample rate (want 3): %u", (res & 0b01110000) >> 4); - ESP_LOGI(kTag, "detected SCK ratio (want 6): %u", res && 0b1111); - - res = ReadRegister(pcm512x::RATE_DET_3); - ESP_LOGI(kTag, "detected BCK (want... 16? 32?): %u", res); - - res = ReadRegister(pcm512x::RATE_DET_4); - ESP_LOGI(kTag, "clock errors (want zeroes): "); - ESP_LOGI(kTag, BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(res & 0b1111111)); - - res = ReadRegister(pcm512x::CLOCK_STATUS); - ESP_LOGI(kTag, "clock status (want zeroes): "); - ESP_LOGI(kTag, BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(res & 0b10111)); - - res = ReadRegister(pcm512x::DIGITAL_MUTE_DET); - ESP_LOGI(kTag, "automute status (want 0): %u", res & 0b10001); - - auto power = ReadPowerState(); - ESP_LOGI(kTag, "current power state (want 5): %u", power.second); -} - -void AudioDac::WriteRegister(pcm512x::Register r, uint8_t val) { - SelectPage(r.page); - WriteRegisterRaw(r.reg, val); -} - -uint8_t AudioDac::ReadRegister(pcm512x::Register r) { - SelectPage(r.page); - return ReadRegisterRaw(r.reg); -} - -void AudioDac::SelectPage(uint8_t page) { - if (active_page_ && active_page_ == page) { - return; - } - WriteRegisterRaw(0, page); - active_page_ = page; -} - -void AudioDac::WriteRegisterRaw(uint8_t reg, uint8_t val) { - I2CTransaction transaction; - transaction.start() - .write_addr(kPcm5122Address, I2C_MASTER_WRITE) - .write_ack(reg, val) - .stop(); - // TODO: Retry once? - transaction.Execute(); -} - -uint8_t AudioDac::ReadRegisterRaw(uint8_t reg) { - uint8_t result = 0; - I2CTransaction transaction; - transaction.start() - .write_addr(kPcm5122Address, I2C_MASTER_WRITE) - .write_ack(reg) - .start() - .write_addr(kPcm5122Address, I2C_MASTER_READ) - .read(&result, I2C_MASTER_NACK) - .stop(); - - transaction.Execute(); - return result; -} - -} // namespace drivers diff --git a/src/drivers/digital_pot.cpp b/src/drivers/digital_pot.cpp new file mode 100644 index 00000000..b20d982d --- /dev/null +++ b/src/drivers/digital_pot.cpp @@ -0,0 +1,85 @@ +/* + * Copyright 2023 jacqueline + * + * SPDX-License-Identifier: GPL-3.0-only + */ + +#include "digital_pot.hpp" + +#include + +namespace drivers { + +using GpioExpander::VOL_LEFT; +using GpioExpander::VOL_RIGHT; +using GpioExpander::VOL_UP_DOWN; +using GpioExpander::VOL_Z_CROSS; + +DigitalPot::DigitalPot(GpioExpander* gpios) : gpios_(gpios) { + gpios_->set_pin(VOL_Z_CROSS, true); // Active-low + gpios_->set_pin(VOL_UP_DOWN, true); + gpios_->set_pin(VOL_LEFT, false); + gpios_->set_pin(VOL_RIGHT, false); + gpios_->Write(); + + // Power-on reset sets attenuation to maximum anyway, but we want to be safe + // and not blow anyone's ears out. + for (int i = 0; i < 32; i++) { + gpios_->set_pin(VOL_LEFT, true); + gpios_->set_pin(VOL_RIGHT, true); + gpios_->Write(); + gpios_->set_pin(VOL_LEFT, false); + gpios_->set_pin(VOL_RIGHT, false); + gpios_->Write(); + } +} + +auto DigitalPot::SetRelative(int_fast8_t change) -> void { + if (change == 0) { + return; + } + + gpios_->set_pin(VOL_UP_DOWN, change > 0); + gpios_->Write(); + + for (int i = 0; i < std::abs(change); i++) { + gpios_->set_pin(VOL_LEFT, true); + gpios_->set_pin(VOL_RIGHT, true); + gpios_->Write(); + gpios_->set_pin(VOL_LEFT, false); + gpios_->set_pin(VOL_RIGHT, false); + gpios_->Write(); + } +} + +auto DigitalPot::SetRelative(Channel ch, int_fast8_t change) -> void { + if (change == 0) { + return; + } + + GpioExpander::Pin pin = (ch == Channel::kLeft) ? VOL_LEFT : VOL_RIGHT; + gpios_->set_pin(VOL_UP_DOWN, change > 0); + gpios_->Write(); + + for (int i = 0; i < std::abs(change); i++) { + gpios_->set_pin(pin, true); + gpios_->Write(); + gpios_->set_pin(pin, false); + gpios_->Write(); + } +} + +auto DigitalPot::SetZeroCrossDetect(bool enabled) -> void { + gpios_->set_pin(VOL_Z_CROSS, !enabled); // Active-low + gpios_->Write(); +} + +auto DigitalPot::GetMaxAttenuation() -> int_fast8_t { + return 31; +} + +auto DigitalPot::GetMinAttenuation() -> int_fast8_t { + return 0; +} + +} // namespace drivers diff --git a/src/drivers/i2s_dac.cpp b/src/drivers/i2s_dac.cpp new file mode 100644 index 00000000..68e92970 --- /dev/null +++ b/src/drivers/i2s_dac.cpp @@ -0,0 +1,202 @@ +/* + * Copyright 2023 jacqueline + * + * SPDX-License-Identifier: GPL-3.0-only + */ + +#include "i2s_dac.hpp" + +#include +#include + +#include "assert.h" +#include "driver/i2c.h" +#include "driver/i2s_common.h" +#include "driver/i2s_std.h" +#include "esp_attr.h" +#include "esp_err.h" +#include "esp_log.h" +#include "freertos/portmacro.h" +#include "freertos/projdefs.h" +#include "hal/gpio_types.h" +#include "hal/i2c_types.h" + +#include "gpio_expander.hpp" +#include "hal/i2s_types.h" +#include "i2c.hpp" +#include "soc/clk_tree_defs.h" +#include "sys/_stdint.h" + +namespace drivers { + +static const char* kTag = "i2s_dac"; +static const i2s_port_t kI2SPort = I2S_NUM_0; + +auto I2SDac::create(GpioExpander* expander) -> std::optional { + i2s_chan_handle_t i2s_handle; + i2s_chan_config_t channel_config = + I2S_CHANNEL_DEFAULT_CONFIG(kI2SPort, I2S_ROLE_MASTER); + + // Use the maximum possible DMA buffer size, since a smaller number of large + // copies is faster than a large number of small copies. + channel_config.dma_frame_num = 1024; + // Triple buffering should be enough to keep samples flowing smoothly. + // TODO(jacqueline): verify this with 192kHz 32bps. + channel_config.dma_desc_num = 4; + // channel_config.auto_clear = true; + + ESP_ERROR_CHECK(i2s_new_channel(&channel_config, &i2s_handle, NULL)); + // + // First, instantiate the instance so it can do all of its power on + // configuration. + std::unique_ptr dac = std::make_unique(expander, i2s_handle); + + // Whilst we wait for the initial boot, we can work on installing the I2S + // driver. + i2s_std_config_t i2s_config = { + .clk_cfg = dac->clock_config_, + .slot_cfg = dac->slot_config_, + .gpio_cfg = {.mclk = GPIO_NUM_0, + .bclk = GPIO_NUM_26, + .ws = GPIO_NUM_27, + .dout = GPIO_NUM_5, + .din = I2S_GPIO_UNUSED, + .invert_flags = + { + .mclk_inv = false, + .bclk_inv = false, + .ws_inv = true, + }}, + }; + + if (esp_err_t err = + i2s_channel_init_std_mode(i2s_handle, &i2s_config) != ESP_OK) { + ESP_LOGE(kTag, "failed to initialise i2s channel %x", err); + return {}; + } + + return dac.release(); +} + +I2SDac::I2SDac(GpioExpander* gpio, i2s_chan_handle_t i2s_handle) + : gpio_(gpio), + i2s_handle_(i2s_handle), + i2s_active_(false), + active_page_(), + clock_config_(I2S_STD_CLK_DEFAULT_CONFIG(44100)), + slot_config_(I2S_STD_MSB_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_16BIT, + I2S_SLOT_MODE_STEREO)) { + clock_config_.clk_src = I2S_CLK_SRC_PLL_160M; + gpio_->set_pin(GpioExpander::AMP_EN, false); + gpio_->Write(); +} + +I2SDac::~I2SDac() { + Stop(); + i2s_del_channel(i2s_handle_); +} + +auto I2SDac::Start() -> void { + gpio_->set_pin(GpioExpander::AMP_EN, true); + gpio_->Write(); + + vTaskDelay(pdMS_TO_TICKS(1)); + i2s_channel_enable(i2s_handle_); + + i2s_active_ = true; +} + +auto I2SDac::Stop() -> void { + i2s_channel_disable(i2s_handle_); + vTaskDelay(pdMS_TO_TICKS(1)); + + gpio_->set_pin(GpioExpander::AMP_EN, false); + gpio_->Write(); + + i2s_active_ = false; +} + +auto I2SDac::Reconfigure(BitsPerSample bps, SampleRate rate) -> void { + if (i2s_active_) { + i2s_channel_disable(i2s_handle_); + } + + uint8_t bps_bits = 0; + switch (bps) { + case BPS_16: + slot_config_.data_bit_width = I2S_DATA_BIT_WIDTH_16BIT; + bps_bits = 0; + break; + case BPS_24: + slot_config_.data_bit_width = I2S_DATA_BIT_WIDTH_24BIT; + bps_bits = 0b10; + break; + case BPS_32: + slot_config_.data_bit_width = I2S_DATA_BIT_WIDTH_32BIT; + bps_bits = 0b11; + break; + } + ESP_ERROR_CHECK(i2s_channel_reconfig_std_slot(i2s_handle_, &slot_config_)); + + clock_config_.sample_rate_hz = rate; + // If we have an MCLK/SCK, then it must be a multiple of both the sample rate + // and the bit clock. At 24 BPS, we therefore have to change the MCLK multiple + // to avoid issues at some sample rates. (e.g. 48KHz) + clock_config_.mclk_multiple = + bps == BPS_24 ? I2S_MCLK_MULTIPLE_384 : I2S_MCLK_MULTIPLE_256; + ESP_ERROR_CHECK(i2s_channel_reconfig_std_clock(i2s_handle_, &clock_config_)); + + if (i2s_active_) { + i2s_channel_enable(i2s_handle_); + } +} + +auto I2SDac::WriteData(const cpp::span& data) -> void { + std::size_t bytes_written = 0; + esp_err_t err = i2s_channel_write(i2s_handle_, data.data(), data.size_bytes(), + &bytes_written, portMAX_DELAY); + if (err != ESP_ERR_TIMEOUT) { + ESP_ERROR_CHECK(err); + } +} + +extern "C" IRAM_ATTR auto callback(i2s_chan_handle_t handle, + i2s_event_data_t* event, + void* user_ctx) -> bool { + if (event == nullptr || user_ctx == nullptr) { + return false; + } + if (event->data == nullptr || event->size == 0) { + return false; + } + uint8_t** buf = reinterpret_cast(event->data); + StreamBufferHandle_t src = reinterpret_cast(user_ctx); + BaseType_t ret = false; + std::size_t bytes_received = + xStreamBufferReceiveFromISR(src, *buf, event->size, &ret); + if (bytes_received < event->size) { + memset(*buf + bytes_received, 0, event->size - bytes_received); + } + return ret; +} + +auto I2SDac::SetSource(StreamBufferHandle_t buffer) -> void { + if (i2s_active_) { + ESP_ERROR_CHECK(i2s_channel_disable(i2s_handle_)); + } + i2s_event_callbacks_t callbacks{ + .on_recv = NULL, + .on_recv_q_ovf = NULL, + .on_sent = NULL, + .on_send_q_ovf = NULL, + }; + if (buffer != nullptr) { + callbacks.on_sent = &callback; + } + i2s_channel_register_event_callback(i2s_handle_, &callbacks, buffer); + if (i2s_active_) { + ESP_ERROR_CHECK(i2s_channel_enable(i2s_handle_)); + } +} + +} // namespace drivers diff --git a/src/drivers/include/dac.hpp b/src/drivers/include/dac.hpp deleted file mode 100644 index 22d6c855..00000000 --- a/src/drivers/include/dac.hpp +++ /dev/null @@ -1,204 +0,0 @@ -/* - * Copyright 2023 jacqueline - * - * SPDX-License-Identifier: GPL-3.0-only - */ - -#pragma once - -#include - -#include -#include -#include -#include - -#include "driver/i2s_std.h" -#include "driver/i2s_types.h" -#include "esp_err.h" -#include "freertos/FreeRTOS.h" -#include "freertos/portmacro.h" -#include "freertos/stream_buffer.h" -#include "result.hpp" -#include "span.hpp" - -#include "gpio_expander.hpp" -#include "sys/_stdint.h" - -namespace drivers { - -namespace pcm512x { -class Register { - public: - uint8_t page; - uint8_t reg; - - constexpr Register(uint8_t p, uint8_t r) : page(p), reg(r) {} -}; - -constexpr Register RESET(0, 1); -constexpr Register POWER(0, 2); -constexpr Register MUTE(0, 3); -constexpr Register PLL_EN(0, 4); -constexpr Register SPI_MISO_FUNCTION(0, 6); -constexpr Register DSP(0, 7); -constexpr Register GPIO_EN(0, 8); -constexpr Register BCLK_LRCLK_CFG(0, 9); -constexpr Register DSP_GPIO_INPUT(0, 10); -constexpr Register MASTER_MODE(0, 12); -constexpr Register PLL_REF(0, 13); -constexpr Register DAC_REF(0, 14); -constexpr Register GPIO_DACIN(0, 16); -constexpr Register GPIO_PLLIN(0, 18); -constexpr Register SYNCHRONIZE(0, 19); -constexpr Register PLL_COEFF_0(0, 20); -constexpr Register PLL_COEFF_1(0, 21); -constexpr Register PLL_COEFF_2(0, 22); -constexpr Register PLL_COEFF_3(0, 23); -constexpr Register PLL_COEFF_4(0, 24); -constexpr Register DSP_CLKDIV(0, 27); -constexpr Register DAC_CLKDIV(0, 28); -constexpr Register NCP_CLKDIV(0, 29); -constexpr Register OSR_CLKDIV(0, 30); -constexpr Register MASTER_CLKDIV_1(0, 32); -constexpr Register MASTER_CLKDIV_2(0, 33); -constexpr Register FS_SPEED_MODE(0, 34); -constexpr Register IDAC_1(0, 35); -constexpr Register IDAC_2(0, 36); -constexpr Register ERROR_DETECT(0, 37); -constexpr Register I2S_1(0, 40); -constexpr Register I2S_2(0, 41); -constexpr Register DAC_ROUTING(0, 42); -constexpr Register DSP_PROGRAM(0, 43); -constexpr Register CLKDET(0, 44); -constexpr Register AUTO_MUTE(0, 59); -constexpr Register DIGITAL_VOLUME_1(0, 60); -constexpr Register DIGITAL_VOLUME_2(0, 61); -constexpr Register DIGITAL_VOLUME_3(0, 62); -constexpr Register DIGITAL_MUTE_1(0, 63); -constexpr Register DIGITAL_MUTE_2(0, 64); -constexpr Register DIGITAL_MUTE_3(0, 65); -constexpr Register GPIO_OUTPUT_1(0, 80); -constexpr Register GPIO_OUTPUT_2(0, 81); -constexpr Register GPIO_OUTPUT_3(0, 82); -constexpr Register GPIO_OUTPUT_4(0, 83); -constexpr Register GPIO_OUTPUT_5(0, 84); -constexpr Register GPIO_OUTPUT_6(0, 85); -constexpr Register GPIO_CONTROL_1(0, 86); -constexpr Register GPIO_CONTROL_2(0, 87); -constexpr Register OVERFLOW(0, 90); -constexpr Register RATE_DET_1(0, 91); -constexpr Register RATE_DET_2(0, 92); -constexpr Register RATE_DET_3(0, 93); -constexpr Register RATE_DET_4(0, 94); -constexpr Register CLOCK_STATUS(0, 95); -constexpr Register ANALOG_MUTE_DET(0, 108); -constexpr Register POWER_STATE(0, 118); -constexpr Register GPIN(0, 119); -constexpr Register DIGITAL_MUTE_DET(0, 120); - -constexpr Register OUTPUT_AMPLITUDE(1, 1); -constexpr Register ANALOG_GAIN_CTRL(1, 2); -constexpr Register UNDERVOLTAGE_PROT(1, 5); -constexpr Register ANALOG_MUTE_CTRL(1, 6); -constexpr Register ANALOG_GAIN_BOOST(1, 7); -constexpr Register VCOM_CTRL_1(1, 8); -constexpr Register VCOM_CTRL_2(1, 9); - -constexpr Register CRAM_CTRL(44, 1); - -constexpr Register FLEX_A(253, 63); -constexpr Register FLEX_B(253, 64); - -} // namespace pcm512x - -/** - * Interface for a PCM5122PWR DAC, configured over I2C. - */ -class AudioDac { - public: - enum Error { - FAILED_TO_BOOT, - FAILED_TO_CONFIGURE, - FAILED_TO_INSTALL_I2S, - }; - - static auto create(GpioExpander* expander) -> cpp::result; - - AudioDac(GpioExpander* gpio, i2s_chan_handle_t i2s_handle); - ~AudioDac(); - - /** - * Sets the volume on a scale from 0 (loudest) to 254 (quietest). A value of - * 255 engages the soft mute function. - */ - void WriteVolume(uint8_t volume); - - enum PowerState { - POWERDOWN = 0b0, - WAIT_FOR_CP = 0b1, - CALIBRATION_1 = 0b10, - CALIBRATION_2 = 0b11, - RAMP_UP = 0b100, - RUN = 0b101, - SHORT = 0b110, - RAMP_DOWN = 0b111, - STANDBY = 0b1000, - }; - - /* Returns the current boot-up status and internal state of the DAC */ - std::pair ReadPowerState(); - - enum BitsPerSample { - BPS_16 = I2S_DATA_BIT_WIDTH_16BIT, - BPS_24 = I2S_DATA_BIT_WIDTH_24BIT, - BPS_32 = I2S_DATA_BIT_WIDTH_32BIT, - }; - enum SampleRate { - SAMPLE_RATE_11_025 = 11025, - SAMPLE_RATE_16 = 16000, - SAMPLE_RATE_22_05 = 22050, - SAMPLE_RATE_32 = 32000, - SAMPLE_RATE_44_1 = 44100, - SAMPLE_RATE_48 = 48000, - SAMPLE_RATE_96 = 96000, - SAMPLE_RATE_192 = 192000, - }; - - // TODO(jacqueline): worth supporting channels here as well? - auto Reconfigure(BitsPerSample bps, SampleRate rate) -> void; - - auto WriteData(const cpp::span& data) -> void; - auto SetSource(StreamBufferHandle_t buffer) -> void; - - auto Stop() -> void; - auto LogStatus() -> void; - - // Not copyable or movable. - AudioDac(const AudioDac&) = delete; - AudioDac& operator=(const AudioDac&) = delete; - - private: - GpioExpander* gpio_; - i2s_chan_handle_t i2s_handle_; - bool i2s_active_; - std::optional active_page_; - - i2s_std_clk_config_t clock_config_; - i2s_std_slot_config_t slot_config_; - - /* - * Pools the power state for up to 10ms, waiting for the given predicate to - * be true. - */ - bool WaitForPowerState(std::function predicate); - - void WriteRegister(pcm512x::Register r, uint8_t val); - uint8_t ReadRegister(pcm512x::Register r); - - void SelectPage(uint8_t page); - void WriteRegisterRaw(uint8_t reg, uint8_t val); - uint8_t ReadRegisterRaw(uint8_t reg); -}; - -} // namespace drivers diff --git a/src/drivers/include/digital_pot.hpp b/src/drivers/include/digital_pot.hpp new file mode 100644 index 00000000..e2ca00b1 --- /dev/null +++ b/src/drivers/include/digital_pot.hpp @@ -0,0 +1,49 @@ +/* + * Copyright 2023 jacqueline + * + * SPDX-License-Identifier: GPL-3.0-only + */ + +#pragma once + +#include +#include + +#include "esp_err.h" +#include "result.hpp" + +#include "gpio_expander.hpp" + +namespace drivers { + +/* + * Driver for a two-channel digital potentiometer, with steps measured in + * decibels. + */ +class DigitalPot { + public: + explicit DigitalPot(GpioExpander* gpios); + ~DigitalPot() {} + + // Not copyable or movable. + DigitalPot(const DigitalPot&) = delete; + DigitalPot& operator=(const DigitalPot&) = delete; + + enum class Channel { + kLeft, + kRight, + }; + + auto SetRelative(int_fast8_t change) -> void; + auto SetRelative(Channel ch, int_fast8_t change) -> void; + + auto SetZeroCrossDetect(bool enabled) -> void; + + auto GetMaxAttenuation() -> int_fast8_t; + auto GetMinAttenuation() -> int_fast8_t; + + private: + GpioExpander* gpios_; +}; + +} // namespace drivers diff --git a/src/drivers/include/gpio_expander.hpp b/src/drivers/include/gpio_expander.hpp index da682848..8231e140 100644 --- a/src/drivers/include/gpio_expander.hpp +++ b/src/drivers/include/gpio_expander.hpp @@ -56,12 +56,12 @@ class GpioExpander { static const uint8_t kPortADefault = 0b10111110; // Port B: - // 0 - trs output enable - // 1 - 3.5mm jack detect (active low) - // 2 - NC - // 3 - NC - // 4 - NC - // 5 - NC + // 0 - 3.5mm jack detect (active low) + // 1 - trs output enable + // 2 - volume zero-cross detection + // 3 - volume direction + // 4 - volume left channel + // 5 - volume right channel // 6 - NC // 7 - NC // Default input high, trs output low @@ -118,12 +118,12 @@ class GpioExpander { SD_CARD_POWER_ENABLE = 7, // Port B - AMP_EN = 8, - PHONE_DETECT = 9, - // UNUSED = 10, - // UNUSED = 11, - // UNUSED = 12, - // UNUSED = 13, + PHONE_DETECT = 8, + AMP_EN = 9, + VOL_Z_CROSS = 10, + VOL_UP_DOWN = 11, + VOL_LEFT = 12, + VOL_RIGHT = 13, // UNUSED = 14, // UNUSED = 15, }; diff --git a/src/drivers/include/i2s_dac.hpp b/src/drivers/include/i2s_dac.hpp new file mode 100644 index 00000000..42c094b1 --- /dev/null +++ b/src/drivers/include/i2s_dac.hpp @@ -0,0 +1,78 @@ +/* + * Copyright 2023 jacqueline + * + * SPDX-License-Identifier: GPL-3.0-only + */ + +#pragma once + +#include + +#include +#include +#include +#include + +#include "driver/i2s_std.h" +#include "driver/i2s_types.h" +#include "esp_err.h" +#include "freertos/FreeRTOS.h" +#include "freertos/portmacro.h" +#include "freertos/stream_buffer.h" +#include "result.hpp" +#include "span.hpp" + +#include "gpio_expander.hpp" +#include "sys/_stdint.h" + +namespace drivers { + +/** + * Interface for a DAC that receives PCM samples over I2S. + */ +class I2SDac { + public: + static auto create(GpioExpander* expander) -> std::optional; + + I2SDac(GpioExpander* gpio, i2s_chan_handle_t i2s_handle); + ~I2SDac(); + + auto Start() -> void; + auto Stop() -> void; + + enum BitsPerSample { + BPS_16 = I2S_DATA_BIT_WIDTH_16BIT, + BPS_24 = I2S_DATA_BIT_WIDTH_24BIT, + BPS_32 = I2S_DATA_BIT_WIDTH_32BIT, + }; + enum SampleRate { + SAMPLE_RATE_11_025 = 11025, + SAMPLE_RATE_16 = 16000, + SAMPLE_RATE_22_05 = 22050, + SAMPLE_RATE_32 = 32000, + SAMPLE_RATE_44_1 = 44100, + SAMPLE_RATE_48 = 48000, + SAMPLE_RATE_96 = 96000, + SAMPLE_RATE_192 = 192000, + }; + + auto Reconfigure(BitsPerSample bps, SampleRate rate) -> void; + + auto WriteData(const cpp::span& data) -> void; + auto SetSource(StreamBufferHandle_t buffer) -> void; + + // Not copyable or movable. + I2SDac(const I2SDac&) = delete; + I2SDac& operator=(const I2SDac&) = delete; + + private: + GpioExpander* gpio_; + i2s_chan_handle_t i2s_handle_; + bool i2s_active_; + std::optional active_page_; + + i2s_std_clk_config_t clock_config_; + i2s_std_slot_config_t slot_config_; +}; + +} // namespace drivers diff --git a/src/system_fsm/booting.cpp b/src/system_fsm/booting.cpp index b14da10c..e18a8e8d 100644 --- a/src/system_fsm/booting.cpp +++ b/src/system_fsm/booting.cpp @@ -63,14 +63,12 @@ auto Booting::entry() -> void { // booting. We will transition to the error state if these aren't present. ESP_LOGI(kTag, "installing required drivers"); sSamd.reset(drivers::Samd::Create()); - auto dac_res = drivers::AudioDac::create(sGpioExpander.get()); - if (dac_res.has_error() || !sSamd || !sRelativeTouch) { + if (!sSamd || !sRelativeTouch) { events::Dispatch( FatalError()); return; } - sDac.reset(dac_res.value()); // These drivers are initialised on boot, but are recoverable (if weird) if // they fail. @@ -79,7 +77,11 @@ auto Booting::entry() -> void { // All drivers are now loaded, so we can finish initing the other state // machines. - audio::AudioState::Init(sGpioExpander.get(), sDac, sDatabase); + if (!audio::AudioState::Init(sGpioExpander.get(), sDatabase)) { + events::Dispatch( + FatalError()); + return; + } events::Dispatch( BootComplete()); diff --git a/src/system_fsm/include/system_fsm.hpp b/src/system_fsm/include/system_fsm.hpp index 4413f64e..89cdcf47 100644 --- a/src/system_fsm/include/system_fsm.hpp +++ b/src/system_fsm/include/system_fsm.hpp @@ -10,7 +10,6 @@ #include "app_console.hpp" #include "battery.hpp" -#include "dac.hpp" #include "database.hpp" #include "display.hpp" #include "gpio_expander.hpp" @@ -56,7 +55,6 @@ class SystemState : public tinyfsm::Fsm { static std::shared_ptr sBattery; static std::shared_ptr sStorage; static std::shared_ptr sDisplay; - static std::shared_ptr sDac; static std::shared_ptr sDatabase; }; diff --git a/src/system_fsm/system_fsm.cpp b/src/system_fsm/system_fsm.cpp index eb7cce52..bcab298c 100644 --- a/src/system_fsm/system_fsm.cpp +++ b/src/system_fsm/system_fsm.cpp @@ -18,7 +18,6 @@ std::shared_ptr SystemState::sRelativeTouch; std::shared_ptr SystemState::sBattery; std::shared_ptr SystemState::sStorage; std::shared_ptr SystemState::sDisplay; -std::shared_ptr SystemState::sDac; std::shared_ptr SystemState::sDatabase; void SystemState::react(const FatalError& err) { diff --git a/src/ui/include/ui_fsm.hpp b/src/ui/include/ui_fsm.hpp index dda8e447..da6263b7 100644 --- a/src/ui/include/ui_fsm.hpp +++ b/src/ui/include/ui_fsm.hpp @@ -22,8 +22,8 @@ namespace ui { class UiState : public tinyfsm::Fsm { public: static auto Init(drivers::GpioExpander* gpio_expander, - const std::weak_ptr &touchwheel, - const std::weak_ptr &display) -> void; + const std::weak_ptr& touchwheel, + const std::weak_ptr& display) -> void; virtual ~UiState() {} diff --git a/src/ui/ui_fsm.cpp b/src/ui/ui_fsm.cpp index 1bc7ddb8..5c59cf22 100644 --- a/src/ui/ui_fsm.cpp +++ b/src/ui/ui_fsm.cpp @@ -42,8 +42,7 @@ void PreBoot::react(const system_fsm::DisplayReady& ev) { transit(); } -void Splash::entry() { -} +void Splash::entry() {} void Splash::react(const system_fsm::BootComplete& ev) { transit();