SPIAudioSlave.h

Go to the documentation of this file.

#pragma once
 
#include <SPI.h>
 
#include "AudioTools/CoreAudio/AudioBasic/Str.h"
#include "AudioTools/CoreAudio/AudioOutput.h"
#include "AudioTools/CoreAudio/AudioTypes.h"
#include "AudioTools/CoreAudio/BaseStream.h"
#include "AudioTools/CoreAudio/Buffers.h"
#include "SPIAudioCommand.h"
 
#if defined(ESP32)
#include "driver/spi_slave.h"
#endif
 
namespace audio_tools {
 
struct SPIAudioSlaveConfig : public AudioInfo {
  size_t max_command_payload = 1024;
  size_t max_response_payload = 32;
  size_t max_mime_len = 20;
#if defined(ESP32)
  bool use_hw_slave = true;
#if defined(SPI2_HOST)
  spi_host_device_t host = SPI2_HOST;
#elif defined(HSPI_HOST)
  spi_host_device_t host = HSPI_HOST;
#elif defined(SPI3_HOST)
  spi_host_device_t host = SPI3_HOST;
#elif defined(VSPI_HOST)
  spi_host_device_t host = VSPI_HOST;
#else
  spi_host_device_t host = SPI2_HOST;
#endif
  int dma_chan = 1;
  int pin_mosi = 23;
  int pin_miso = 19;
  int pin_sclk = 18;
  int pin_cs = 5;
  int queue_size = 4;
#endif
  void log() const {
    LOGI(
        "SPIAudioSlaveConfig: sample_rate=%d, channels=%d, bits_per_sample=%d, "
        "max_command_payload=%d, max_response_payload=%d, max_mime_len=%d ",
        (int)sample_rate, (int)channels, (int)bits_per_sample,
        (int)max_command_payload, (int)max_response_payload, (int)max_mime_len);
#if defined(ESP32)
    LOGI(
        "ESP32 SPI Slave Config: use_hw_slave=%s, host=%d, dma_chan=%d, "
        "pin_mosi=%d, pin_miso=%d, pin_sclk=%d, pin_cs=%d, queue_size=%d",
        use_hw_slave ? "true" : "false", host, dma_chan, pin_mosi, pin_miso,
        pin_sclk, pin_cs, queue_size);
#endif
  }
};
 
class SPIAudioSlave : public AudioStream {
 public:
  enum StatusCode : uint8_t {
    Ok = 0,
    InvalidCommand = 1,
    InvalidPayload = 2,
    BufferOverflow = 3,
    InternalError = 4
  };
 
  SPIAudioSlave(BaseBuffer<uint8_t>& buffer) : p_buffer(&buffer) {}
 
  bool begin(SPIAudioSlaveConfig cfg = SPIAudioSlaveConfig()) {
    config = cfg;
    config.log();
    setAudioInfo(cfg);
    if (config.max_command_payload == 0) config.max_command_payload = 1;
    if (config.max_response_payload == 0) config.max_response_payload = 1;
    if (config.max_mime_len == 0) config.max_mime_len = 1;
 
    if (p_buffer == nullptr) return false;
    p_buffer->reset();
    request_payload.resize(config.max_command_payload);
    response_payload.resize(config.max_response_payload);
    mime.setCapacity(config.max_mime_len > 0 ? config.max_mime_len - 1 : 0);
    mime = "";
 
    resetProtocolState();
 
#if defined(ESP32)
    if (config.use_hw_slave) {
      spi_bus_config_t bus_cfg;
      memset(&bus_cfg, 0, sizeof(bus_cfg));
      bus_cfg.mosi_io_num = config.pin_mosi;
      bus_cfg.miso_io_num = config.pin_miso;
      bus_cfg.sclk_io_num = config.pin_sclk;
      bus_cfg.quadwp_io_num = -1;
      bus_cfg.quadhd_io_num = -1;
 
      spi_slave_interface_config_t slave_cfg;
      memset(&slave_cfg, 0, sizeof(slave_cfg));
      slave_cfg.mode = 0;
      slave_cfg.spics_io_num = config.pin_cs;
      slave_cfg.queue_size = config.queue_size;
      slave_cfg.flags = 0;
 
      esp_err_t rc = spi_slave_initialize(config.host, &bus_cfg, &slave_cfg,
                                          config.dma_chan);
      if (rc != ESP_OK) {
        active = false;
        return false;
      }
      esp32_spi_active = true;
      spi_tx_byte = 0;
    }
#endif
 
    active = true;
    return true;
  }
 
  void end() override {
#if defined(ESP32)
    if (esp32_spi_active) {
      spi_slave_free(config.host);
      esp32_spi_active = false;
    }
#endif
    active = false;
    if (p_buffer != nullptr) p_buffer->reset();
    resetProtocolState();
  }
 
  bool isActive() const { return active; }
 
  void setAudioInfo(AudioInfo info) override {
    AudioStream::setAudioInfo(info);
    config.copyFrom(info);
  }
 
  bool process() {
#if defined(ESP32)
    if (!esp32_spi_active) return false;
 
    spi_slave_transaction_t t;
    memset(&t, 0, sizeof(t));
    t.length = 8;
    t.tx_buffer = &spi_tx_byte;
    t.rx_buffer = &spi_rx_byte;
 
    esp_err_t rc = spi_slave_transmit(config.host, &t, 0);
    if (rc != ESP_OK) return false;
 
    spi_tx_byte = onTransfer(spi_rx_byte);
    // If the last Rx byte triggered a Rx→TxStatus transition, the returned
    // value was 0 (Rx state return). Pre-advance through TxStatus now so that
    // spi_tx_byte holds tx_status before the next spi_slave_transmit call,
    // eliminating the 1-byte pipeline shift in the response stream.
    if (state == TxStatus) {
      spi_tx_byte = onTransfer(0);
    }
    return true;
#else
    return false;
#endif
  }
 
  uint8_t onTransfer(uint8_t in) {
    switch (state) {
      case RxCmd:
        current_cmd = in;
        expected_payload_len = 0;
        rx_pos = 0;
        tx_pos = 0;
        tx_len = 0;
        tx_status = Ok;
        state = RxLenLo;
        return 0;
 
      case RxLenLo:
        expected_payload_len = in;
        state = RxLenHi;
        return 0;
 
      case RxLenHi:
        expected_payload_len |= static_cast<uint16_t>(in) << 8;
        if (expected_payload_len == 0) {
          prepareResponse();
          state = TxStatus;
        } else {
          rx_pos = 0;
          state = RxPayload;
        }
        return 0;
 
      case RxPayload:
        if (rx_pos < request_payload.size()) {
          request_payload[rx_pos] = in;
        }
        rx_pos++;
        if (rx_pos >= expected_payload_len) {
          prepareResponse();
          state = TxStatus;
        }
        return 0;
 
      case TxStatus:
        state = TxLenLo;
        return tx_status;
 
      case TxLenLo:
        state = TxLenHi;
        return static_cast<uint8_t>(tx_len & 0xFF);
 
      case TxLenHi: {
        uint8_t out = static_cast<uint8_t>((tx_len >> 8) & 0xFF);
        if (tx_len == 0) {
          state = RxCmd;
        } else {
          state = TxPayload;
        }
        return out;
      }
 
      case TxPayload: {
        uint8_t out = tx_pos < tx_len ? response_payload[tx_pos] : 0;
        tx_pos++;
        if (tx_pos >= tx_len) {
          state = RxCmd;
        }
        return out;
      }
    }
    resetProtocolState();
    return 0;
  }
 
  bool processFrame(const uint8_t* request_frame, uint16_t request_frame_len,
                    uint8_t* response_frame, uint16_t response_frame_max,
                    uint16_t* response_frame_len = nullptr) {
    if (request_frame == nullptr || request_frame_len < 3 ||
        response_frame == nullptr || response_frame_max < 3) {
      return false;
    }
 
    uint8_t cmd = request_frame[0];
    uint16_t payload_len = static_cast<uint16_t>(request_frame[1]) |
                           (static_cast<uint16_t>(request_frame[2]) << 8);
    if (static_cast<uint32_t>(payload_len) + 3 > request_frame_len) {
      return false;
    }
 
    uint16_t out_len = 0;
    uint8_t status = processCommand(
        static_cast<SPIAudioCommand>(cmd), request_frame + 3, payload_len,
        response_frame + 3, response_frame_max - 3, out_len);
 
    response_frame[0] = status;
    response_frame[1] = static_cast<uint8_t>(out_len & 0xFF);
    response_frame[2] = static_cast<uint8_t>((out_len >> 8) & 0xFF);
 
    if (response_frame_len != nullptr) {
      *response_frame_len = out_len + 3;
    }
    return true;
  }
 
  // Audio data access
  int available() override {
    return p_buffer == nullptr ? 0 : p_buffer->available();
  }
 
  int availableForWrite() override {
    return p_buffer == nullptr ? 0 : p_buffer->availableForWrite();
  }
 
  size_t readBytes(uint8_t* data, size_t len) override {
    if (!active || data == nullptr || len == 0) return 0;
    if (p_buffer == nullptr) return 0;
    int to_read = min(static_cast<int>(len), p_buffer->available());
    if (to_read <= 0) return 0;
    return p_buffer->readArray(data, to_read);
  }
 
  size_t write(const uint8_t* data, size_t len) override {
    if (!active || data == nullptr || len == 0) return 0;
    if (p_buffer == nullptr) return 0;
    int to_write = min(static_cast<int>(len), p_buffer->availableForWrite());
    if (to_write <= 0) return 0;
    return p_buffer->writeArray(data, to_write);
  }
 
  void clearBuffer() {
    if (p_buffer != nullptr) p_buffer->reset();
  }
 
  const char* mimeType() { return mime.c_str(); }
 
 protected:
  enum ProtocolState : uint8_t {
    RxCmd,
    RxLenLo,
    RxLenHi,
    RxPayload,
    TxStatus,
    TxLenLo,
    TxLenHi,
    TxPayload
  };
 
  SPIAudioSlaveConfig config;
  bool active = false;
  BaseBuffer<uint8_t>* p_buffer = nullptr;
  Vector<uint8_t> request_payload{0};
  Vector<uint8_t> response_payload{0};
  Str mime;
 
#if defined(ESP32)
  bool esp32_spi_active = false;
  uint8_t spi_tx_byte = 0;
  uint8_t spi_rx_byte = 0;
#endif
 
  // protocol state
  ProtocolState state = RxCmd;
  uint8_t current_cmd = 0;
  uint16_t expected_payload_len = 0;
  uint16_t rx_pos = 0;
  uint16_t tx_pos = 0;
  uint16_t tx_len = 0;
  uint8_t tx_status = Ok;
 
  void resetProtocolState() {
    state = RxCmd;
    current_cmd = 0;
    expected_payload_len = 0;
    rx_pos = 0;
    tx_pos = 0;
    tx_len = 0;
    tx_status = Ok;
  }
 
  void prepareResponse() {
    if (expected_payload_len > request_payload.size()) {
      tx_status = InvalidPayload;
      tx_len = 0;
      tx_pos = 0;
      return;
    }
 
    uint16_t out_len = 0;
    tx_status = processCommand(
        static_cast<SPIAudioCommand>(current_cmd), request_payload.data(),
        expected_payload_len, response_payload.data(),
        static_cast<uint16_t>(response_payload.size()), out_len);
    tx_len = out_len;
    tx_pos = 0;
  }
 
  uint8_t processCommand(SPIAudioCommand cmd, const uint8_t* payload,
                         uint16_t payload_len, uint8_t* response,
                         uint16_t response_max, uint16_t& response_len) {
    response_len = 0;
 
    switch (cmd) {
      case SPIAudioCommand::SetMime: {
        if (payload_len == 0 || payload == nullptr) return InvalidPayload;
        size_t max_len = config.max_mime_len > 0 ? config.max_mime_len - 1 : 0;
        size_t n = min(static_cast<size_t>(payload_len), max_len);
        if (n > 0 && payload[n - 1] == '\0') {
          --n;
        }
        mime.copyFrom(reinterpret_cast<const char*>(payload), n, max_len);
        return Ok;
      }
 
      case SPIAudioCommand::SetAudioInfo: {
        if (payload_len != 6 || payload == nullptr) return InvalidPayload;
        AudioInfo info = audioInfo();
        info.sample_rate = readU32LE(payload);
        info.channels = payload[4];
        info.bits_per_sample = payload[5];
        setAudioInfo(info);
        return Ok;
      }
 
      case SPIAudioCommand::WriteData: {
        if (payload_len == 0 || payload == nullptr) return Ok;
        if (p_buffer == nullptr) return InternalError;
        int written = p_buffer->writeArray(payload, payload_len);
        return written == static_cast<int>(payload_len) ? Ok : BufferOverflow;
      }
 
      case SPIAudioCommand::GetAvailableBufferSize: {
        if (response == nullptr || response_max < 4) return InternalError;
        if (p_buffer == nullptr) return InternalError;
        int avail = p_buffer->availableForWrite();
        writeU32LE(response, static_cast<uint32_t>(avail > 0 ? avail : 0));
        response_len = 4;
        return Ok;
      }
 
      case SPIAudioCommand::Clear: {
        if (p_buffer != nullptr) p_buffer->reset();
        return Ok;
      }
 
      case SPIAudioCommand::GetFilledBufferSize: {
        if (response == nullptr || response_max < 4) return InternalError;
        if (p_buffer == nullptr) return InternalError;
        int filled = p_buffer->available();
        writeU32LE(response, static_cast<uint32_t>(filled > 0 ? filled : 0));
        response_len = 4;
        return Ok;
      }
 
      default:
        return InvalidCommand;
    }
  }
 
  static void writeU32LE(uint8_t* out, uint32_t value) {
    out[0] = static_cast<uint8_t>(value & 0xFF);
    out[1] = static_cast<uint8_t>((value >> 8) & 0xFF);
    out[2] = static_cast<uint8_t>((value >> 16) & 0xFF);
    out[3] = static_cast<uint8_t>((value >> 24) & 0xFF);
  }
 
  static uint32_t readU32LE(const uint8_t* in) {
    return static_cast<uint32_t>(in[0]) | (static_cast<uint32_t>(in[1]) << 8) |
           (static_cast<uint32_t>(in[2]) << 16) |
           (static_cast<uint32_t>(in[3]) << 24);
  }
};
 
}  // namespace audio_tools