SPIAudioMaster.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 SPIAudioMasterConfig : public AudioInfo {
#if defined(SS)
  int cs_pin = SS;
#else
  int cs_pin = 10;
#endif
  uint32_t clock_hz = 8000000;
  uint8_t bit_order = MSBFIRST;
  uint8_t data_mode = SPI_MODE0;
  size_t max_payload = 1024;
  bool is_blocking_write = false;
  void log() const {
    LOGI(
        "SPIAudioMasterConfig: sample_rate=%d, channels=%d, "
        "bits_per_sample=%d, cs_pin=%d, clock_hz=%d, bit_order=%s, "
        "data_mode=%s, max_payload=%d, is_blocking_write=%s",
        (int)sample_rate, (int)channels, (int)bits_per_sample, cs_pin, clock_hz,
        bit_order == MSBFIRST ? "MSBFIRST" : "LSBFIRST",
        data_mode == SPI_MODE0   ? "SPI_MODE0"
        : data_mode == SPI_MODE1 ? "SPI_MODE1"
        : data_mode == SPI_MODE2 ? "SPI_MODE2"
        : data_mode == SPI_MODE3 ? "SPI_MODE3"
                                 : "UNKNOWN",
        (int)max_payload, is_blocking_write ? "true" : "false");
  }
};
 
class SPIAudioMaster : public AudioOutput {
 public:
  SPIAudioMaster() = default;
  explicit SPIAudioMaster(SPIClass& spi) : p_spi(&spi) {}
 
  bool begin(SPIAudioMasterConfig cfg = SPIAudioMasterConfig()) {
    config = cfg;
    config.log();
    if (p_spi == nullptr) {
      p_spi = &SPI;
    }
    if (config.cs_pin >= 0) {
      pinMode(config.cs_pin, OUTPUT);
      digitalWrite(config.cs_pin, HIGH);
    }
    p_spi->begin();
    active = true;
 
    clear();  // Clear remote buffer on start
    buffer_size = getAvailableBufferSize();
    LOGI("SPIAudioMaster started with remote buffer size: %d bytes",
         buffer_size);
    return true;
  }
 
  void end() {
    clear();
    if (p_spi != nullptr) {
      p_spi->end();
    }
    active = false;
  }
 
  bool isActive() const { return active; }
 
  bool setMime(const char* mime) {
    if (mime == nullptr) return false;
    return sendCommand(SPIAudioCommand::SetMime,
                       reinterpret_cast<const uint8_t*>(mime), strlen(mime) + 1,
                       nullptr, nullptr);
  }
 
  void setAudioInfo(AudioInfo info) override {
    AudioOutput::setAudioInfo(info);
    uint8_t payload[6];
    writeU32LE(payload, info.sample_rate);
    payload[4] = static_cast<uint8_t>(info.channels);
    payload[5] = static_cast<uint8_t>(info.bits_per_sample);
    (void)sendCommand(SPIAudioCommand::SetAudioInfo, payload, sizeof(payload),
                      nullptr, nullptr);
  }
 
  size_t write(const uint8_t* data, size_t len) {
    if (!active) return 0;
    if (data == nullptr || len == 0) return 0;
    if (len > buffer_size) {
      LOGE("Attempting to write %d bytes, but remote buffer size is only %d",
           (int)len, buffer_size);
      return 0;
    }
 
    size_t chunk = min(config.max_payload, len);
    if (chunk == 0) return 0;
 
    if (!config.is_blocking_write) {
      size_t available = getAvailableBufferSize();
      chunk = min(chunk, available);
      if (chunk == 0) return 0;
      return sendCommand(SPIAudioCommand::WriteData, data, chunk, nullptr,
                         nullptr)
                 ? chunk
                 : 0;
    }
 
    // wait until enough space is available for the chunk
    while (getAvailableBufferSize() < chunk) {
      delay(10);
    }
    return sendCommand(SPIAudioCommand::WriteData, data, chunk, nullptr,
                       nullptr)
               ? chunk
               : 0;
  }
 
  int availableForWrite() {
    return active ? static_cast<int>(getAvailableBufferSize()) : 0;
  }
 
  bool clear() {
    return sendCommand(SPIAudioCommand::Clear, nullptr, 0, nullptr, nullptr);
  }
 
  int available() {
    return active ? static_cast<int>(getFilledBufferSize()) : 0;
  }
 
 protected:
  SPIAudioMasterConfig config;
  bool active = false;
  SPIClass* p_spi = nullptr;
  int buffer_size = 0;
 
  uint32_t getAvailableBufferSize() {
    uint8_t response[4] = {0, 0, 0, 0};
    uint16_t response_len = sizeof(response);
    if (!sendCommand(SPIAudioCommand::GetAvailableBufferSize, nullptr, 0,
                     response, &response_len)) {
      return 0;
    }
    if (response_len < 4) {
      return 0;
    }
    return readU32LE(response);
  }
 
  uint32_t getFilledBufferSize() {
    uint8_t response[4] = {0, 0, 0, 0};
    uint16_t response_len = sizeof(response);
    if (!sendCommand(SPIAudioCommand::GetFilledBufferSize, nullptr, 0, response,
                     &response_len)) {
      return 0;
    }
    if (response_len < 4) {
      return 0;
    }
    return readU32LE(response);
  }
 
  bool sendCommand(SPIAudioCommand command, const uint8_t* payload,
                   uint16_t payload_len, uint8_t* response,
                   uint16_t* response_len) {
    if (!active || p_spi == nullptr) return false;
 
    SPISettings settings(config.clock_hz, config.bit_order, config.data_mode);
    p_spi->beginTransaction(settings);
    if (config.cs_pin >= 0) {
      digitalWrite(config.cs_pin, LOW);
    }
 
    p_spi->transfer(static_cast<uint8_t>(command));
    transferU16LE(payload_len);
 
    for (uint16_t i = 0; i < payload_len; i++) {
      p_spi->transfer(payload != nullptr ? payload[i] : 0);
    }
 
    uint8_t status = p_spi->transfer(0x00);
    uint16_t len = transferU16LE(0);
    uint16_t response_capacity = 0;
 
    if (response != nullptr && response_len != nullptr) {
      response_capacity = *response_len;
    }
 
    if (response_len != nullptr) {
      *response_len = len;
    }
 
    for (uint16_t i = 0; i < len; i++) {
      uint8_t value = p_spi->transfer(0x00);
      if (response != nullptr && i < response_capacity) {
        response[i] = value;
      }
    }
 
    if (config.cs_pin >= 0) {
      digitalWrite(config.cs_pin, HIGH);
    }
    p_spi->endTransaction();
 
    return status == 0;
  }
 
  uint16_t transferU16LE(uint16_t value) {
    uint8_t lo = p_spi->transfer(static_cast<uint8_t>(value & 0xFF));
    uint8_t hi = p_spi->transfer(static_cast<uint8_t>((value >> 8) & 0xFF));
    return static_cast<uint16_t>(lo) | (static_cast<uint16_t>(hi) << 8);
  }
 
  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