I2SDriverTangNano.h

Go to the documentation of this file.

#pragma once
 
#include "AudioTools/CoreAudio/AudioI2S/I2SConfig.h"
#include "AudioTools/CoreAudio/AudioI2S/I2SDriverBase.h"
#if defined(ARDUINO_ARCH_TANGNANO20K)
// The core defines a global I2SConfig which would be ambiguous with
// audio_tools::I2SConfig because of the automatic using namespace
#define I2SConfig TangNanoI2SConfig
#include <I2STangNano.h>
#undef I2SConfig
 
#define IS_I2S_IMPLEMENTED
 
namespace audio_tools {
 
class I2SDriverTangNano : public I2SDriverBase {
  friend class I2SStream;
 
 public:
  I2SConfigStd defaultConfig(RxTxMode mode) {
    I2SConfigStd c(mode);
    return c;
  }
 
  bool setAudioInfo(AudioInfo info) { return info.equals(cfg); }
 
  bool begin(RxTxMode mode = TX_MODE) { return begin(defaultConfig(mode)); }
 
  bool begin(I2SConfigStd cfg) {
    TRACEI();
    if (is_active) end();
    this->cfg = cfg;
    cfg.logInfo();
 
    if (!cfg.is_master) {
      LOGE("Only master mode is supported");
      return false;
    }
    if (cfg.i2s_format != I2S_STD_FORMAT &&
        cfg.i2s_format != I2S_PHILIPS_FORMAT) {
      LOGE("Only the I2S (Philips) format is supported");
      return false;
    }
    if (cfg.channels < 1 || cfg.channels > 2) {
      LOGE("Unsupported channels: %d", cfg.channels);
      return false;
    }
 
    TangNanoI2SConfig tang_cfg;
    tang_cfg.sampleRate = cfg.sample_rate;
    tang_cfg.channels = cfg.channels;
    switch (cfg.rx_tx_mode) {
      case TX_MODE:
        tang_cfg.mode = I2S_MODE_OUTPUT;
        break;
      case RX_MODE:
        tang_cfg.mode = I2S_MODE_INPUT;
        break;
      default:
        tang_cfg.mode = I2S_MODE_DUPLEX;
        break;
    }
    switch (cfg.bits_per_sample) {
      case 8:
        tang_cfg.bits = I2S_BITS_8;
        break;
      case 16:
        tang_cfg.bits = I2S_BITS_16;
        break;
      case 24:
#ifdef USE_3BYTE_INT24
        tang_cfg.bits = I2S_BITS_24;
#else
        // int24_4bytes_t is stored as a left aligned 32 bit value
        tang_cfg.bits = I2S_BITS_32;
#endif
        break;
      case 32:
        tang_cfg.bits = I2S_BITS_32;
        break;
      default:
        LOGE("Unsupported bits_per_sample: %d", cfg.bits_per_sample);
        return false;
    }
    if (cfg.buffer_size > 0 && cfg.buffer_count > 0) {
      // buffer size is in bytes: the ring buffer is in frames
      int frame_size = cfg.channels * bytesPerSample();
      int frames = cfg.buffer_size * cfg.buffer_count / frame_size;
      if (frames > 0xFFFF) frames = 0xFFFF;
      tang_cfg.ringSamples = frames;
    }
 
    ::I2S.begin(tang_cfg);
    is_active = true;
    return true;
  }
 
  void end() {
    ::I2S.end();
    is_active = false;
  }
 
  I2SConfigStd config() { return cfg; }
 
  size_t writeBytes(const void *src, size_t size_bytes) {
    return ::I2S.write((const uint8_t *)src, size_bytes);
  }
 
  size_t readBytes(void *dest, size_t size_bytes) {
    return ::I2S.readBytes((uint8_t *)dest, size_bytes);
  }
 
  int availableForWrite() {
    return ::I2S.availableForWrite() * cfg.channels * bytesPerSample();
  }
 
  int available() { return ::I2S.available(); }
 
  void flush() { ::I2S.flush(); }
 
 protected:
  I2SConfigStd cfg;
  bool is_active = false;
 
  int bytesPerSample() {
    return cfg.bits_per_sample == 24 ? sizeof(int24_t)
                                     : cfg.bits_per_sample / 8;
  }
};
 
using I2SDriver = I2SDriverTangNano;
 
}  // namespace audio_tools
 
#endif