MightyPork
/
tangara-fw
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

standardise on formatting

Browse Source
custom
jacqueline 3 years ago
parent efd5392f6c
commit 3726fb750a
13 changed files with 480 additions and 467 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 5
      .clang-format
  2. 17
      main/CMakeLists.txt
  3. 6
      main/battery.cpp
  4. 2
      main/battery.h
  5. 56
      main/dac.cpp
  6. 98
      main/dac.h
  7. 146
      main/gay-ipod-fw.cpp
  8. 30
      main/gpio-expander.cpp
  9. 363
      main/gpio-expander.h
  10. 4
      main/i2c.cpp
  11. 109
      main/i2c.h
  12. 19
      main/storage.cpp
  13. 92
      main/storage.h

5
.clang-format
Unescape View File

@ -0,0 +1,5 @@
---
BasedOnStyle: Chromium
UseTab: Never
...

17
main/CMakeLists.txt
Unescape View File

@ -1,5 +1,12 @@
idf_component_register(
SRCS "gay-ipod-fw.cpp" "dac.cpp" "gpio-expander.cpp" "battery.cpp" "storage.cpp" "i2c.cpp"
INCLUDE_DIRS "."
REQUIRES "esp_adc_cal" "fatfs" "audio_pipeline" "audio_stream" "result"
)
idf_component_register(SRCS
"gay-ipod-fw.cpp"
"dac.cpp"
"gpio-expander.cpp"
"battery.cpp"
"storage.cpp"
"i2c.cpp" INCLUDE_DIRS "." REQUIRES
"esp_adc_cal"
"fatfs"
"audio_pipeline"
"audio_stream"
"result")

6
main/battery.cpp
Unescape View File

@ -11,8 +11,8 @@ static esp_adc_cal_characteristics_t calibration;
esp_err_t init_adc(void) {
// Calibration should already be fused into the chip from the factory, so
// we should only need to read it back out again.
esp_adc_cal_characterize(
ADC_UNIT_1, ADC_ATTEN_DB_11, ADC_WIDTH_BIT_12, 0, &calibration);
esp_adc_cal_characterize(ADC_UNIT_1, ADC_ATTEN_DB_11, ADC_WIDTH_BIT_12, 0,
&calibration);
// Max battery voltage should be a little over 2V due to our divider, so
// we need the max attenuation to properly handle the full range.
@ -28,4 +28,4 @@ uint32_t read_battery_voltage(void) {
return esp_adc_cal_raw_to_voltage(raw, &calibration);
}
} // namespace gay_ipod
} // namespace gay_ipod

2
main/battery.h
Unescape View File

@ -13,4 +13,4 @@ esp_err_t init_adc(void);
*/
uint32_t read_battery_voltage(void);
} // namespace gay_ipod
} // namespace gay_ipod

56
main/dac.cpp
Unescape View File

@ -1,26 +1,27 @@
#include "dac.h"
#include "esp_err.h"
#include "i2c.h"
#include "esp_log.h"
#include <cstdint>
#include "assert.h"
#include "driver/i2c.h"
#include "esp_err.h"
#include "esp_log.h"
#include "gpio-expander.h"
#include "hal/i2c_types.h"
#include <cstdint>
#include "i2c.h"
namespace gay_ipod {
static const char* TAG = "AUDIODAC";
AudioDac::AudioDac(GpioExpander *gpio) {
AudioDac::AudioDac(GpioExpander* gpio) {
this->gpio_ = gpio;
};
AudioDac::~AudioDac() {};
AudioDac::~AudioDac(){};
esp_err_t AudioDac::Start() {
bool is_booted = WaitForPowerState([](bool booted, PowerState state){ return booted; });
bool is_booted =
WaitForPowerState([](bool booted, PowerState state) { return booted; });
if (!is_booted) {
ESP_LOGE(TAG, "Timed out waiting for boot");
return ESP_ERR_TIMEOUT;
@ -29,8 +30,9 @@ esp_err_t AudioDac::Start() {
WriteRegister(Register::DE_EMPHASIS, 1 << 4);
WriteVolume(100);
WaitForPowerState([](bool booted, PowerState state){
return state == WAIT_FOR_CP || state == RAMP_UP || state == RUN || state == STANDBY;
WaitForPowerState([](bool booted, PowerState state) {
return state == WAIT_FOR_CP || state == RAMP_UP || state == RUN ||
state == STANDBY;
});
return ESP_OK;
@ -45,31 +47,32 @@ std::pair<bool, AudioDac::PowerState> AudioDac::ReadPowerState() {
uint8_t result = 0;
I2CTransaction transaction;
transaction
.start()
.write_addr(kPCM5122Address, I2C_MASTER_WRITE)
.write_ack(DSP_BOOT_POWER_STATE)
.start()
.write_addr(kPCM5122Address, I2C_MASTER_READ)
.read(&result, I2C_MASTER_NACK)
.stop();
transaction.start()
.write_addr(kPCM5122Address, I2C_MASTER_WRITE)
.write_ack(DSP_BOOT_POWER_STATE)
.start()
.write_addr(kPCM5122Address, I2C_MASTER_READ)
.read(&result, I2C_MASTER_NACK)
.stop();
ESP_ERROR_CHECK(transaction.Execute());
bool is_booted = result >> 7;
PowerState detail = (PowerState) (result & 0b1111);
PowerState detail = (PowerState)(result & 0b1111);
return std::pair(is_booted, detail);
}
bool AudioDac::WaitForPowerState(std::function<bool(bool,AudioDac::PowerState)> predicate) {
bool AudioDac::WaitForPowerState(
std::function<bool(bool, AudioDac::PowerState)> predicate) {
bool has_matched = false;
for (int i=0; i<10; i++) {
for (int i = 0; i < 10; i++) {
std::pair<bool, PowerState> result = ReadPowerState();
has_matched = predicate(result.first, result.second);
if (has_matched) {
break;
} else {
ESP_LOGI(TAG, "Waiting for power state (was %d %x)", result.first, (uint8_t) result.second);
ESP_LOGI(TAG, "Waiting for power state (was %d %x)", result.first,
(uint8_t)result.second);
vTaskDelay(pdMS_TO_TICKS(1));
}
}
@ -77,14 +80,13 @@ bool AudioDac::WaitForPowerState(std::function<bool(bool,AudioDac::PowerState)>
}
void AudioDac::WriteRegister(Register reg, uint8_t val) {
I2CTransaction transaction;
transaction
.start()
I2CTransaction transaction;
transaction.start()
.write_addr(kPCM5122Address, I2C_MASTER_WRITE)
.write_ack(reg, val)
.stop();
// TODO: Retry once?
ESP_ERROR_CHECK(transaction.Execute());
// TODO: Retry once?
ESP_ERROR_CHECK(transaction.Execute());
}
} // namespace gay_ipod
} // namespace gay_ipod

98
main/dac.h
Unescape View File

@ -1,72 +1,72 @@
#pragma once
#include "esp_err.h"
#include "gpio-expander.h"
#include <stdint.h>
#include <functional>
#include "esp_err.h"
#include "gpio-expander.h"
namespace gay_ipod {
static const uint8_t kPCM5122Address = 0x4C;
static const uint8_t kPCM5122Timeout = 100 / portTICK_RATE_MS;
static const uint8_t kPCM5122Address = 0x4C;
static const uint8_t kPCM5122Timeout = 100 / portTICK_RATE_MS;
/**
* Interface for a PCM5122PWR DAC, configured over I2C.
*/
class AudioDac {
public:
AudioDac(GpioExpander *gpio);
~AudioDac();
public:
AudioDac(GpioExpander* gpio);
~AudioDac();
/**
* Performs initial configuration of the DAC and sets it to begin expecting
* I2S audio data.
*/
esp_err_t Start();
/**
* Performs initial configuration of the DAC and sets it to begin expecting
* I2S audio data.
*/
esp_err_t Start();
/**
* 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);
/**
* 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,
};
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<bool,PowerState> ReadPowerState();
/* Returns the current boot-up status and internal state of the DAC */
std::pair<bool, PowerState> ReadPowerState();
// Not copyable or movable.
AudioDac(const AudioDac&) = delete;
AudioDac& operator=(const AudioDac&) = delete;
// Not copyable or movable.
AudioDac(const AudioDac&) = delete;
AudioDac& operator=(const AudioDac&) = delete;
private:
GpioExpander *gpio_;
private:
GpioExpander* gpio_;
/*
* Pools the power state for up to 10ms, waiting for the given predicate to
* be true.
*/
bool WaitForPowerState(std::function<bool(bool,PowerState)> predicate);
/*
* Pools the power state for up to 10ms, waiting for the given predicate to
* be true.
*/
bool WaitForPowerState(std::function<bool(bool, PowerState)> predicate);
enum Register {
PAGE_SELECT = 0,
DE_EMPHASIS = 7,
DIGITAL_VOLUME_L = 61,
DIGITAL_VOLUME_R = 62,
DSP_BOOT_POWER_STATE = 118,
};
enum Register {
PAGE_SELECT = 0,
DE_EMPHASIS = 7,
DIGITAL_VOLUME_L = 61,
DIGITAL_VOLUME_R = 62,
DSP_BOOT_POWER_STATE = 118,
};
void WriteRegister(Register reg, uint8_t val);
void WriteRegister(Register reg, uint8_t val);
};
} // namespace gay_ipod
} // namespace gay_ipod

146
main/gay-ipod-fw.cpp
Unescape View File

@ -1,6 +1,6 @@
#include <cstdint>
#include <stdio.h>
#include <dirent.h>
#include <stdio.h>
#include <cstdint>
#include "battery.h"
#include "dac.h"
@ -21,9 +21,9 @@
#include "hal/spi_types.h"
#include "storage.h"
#include "audio_common.h"
#include "audio_element.h"
#include "audio_pipeline.h"
#include "audio_common.h"
#include "fatfs_stream.h"
#include "i2s_stream.h"
#include "mp3_decoder.h"
@ -48,16 +48,17 @@ static const char* TAG = "MAIN";
esp_err_t init_i2c(void) {
i2c_port_t port = I2C_NUM_0;
i2c_config_t config = {
.mode = I2C_MODE_MASTER,
.sda_io_num = I2C_SDA_IO,
.scl_io_num = I2C_SCL_IO,
.sda_pullup_en = GPIO_PULLUP_ENABLE,
.scl_pullup_en = GPIO_PULLUP_ENABLE,
.master = {
.clk_speed = I2C_CLOCK_HZ,
},
// No requirements for the clock.
.clk_flags = 0,
.mode = I2C_MODE_MASTER,
.sda_io_num = I2C_SDA_IO,
.scl_io_num = I2C_SCL_IO,
.sda_pullup_en = GPIO_PULLUP_ENABLE,
.scl_pullup_en = GPIO_PULLUP_ENABLE,
.master =
{
.clk_speed = I2C_CLOCK_HZ,
},
// No requirements for the clock.
.clk_flags = 0,
};
ESP_ERROR_CHECK(i2c_param_config(port, &config));
@ -70,22 +71,22 @@ esp_err_t init_i2c(void) {
esp_err_t init_spi(void) {
spi_bus_config_t config = {
.mosi_io_num = SPI_SDO_IO,
.miso_io_num = SPI_SDI_IO,
.sclk_io_num = SPI_SCLK_IO,
.quadwp_io_num = SPI_QUADWP_IO,
.quadhd_io_num = SPI_QUADHD_IO,
// Unused
.data4_io_num = -1,
.data5_io_num = -1,
.data6_io_num = -1,
.data7_io_num = -1,
// Use the DMA default size.
.max_transfer_sz = 0,
.flags = SPICOMMON_BUSFLAG_MASTER | SPICOMMON_BUSFLAG_IOMUX_PINS,
.intr_flags = 0,
.mosi_io_num = SPI_SDO_IO,
.miso_io_num = SPI_SDI_IO,
.sclk_io_num = SPI_SCLK_IO,
.quadwp_io_num = SPI_QUADWP_IO,
.quadhd_io_num = SPI_QUADHD_IO,
// Unused
.data4_io_num = -1,
.data5_io_num = -1,
.data6_io_num = -1,
.data7_io_num = -1,
// Use the DMA default size.
.max_transfer_sz = 0,
.flags = SPICOMMON_BUSFLAG_MASTER | SPICOMMON_BUSFLAG_IOMUX_PINS,
.intr_flags = 0,
};
ESP_ERROR_CHECK(spi_bus_initialize(VSPI_HOST, &config, SPI_DMA_CH_AUTO));
@ -93,8 +94,7 @@ esp_err_t init_spi(void) {
return ESP_OK;
}
extern "C" void app_main(void)
{
extern "C" void app_main(void) {
ESP_LOGI(TAG, "Initialising peripherals");
ESP_ERROR_CHECK(gpio_install_isr_service(ESP_INTR_FLAG_LOWMED));
@ -105,7 +105,7 @@ extern "C" void app_main(void)
gay_ipod::GpioExpander expander;
// for debugging usb ic
//expander.set_sd_mux(gay_ipod::GpioExpander::USB);
// expander.set_sd_mux(gay_ipod::GpioExpander::USB);
ESP_LOGI(TAG, "Init ADC");
ESP_ERROR_CHECK(gay_ipod::init_adc());
@ -132,72 +132,72 @@ extern "C" void app_main(void)
i2s_port_t port = I2S_NUM_0;
i2s_config_t i2s_config = {
// Weird enum usage in ESP IDF.
.mode = static_cast<i2s_mode_t>(I2S_MODE_MASTER | I2S_MODE_TX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
.channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
.communication_format = I2S_COMM_FORMAT_STAND_I2S,
.intr_alloc_flags = ESP_INTR_FLAG_LOWMED,
.dma_buf_count = 8,
.dma_buf_len = 64,
.use_apll = false,
.tx_desc_auto_clear = false,
.fixed_mclk = 0,
.mclk_multiple = I2S_MCLK_MULTIPLE_DEFAULT,
.bits_per_chan = I2S_BITS_PER_CHAN_DEFAULT,
// Weird enum usage in ESP IDF.
.mode = static_cast<i2s_mode_t>(I2S_MODE_MASTER | I2S_MODE_TX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
.channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
.communication_format = I2S_COMM_FORMAT_STAND_I2S,
.intr_alloc_flags = ESP_INTR_FLAG_LOWMED,
.dma_buf_count = 8,
.dma_buf_len = 64,
.use_apll = false,
.tx_desc_auto_clear = false,
.fixed_mclk = 0,
.mclk_multiple = I2S_MCLK_MULTIPLE_DEFAULT,
.bits_per_chan = I2S_BITS_PER_CHAN_DEFAULT,
};
//ESP_ERROR_CHECK(i2s_driver_install(port, &i2s_config, 0, NULL));
// ESP_ERROR_CHECK(i2s_driver_install(port, &i2s_config, 0, NULL));
audio_pipeline_handle_t pipeline;
audio_element_handle_t fatfs_stream_reader, i2s_stream_writer, audio_decoder;
audio_pipeline_cfg_t pipeline_config = audio_pipeline_cfg_t(DEFAULT_AUDIO_PIPELINE_CONFIG());
audio_pipeline_cfg_t pipeline_config =
audio_pipeline_cfg_t(DEFAULT_AUDIO_PIPELINE_CONFIG());
pipeline = audio_pipeline_init(&pipeline_config);
assert(pipeline != NULL);
ESP_LOGI(TAG, "Made pipeline okay.");
fatfs_stream_cfg_t fatfs_stream_config = fatfs_stream_cfg_t(FATFS_STREAM_CFG_DEFAULT());
fatfs_stream_cfg_t fatfs_stream_config =
fatfs_stream_cfg_t(FATFS_STREAM_CFG_DEFAULT());
fatfs_stream_config.type = AUDIO_STREAM_READER;
fatfs_stream_reader = fatfs_stream_init(&fatfs_stream_config);
assert(fatfs_stream_reader != NULL);
ESP_LOGI(TAG, "Made reader okay.");
i2s_stream_cfg_t i2s_stream_config = i2s_stream_cfg_t{
.type = AUDIO_STREAM_WRITER,
.i2s_config = i2s_config,
.i2s_port = port,
.use_alc = false,
.volume = 0, // Does nothing; use the dac
.out_rb_size = I2S_STREAM_RINGBUFFER_SIZE,
.task_stack = I2S_STREAM_TASK_STACK,
.task_core = I2S_STREAM_TASK_CORE,
.task_prio = I2S_STREAM_TASK_PRIO,
.stack_in_ext = false,
.multi_out_num = 0,
.uninstall_drv = true,
.need_expand = false,
.expand_src_bits = I2S_BITS_PER_SAMPLE_16BIT,
.type = AUDIO_STREAM_WRITER,
.i2s_config = i2s_config,
.i2s_port = port,
.use_alc = false,
.volume = 0, // Does nothing; use the dac
.out_rb_size = I2S_STREAM_RINGBUFFER_SIZE,
.task_stack = I2S_STREAM_TASK_STACK,
.task_core = I2S_STREAM_TASK_CORE,
.task_prio = I2S_STREAM_TASK_PRIO,
.stack_in_ext = false,
.multi_out_num = 0,
.uninstall_drv = true,
.need_expand = false,
.expand_src_bits = I2S_BITS_PER_SAMPLE_16BIT,
};
// TODO fix hardcoded mclk :(
i2s_stream_writer = i2s_stream_init(&i2s_stream_config);
assert(i2s_stream_writer != NULL);
ESP_LOGI(TAG, "Made i2s stream okay.");
ESP_LOGI(TAG, "Init i2s pins");
i2s_pin_config_t pin_config = {
.mck_io_num = GPIO_NUM_0,
.bck_io_num = GPIO_NUM_26,
.ws_io_num = GPIO_NUM_27,
.data_out_num = GPIO_NUM_5,
.data_in_num = I2S_PIN_NO_CHANGE
};
i2s_pin_config_t pin_config = {.mck_io_num = GPIO_NUM_0,
.bck_io_num = GPIO_NUM_26,
.ws_io_num = GPIO_NUM_27,
.data_out_num = GPIO_NUM_5,
.data_in_num = I2S_PIN_NO_CHANGE};
ESP_ERROR_CHECK(i2s_set_pin(port, &pin_config));
mp3_decoder_cfg_t decoder_config = mp3_decoder_cfg_t(DEFAULT_MP3_DECODER_CONFIG());
mp3_decoder_cfg_t decoder_config =
mp3_decoder_cfg_t(DEFAULT_MP3_DECODER_CONFIG());
audio_decoder = mp3_decoder_init(&decoder_config);
assert(audio_decoder != NULL);
ESP_LOGI(TAG, "Made mp3 decoder okay.");
@ -209,7 +209,7 @@ extern "C" void app_main(void)
audio_pipeline_register(pipeline, audio_decoder, "dec");
audio_pipeline_register(pipeline, i2s_stream_writer, "i2s");
const char *link_tag[3] = {"file", "dec", "i2s"};
const char* link_tag[3] = {"file", "dec", "i2s"};
audio_pipeline_link(pipeline, &link_tag[0], 3);
ESP_LOGI(TAG, "Trying to play something??");

30
main/gpio-expander.cpp
Unescape View File

@ -32,9 +32,9 @@ esp_err_t GpioExpander::Write() {
I2CTransaction transaction;
transaction.start()
.write_addr(kPca8575Address, I2C_MASTER_WRITE)
.write_ack(ports_ab.first, ports_ab.second)
.stop();
.write_addr(kPca8575Address, I2C_MASTER_WRITE)
.write_ack(ports_ab.first, ports_ab.second)
.stop();
return transaction.Execute();
}
@ -44,10 +44,10 @@ esp_err_t GpioExpander::Read() {
I2CTransaction transaction;
transaction.start()
.write_addr(kPca8575Address, I2C_MASTER_READ)
.read(&input_a, I2C_MASTER_ACK)
.read(&input_b, I2C_MASTER_LAST_NACK)
.stop();
.write_addr(kPca8575Address, I2C_MASTER_READ)
.read(&input_a, I2C_MASTER_ACK)
.read(&input_b, I2C_MASTER_LAST_NACK)
.stop();
esp_err_t ret = transaction.Execute();
inputs_ = pack(input_a, input_b);
@ -55,7 +55,7 @@ esp_err_t GpioExpander::Read() {
}
void GpioExpander::set_pin(ChipSelect cs, bool value) {
set_pin((Pin) cs, value);
set_pin((Pin)cs, value);
}
void GpioExpander::set_pin(Pin pin, bool value) {
@ -75,16 +75,12 @@ GpioExpander::SpiLock GpioExpander::AcquireSpiBus(ChipSelect cs) {
}
GpioExpander::SpiLock::SpiLock(GpioExpander& gpio, ChipSelect cs)
: lock_(gpio.cs_mutex_), gpio_(gpio), cs_(cs) {
gpio_.with([&](auto& gpio) {
gpio.set_pin(cs_, 0);
});
: lock_(gpio.cs_mutex_), gpio_(gpio), cs_(cs) {
gpio_.with([&](auto& gpio) { gpio.set_pin(cs_, 0); });
}
GpioExpander::SpiLock::~SpiLock() {
gpio_.with([&](auto& gpio) {
gpio.set_pin(cs_, 1);
});
GpioExpander::SpiLock::~SpiLock() {
gpio_.with([&](auto& gpio) { gpio.set_pin(cs_, 1); });
}
} // namespace gay_ipod
} // namespace gay_ipod

363
main/gpio-expander.h
Unescape View File

@ -1,16 +1,16 @@
#pragma once
#include <stdint.h>
#include <atomic>
#include <functional>
#include <mutex>
#include <stdint.h>
#include <tuple>
#include <utility>
#include "driver/i2c.h"
#include "esp_check.h"
#include "esp_log.h"
#include "esp_err.h"
#include "driver/i2c.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
namespace gay_ipod {
@ -26,184 +26,183 @@ namespace gay_ipod {
* should be done whilst holding `cs_lock` (preferably via the helper methods).
*/
class GpioExpander {
public:
GpioExpander();
~GpioExpander();
static const uint8_t kPca8575Address = 0x20;
static const uint8_t kPca8575Timeout = 100 / portTICK_RATE_MS;
// Port A:
// 0 - audio power enable
// 1 - usb interface power enable
// 2 - display power enable
// 3 - sd card power enable
// 4 - charge power ok (active low)
// 5 - sd mux switch
// 6 - sd chip select
// 7 - display chip select
// All power switches low, chip selects high, active-low charge power high
static const uint8_t kPortADefault = 0b11010001;
// Port B:
// 0 - 3.5mm jack detect (active low)
// 1 - dac soft mute switch
// 2 - GPIO
// 3 - GPIO
// 4 - GPIO
// 5 - GPIO
// 6 - GPIO
// 7 - GPIO
// DAC mute output low, everything else is active-low inputs.
static const uint8_t kPortBDefault = 0b11111111;
/*
* Convenience mehod for packing the port a and b bytes into a single 16 bit
* value.
*/
static uint16_t pack(uint8_t a, uint8_t b) {
return ((uint16_t) b) << 8 | a;
}
/*
* Convenience mehod for unpacking the result of `pack` back into two single
* byte port datas.
*/
static std::pair<uint8_t, uint8_t> unpack(uint16_t ba) {
return std::pair((uint8_t) ba, (uint8_t) (ba >> 8));
}
/*
* Convenience function for running some arbitrary pin writing code, then
* flushing a `Write()` to the expander. Example usage:
*
* ```
* gpio_.with([&](auto& gpio) {
* gpio.set_pin(AUDIO_POWER_ENABLE, true);
* });
* ```
*/
void with(std::function<void(GpioExpander&)> f);
/**
* Sets the ports on the GPIO expander to the values currently represented
* in `ports`.
*/
esp_err_t Write(void);
/**
* Reads from the GPIO expander, populating `inputs` with the most recent
* values.
*/
esp_err_t Read(void);
/* Maps each pin of the expander to its number in a `pack`ed uint16. */
enum Pin {
// Port A
AUDIO_POWER_ENABLE = 0,
USB_INTERFACE_POWER_ENABLE = 1,
DISPLAY_POWER_ENABLE = 2,
SD_CARD_POWER_ENABLE = 3,
CHARGE_POWER_OK = 4, // Active-low input
SD_MUX_SWITCH = 5,
SD_CHIP_SELECT = 6,
DISPLAY_CHIP_SELECT = 7,
// Port B
PHONE_DETECT = 8, // Active-high input
DAC_MUTE = 9,
GPIO_1 = 10,
GPIO_2 = 11,
GPIO_3 = 12,
GPIO_4 = 13,
GPIO_5 = 14,
GPIO_6 = 15,
};
/* Pins whose access should be guarded by `cs_lock`. */
enum ChipSelect {
SD_CARD = SD_CHIP_SELECT,
DISPLAY = DISPLAY_CHIP_SELECT,
};
/* Nicer value names for use with the SD_MUX_SWITCH pin. */
enum SdController {
SD_MUX_ESP = 0,
SD_MUX_USB = 1,
};
/**
* Returns the current driven status of each of the ports. The first byte is
* port a, and the second byte is port b.
*/
std::atomic<uint16_t>& ports() { return ports_; }
/*
* Sets a single specific pin to the given value. `true` corresponds to
* HIGH, and `false` corresponds to LOW.
*
* Calls to this method will be buffered in memory until a call to `Write()`
* is made.
*/
void set_pin(Pin pin, bool value);
void set_pin(ChipSelect cs, bool value);
/**
* Returns the input status of each of the ports. The first byte is port a,
* and the second byte is port b.
*/
const std::atomic<uint16_t>& inputs() const { return inputs_; }
/* Returns the most recently cached value of the given pin. Only valid for
* pins used as inputs; to check what value we're driving a pin, use
* `ports()`.
*/
bool get_input(Pin pin) const;
/* Returns the mutex that must be held whilst pulling a CS pin low. */
std::mutex& cs_mutex() { return cs_mutex_; }
/*
* Helper class containing an active `cs_mutex` lock. When an instance of
* this class is destroyed (usually by falling out of scope), the associated
* CS pin will be driven high before the lock is released.
*/
class SpiLock {
public:
SpiLock(GpioExpander &gpio, ChipSelect cs);
~SpiLock();
SpiLock(const SpiLock&) = delete;
private:
std::scoped_lock<std::mutex> lock_;
GpioExpander &gpio_;
ChipSelect cs_;
};
/*
* Pulls the given CS pin low to signal that we are about to communicate
* with a particular device, after acquiring a lock on `cs_mutex`. The
* recommended way to safely interact with devices on the SPI bus is to have
* a self-contained block like so:
*
* ```
* {
* auto lock = AcquireSpiBus(WHATEVER);
* // Do some cool things here.
* }
* ```
*/
SpiLock AcquireSpiBus(ChipSelect cs);
// Not copyable or movable. There should usually only ever be once instance
// of this class, and that instance will likely have a static lifetime.
GpioExpander(const GpioExpander&) = delete;
GpioExpander& operator=(const GpioExpander&) = delete;
private:
std::mutex cs_mutex_;
std::atomic<uint16_t> ports_;
std::atomic<uint16_t> inputs_;
public:
GpioExpander();
~GpioExpander();
static const uint8_t kPca8575Address = 0x20;
static const uint8_t kPca8575Timeout = 100 / portTICK_RATE_MS;
// Port A:
// 0 - audio power enable
// 1 - usb interface power enable
// 2 - display power enable
// 3 - sd card power enable
// 4 - charge power ok (active low)
// 5 - sd mux switch
// 6 - sd chip select
// 7 - display chip select
// All power switches low, chip selects high, active-low charge power high
static const uint8_t kPortADefault = 0b11010001;
// Port B:
// 0 - 3.5mm jack detect (active low)
// 1 - dac soft mute switch
// 2 - GPIO
// 3 - GPIO
// 4 - GPIO
// 5 - GPIO
// 6 - GPIO
// 7 - GPIO
// DAC mute output low, everything else is active-low inputs.
static const uint8_t kPortBDefault = 0b11111111;
/*
* Convenience mehod for packing the port a and b bytes into a single 16 bit
* value.
*/
static uint16_t pack(uint8_t a, uint8_t b) { return ((uint16_t)b) << 8 | a; }
/*
* Convenience mehod for unpacking the result of `pack` back into two single
* byte port datas.
*/
static std::pair<uint8_t, uint8_t> unpack(uint16_t ba) {
return std::pair((uint8_t)ba, (uint8_t)(ba >> 8));
}
/*
* Convenience function for running some arbitrary pin writing code, then
* flushing a `Write()` to the expander. Example usage:
*
* ```
* gpio_.with([&](auto& gpio) {
* gpio.set_pin(AUDIO_POWER_ENABLE, true);
* });
* ```
*/
void with(std::function<void(GpioExpander&)> f);
/**
* Sets the ports on the GPIO expander to the values currently represented
* in `ports`.
*/
esp_err_t Write(void);
/**
* Reads from the GPIO expander, populating `inputs` with the most recent
* values.
*/
esp_err_t Read(void);
/* Maps each pin of the expander to its number in a `pack`ed uint16. */
enum Pin {
// Port A
AUDIO_POWER_ENABLE = 0,
USB_INTERFACE_POWER_ENABLE = 1,
DISPLAY_POWER_ENABLE = 2,
SD_CARD_POWER_ENABLE = 3,
CHARGE_POWER_OK = 4, // Active-low input
SD_MUX_SWITCH = 5,
SD_CHIP_SELECT = 6,
DISPLAY_CHIP_SELECT = 7,
// Port B
PHONE_DETECT = 8, // Active-high input
DAC_MUTE = 9,
GPIO_1 = 10,
GPIO_2 = 11,
GPIO_3 = 12,
GPIO_4 = 13,
GPIO_5 = 14,
GPIO_6 = 15,
};
/* Pins whose access should be guarded by `cs_lock`. */
enum ChipSelect {
SD_CARD = SD_CHIP_SELECT,
DISPLAY = DISPLAY_CHIP_SELECT,
};
/* Nicer value names for use with the SD_MUX_SWITCH pin. */
enum SdController {
SD_MUX_ESP = 0,
SD_MUX_USB = 1,
};
/**
* Returns the current driven status of each of the ports. The first byte is
* port a, and the second byte is port b.
*/
std::atomic<uint16_t>& ports() { return ports_; }
/*
* Sets a single specific pin to the given value. `true` corresponds to
* HIGH, and `false` corresponds to LOW.
*
* Calls to this method will be buffered in memory until a call to `Write()`
* is made.
*/
void set_pin(Pin pin, bool value);
void set_pin(ChipSelect cs, bool value);
/**
* Returns the input status of each of the ports. The first byte is port a,
* and the second byte is port b.
*/
const std::atomic<uint16_t>& inputs() const { return inputs_; }
/* Returns the most recently cached value of the given pin. Only valid for
* pins used as inputs; to check what value we're driving a pin, use
* `ports()`.
*/
bool get_input(Pin pin) const;
/* Returns the mutex that must be held whilst pulling a CS pin low. */
std::mutex& cs_mutex() { return cs_mutex_; }
/*
* Helper class containing an active `cs_mutex` lock. When an instance of
* this class is destroyed (usually by falling out of scope), the associated
* CS pin will be driven high before the lock is released.
*/
class SpiLock {
public:
SpiLock(GpioExpander& gpio, ChipSelect cs);
~SpiLock();
SpiLock(const SpiLock&) = delete;
private:
std::scoped_lock<std::mutex> lock_;
GpioExpander& gpio_;
ChipSelect cs_;
};
/*
* Pulls the given CS pin low to signal that we are about to communicate
* with a particular device, after acquiring a lock on `cs_mutex`. The
* recommended way to safely interact with devices on the SPI bus is to have
* a self-contained block like so:
*
* ```
* {
* auto lock = AcquireSpiBus(WHATEVER);
* // Do some cool things here.
* }
* ```
*/
SpiLock AcquireSpiBus(ChipSelect cs);
// Not copyable or movable. There should usually only ever be once instance
// of this class, and that instance will likely have a static lifetime.
GpioExpander(const GpioExpander&) = delete;
GpioExpander& operator=(const GpioExpander&) = delete;
private:
std::mutex cs_mutex_;
std::atomic<uint16_t> ports_;
std::atomic<uint16_t> inputs_;
};
} // namespace gay_ipod
} // namespace gay_ipod

4
main/i2c.cpp
Unescape View File

@ -36,9 +36,9 @@ I2CTransaction& I2CTransaction::write_ack(uint8_t data) {
return *this;
}
I2CTransaction& I2CTransaction::read(uint8_t *dest, i2c_ack_type_t ack) {
I2CTransaction& I2CTransaction::read(uint8_t* dest, i2c_ack_type_t ack) {
ESP_ERROR_CHECK(i2c_master_read_byte(handle_, dest, ack));
return *this;
}
} // namespace gay_ipod
} // namespace gay_ipod

109
main/i2c.h
Unescape View File

@ -1,8 +1,8 @@
#pragma once
#include <cstdint>
#include "driver/i2c.h"
#include "hal/i2c_types.h"
#include <cstdint>
namespace gay_ipod {
@ -15,66 +15,67 @@ namespace gay_ipod {
* typically represent invalid arguments or OOMs.
*/
class I2CTransaction {
public:
static const uint8_t kI2CTimeout = 100 / portTICK_RATE_MS;
public:
static const uint8_t kI2CTimeout = 100 / portTICK_RATE_MS;
I2CTransaction();
~I2CTransaction();
I2CTransaction();
~I2CTransaction();
/*
* Executes all enqueued commands, returning the result code. Possible error
* codes, per the ESP-IDF docs:
*
* ESP_OK Success
* ESP_ERR_INVALID_ARG Parameter error
* ESP_FAIL Sending command error, slave doesn’t ACK the transfer.
* ESP_ERR_INVALID_STATE I2C driver not installed or not in master mode.
* ESP_ERR_TIMEOUT Operation timeout because the bus is busy.
*/
esp_err_t Execute();
/*
* Executes all enqueued commands, returning the result code. Possible error
* codes, per the ESP-IDF docs:
*
* ESP_OK Success
* ESP_ERR_INVALID_ARG Parameter error
* ESP_FAIL Sending command error, slave doesn’t ACK the transfer.
* ESP_ERR_INVALID_STATE I2C driver not installed or not in master mode.
* ESP_ERR_TIMEOUT Operation timeout because the bus is busy.
*/
esp_err_t Execute();
/*
* Enqueues a start condition. May also be used for repeated start conditions.
*/
I2CTransaction& start();
/* Enqueues a stop condition. */
I2CTransaction& stop();
/*
* Enqueues a start condition. May also be used for repeated start conditions.
*/
I2CTransaction& start();
/* Enqueues a stop condition. */
I2CTransaction& stop();
/*
* Enqueues writing the given 7 bit address, followed by one bit indicating
* whether this is a read or write request.
*
* This command will expect an ACK before continuing.
*/
I2CTransaction& write_addr(uint8_t addr, uint8_t op);
/*
* Enqueues writing the given 7 bit address, followed by one bit indicating
* whether this is a read or write request.
*
* This command will expect an ACK before continuing.
*/
I2CTransaction& write_addr(uint8_t addr, uint8_t op);
/*
* Enqueues one or more bytes to be written. The transaction will wait for
* an ACK to be returned before writing the next byte.
*/
I2CTransaction& write_ack(uint8_t data);
template <typename... More>
I2CTransaction& write_ack(uint8_t data, More... more) {
write_ack(data);
write_ack(more...);
return *this;
}
/*
* Enqueues one or more bytes to be written. The transaction will wait for
* an ACK to be returned before writing the next byte.
*/
I2CTransaction& write_ack(uint8_t data);
template <typename ...More>
I2CTransaction& write_ack(uint8_t data, More... more) {
write_ack(data);
write_ack(more...);
return *this;
}
/*
* Enqueues a read of one byte into the given uint8. Responds with the given
* ACK/NACK type.
*/
I2CTransaction& read(uint8_t* dest, i2c_ack_type_t ack);
/*
* Enqueues a read of one byte into the given uint8. Responds with the given
* ACK/NACK type.
*/
I2CTransaction& read(uint8_t *dest, i2c_ack_type_t ack);
/* Returns the underlying command buffer. */
i2c_cmd_handle_t handle() { return handle_; }
/* Returns the underlying command buffer. */
i2c_cmd_handle_t handle() { return handle_; }
// Cannot be moved or copied, since doing so is probably an error. Pass a
// reference instead.
I2CTransaction(const I2CTransaction&) = delete;
I2CTransaction& operator=(const I2CTransaction&) = delete;
// Cannot be moved or copied, since doing so is probably an error. Pass a
// reference instead.
I2CTransaction(const I2CTransaction&) = delete;
I2CTransaction& operator=(const I2CTransaction&) = delete;
private:
i2c_cmd_handle_t handle_;
private:
i2c_cmd_handle_t handle_;
};
} // namespace gay_ipod
} // namespace gay_ipod

19
main/storage.cpp
Unescape View File

@ -19,7 +19,7 @@ namespace gay_ipod {
static const char* TAG = "SDSTORAGE";
SdStorage::SdStorage(GpioExpander *gpio) {
SdStorage::SdStorage(GpioExpander* gpio) {
this->gpio_ = gpio;
}
@ -33,12 +33,12 @@ SdStorage::Error SdStorage::Acquire(void) {
sdspi_host_init();
sdspi_device_config_t config = {
.host_id = VSPI_HOST,
// CS handled manually bc it's on the GPIO expander
.gpio_cs = GPIO_NUM_2,
.gpio_cd = SDSPI_SLOT_NO_CD,
.gpio_wp = SDSPI_SLOT_NO_WP,
.gpio_int = GPIO_NUM_NC,
.host_id = VSPI_HOST,
// CS handled manually bc it's on the GPIO expander
.gpio_cs = GPIO_NUM_2,
.gpio_cd = SDSPI_SLOT_NO_CD,
.gpio_wp = SDSPI_SLOT_NO_WP,
.gpio_int = GPIO_NUM_NC,
};
ESP_ERROR_CHECK(sdspi_host_init_device(&config, &handle_));
@ -49,7 +49,8 @@ SdStorage::Error SdStorage::Acquire(void) {
// with our own that acquires the CS mutex for the duration of the SPI
// transaction.
auto src = host_.do_transaction;
sdspi::do_transaction_wrapper = [=](sdspi_dev_handle_t handle, sdmmc_command_t *cmd) -> esp_err_t {
sdspi::do_transaction_wrapper = [=](sdspi_dev_handle_t handle,
sdmmc_command_t* cmd) -> esp_err_t {
auto lock = gpio_->AcquireSpiBus(GpioExpander::SD_CARD);
return src(handle, cmd);
};
@ -88,4 +89,4 @@ void SdStorage::Release(void) {
sdspi_host_deinit();
}
} // namespace gay_ipod
} // namespace gay_ipod

92
main/storage.h
Unescape View File

@ -11,63 +11,65 @@ namespace gay_ipod {
// Static functions for interrop with the ESP IDF API, which requires a function
// pointer.
namespace sdspi {
// Holds a lambda created by SdStorage.
static std::function<esp_err_t(sdspi_dev_handle_t,sdmmc_command_t*)> do_transaction_wrapper;
// Holds a lambda created by SdStorage.
static std::function<esp_err_t(sdspi_dev_handle_t, sdmmc_command_t*)>
do_transaction_wrapper;
// Fits the required function pointer signature, but just delegates to the
// wrapper function. Does that make this the wrapper? Who knows.
__attribute__ ((unused)) // (gcc incorrectly thinks this is unused)
static esp_err_t do_transaction(sdspi_dev_handle_t handle, sdmmc_command_t *cmdinfo) {
return do_transaction_wrapper(handle, cmdinfo);
}
} // namespace sdspi
// Fits the required function pointer signature, but just delegates to the
// wrapper function. Does that make this the wrapper? Who knows.
__attribute__((unused)) // (gcc incorrectly thinks this is unused)
static esp_err_t
do_transaction(sdspi_dev_handle_t handle, sdmmc_command_t* cmdinfo) {
return do_transaction_wrapper(handle, cmdinfo);
}
} // namespace sdspi
static const char *kStoragePath = "/sdcard";
static const char* kStoragePath = "/sdcard";
static const uint8_t kMaxOpenFiles = 8;
class SdStorage {
public:
SdStorage(GpioExpander *gpio);
~SdStorage();
public:
SdStorage(GpioExpander* gpio);
~SdStorage();
enum Error {
OK,
/** We couldn't interact with the SD card at all. Is it missing? */
FAILED_TO_READ,
/** We couldn't mount the SD card. Is it formatted? */
FAILED_TO_MOUNT,
};
enum Error {
OK,
/** We couldn't interact with the SD card at all. Is it missing? */
FAILED_TO_READ,
/** We couldn't mount the SD card. Is it formatted? */
FAILED_TO_MOUNT,
};
// FIXME: these methods should also handling powering the SD card up and
// down once we have that capability.
// FIXME: these methods should also handling powering the SD card up and
// down once we have that capability.
/**
* Initialises the SDSPI driver and mounts the SD card for reading and
* writing. This must be called before any interactions with the underlying
* storage.
*/
Error Acquire(void);
/**
* Initialises the SDSPI driver and mounts the SD card for reading and
* writing. This must be called before any interactions with the underlying
* storage.
*/
Error Acquire(void);
/**
* Unmounts the SD card and frees memory associated with the SDSPI driver.
*/
void Release(void);
/**
* Unmounts the SD card and frees memory associated with the SDSPI driver.
*/
void Release(void);
// Not copyable or movable.
// TODO: maybe this could be movable?
SdStorage(const SdStorage&) = delete;
SdStorage& operator=(const SdStorage&) = delete;
// Not copyable or movable.
// TODO: maybe this could be movable?
SdStorage(const SdStorage&) = delete;
SdStorage& operator=(const SdStorage&) = delete;
private:
GpioExpander *gpio_;
private:
GpioExpander* gpio_;
// SPI and SD driver info
sdspi_dev_handle_t handle_;
sdmmc_host_t host_;
sdmmc_card_t card_;
// SPI and SD driver info
sdspi_dev_handle_t handle_;
sdmmc_host_t host_;
sdmmc_card_t card_;
// Filesystem info
FATFS *fs_ = nullptr;
// Filesystem info
FATFS* fs_ = nullptr;
};
} // namespace gay_ipod
} // namespace gay_ipod

Write Preview
Loading…
Cancel
Save