DriverDeviceInfo.h

Go to the documentation of this file.

 
#pragma once
#ifdef __zephyr__
#include "DriverDeviceInfoZephyr.h"
#else
#include "Platforms/API_Delay.h"
#include "Platforms/GPIO.h"
#include "Platforms/IDriverDeviceInfo.h"
 
namespace audio_driver {
 
class DriverDeviceInfo : public IDriverDeviceInfo {
 public:
  DriverDeviceInfo(const DriverDeviceInfo&) = delete;
  DriverDeviceInfo& operator=(const DriverDeviceInfo&) = delete;
  DriverDeviceInfo() = default;
 
  bool addI2S(InfoI2S pin) {
    if (getI2SPins(pin.function)) return false;
    i2s.push_back(pin);
    return true;
  }
 
  bool addI2S(PinFunction function, GpioPin mclk, GpioPin bck, GpioPin ws,
              GpioPin data_out, GpioPin data_in = -1, int port = 0) {
    InfoI2S pin{function, mclk, bck, ws, data_out, data_in, port};
    return addI2S(pin);
  }
 
  bool setI2S(InfoI2S pin) { return set<InfoI2S>(pin, i2s); }
 
  bool addSPI(InfoSPI pin) {
    if (getSPIPins(pin.function)) return false;
    spi.push_back(pin);
    return true;
  }
 
  bool addSPI(PinFunction function, GpioPin clk, GpioPin miso, GpioPin mosi,
              GpioPin cs, SPIClass& spi) {
    InfoSPI pin(function, clk, miso, mosi, cs, spi);
    return addSPI(pin);
  }
 
  bool setSPI(InfoSPI pin) { return set<InfoSPI>(pin, spi); }
 
  bool addI2C(InfoI2C pin) {
    if (getI2CPins(pin.function)) return false;
    i2c.push_back(pin);
    return true;
  }
 
#ifdef ARDUINO
  bool addI2C(PinFunction function, TwoWire& wire, bool setActive = false) {
    PinsI2C pin(function, -1, -1, -1, -1, &wire, setActive);
    return addI2C(pin);
  }
 
  bool addI2C(PinFunction function, GpioPin scl, GpioPin sda, int port,
              uint32_t frequency, TwoWire& wire, bool active = true) {
    PinsI2C pin(function, scl, sda, port, frequency, &wire, active);
    return addI2C(pin);
  }
#endif
 
  bool addI2C(PinFunction function, GpioPin scl, GpioPin sda, int port = -1,
              uint32_t frequency = 100000, i2c_bus_handle_t wire = DEFAULT_WIRE,
              bool active = true) {
    InfoI2C pin(function, scl, sda, port, frequency, wire, active);
    return addI2C(pin);
  }
 
  bool setI2C(InfoI2C pin) { return set<InfoI2C>(pin, i2c); }
 
  bool addPin(InfoGPIO pin) {
    pins.push_back(pin);
    return true;
  }
 
  bool addPin(PinFunction function, GpioPin pinNo, PinLogic logic,
              int index = 0) {
    InfoGPIO pin(function, pinNo, logic, index);
    return addPin(pin);
  }
 
  bool setPin(InfoGPIO updatedPin) {
    for (InfoGPIO& pin : pins) {
      if (pin.function == updatedPin.function &&
          pin.index == updatedPin.index) {
        pin = updatedPin;
        return true;
      }
    }
    return false;
  }
 
  bool setPinActive(int gpioPin, bool active) {
    for (InfoGPIO& pin : pins) {
      if (pin.pin == gpioPin) {
        pin.active = active;
        return true;
      }
    }
    return false;
  }
 
  bool setPinActive(PinFunction func, int idx, bool active) {
    auto pin = getPin(func, idx);
    if (pin) {
      auto value = pin.value();
      value.active = active;
      // update pin
      return setPin(value);
    }
    return false;
  }
 
  audio_driver_local::Optional<InfoGPIO> getPin(PinFunction function,
                                                    int pos = 0) {
    for (InfoGPIO& pin : pins) {
      if (pin.function == function && pin.index == pos) return pin;
    }
    return {};
  }
 
  audio_driver_local::Optional<InfoGPIO> getPin(GpioPin pinId) {
    for (InfoGPIO& pin : pins) {
      if (pin.pin == pinId) return pin;
    }
    return {};
  }
 
  GpioPin getPinID(PinFunction function, int pos = 0) {
    auto pin = getPin(function, pos);
    if (pin) return pin.value().pin;
    return -1;
  }
 
  PinLogic getPinLogic(PinFunction function, int pos = 0) {
    auto pin = getPin(function, pos);
    if (pin) return pin.value().pin_logic;
    return PinLogic::Inactive;
  }
 
  audio_driver_local::Optional<InfoI2C> getI2CPins(
      PinFunction function) override {
    InfoI2C* pins = getPtr<InfoI2C>(function, i2c);
    if (pins == nullptr) return {};
    return *pins;
  }
 
  audio_driver_local::Optional<InfoSPI> getSPIPins(PinFunction function) {
    InfoSPI* pins = getPtr<InfoSPI>(function, spi);
    if (pins == nullptr) return {};
    return *pins;
  }
 
  audio_driver_local::Optional<InfoI2S> getI2SPins(int port) {
    for (InfoI2S& pins : i2s) {
      if (pins.port == port) return pins;
    }
    return {};
  }
 
  audio_driver_local::Optional<InfoI2S> getI2SPins(
      PinFunction function = PinFunction::CODEC) {
    InfoI2S* pins = getPtr<InfoI2S>(function, i2s);
    if (pins == nullptr) return {};
    return *pins;
  }
 
  virtual bool begin() {
    AD_LOGD("DriverDeviceInfo::begin");
 
    // setup function pins
    setupPinMode();
 
    // setup spi
    bool result = true;
    for (auto& tmp : spi) {
      if (tmp.function == PinFunction::SD) {
        if (sd_active)
          result &= tmp.begin();
        else
          result &= tmp.begin();
      }
    }
 
    // setup i2c
    for (auto& tmp : i2c) {
      result &= tmp.begin();
    }
    return result;
  }
 
  void end() {
    // close spi
    for (auto& tmp : spi) {
      // close SD only when sd_active
      if (tmp.function == PinFunction::SD) {
        if (sd_active) tmp.end();
      } else {
        tmp.end();
      }
    }
    // close i2c
    for (auto& tmp : i2c) {
      AD_LOGD("DriverDeviceInfo::begin::I2C::end");
      tmp.end();
    }
  }
 
  void setSPIActiveForSD(bool active) {
    AD_LOGD("DriverDeviceInfo::setSPIActiveForSD: %d", active);
    sd_active = active; }
 
  bool isSPIActiveForSD() { return sd_active; }
 
  void setSDMMCActive(bool active) {
    AD_LOGD("DriverDeviceInfo::setSDMMCActive: %d", active);
    sdmmc_active = active;
    sd_active = false;
  }
 
  bool isSDMMCActive() { return sdmmc_active; }
 
  bool hasPins() { return !pins.empty(); }
 
  virtual bool isKeyPressed(uint8_t key) {
    auto pin_opt = getPin(PinFunction::KEY, key);
    if (!pin_opt) return false;
    auto pin = pin_opt.value();
    bool value = gpio.digitalRead(pin.pin);
    return pin.pin_logic == PinLogic::InputActiveLow ? !value : value;
  }
 
  API_GPIO& getGPIO() { return gpio; }
 
 protected:
  audio_driver_local::Vector<InfoI2S> i2s{0};
  audio_driver_local::Vector<InfoSPI> spi{0};
  audio_driver_local::Vector<InfoI2C> i2c{0};
  audio_driver_local::Vector<InfoGPIO> pins{0};
  GPIOExt gpio;  // standard Arduino GPIO
  bool sd_active = false;
  bool sdmmc_active = false;
 
  template <typename T>
  T* getPtr(PinFunction function, audio_driver_local::Vector<T>& vect) {
    for (auto& pins : vect) {
      if (pins.function == function) return &pins;
    }
    return nullptr;
  }
 
  template <typename T>
  bool set(T pin, audio_driver_local::Vector<T>& vect) {
    T* pins = getPtr<T>(pin.function, vect);
    if (pins == nullptr) return false;
    *pins = pin;
    return true;
  }
 
  void setupPinMode() {
    gpio.begin(*this);
    AD_LOGD("DriverDeviceInfo::setupPinMode");
    // setup pins
    for (auto& tmp : pins) {
      if (tmp.pin != -1) {
        if (!hasConflict(tmp.pin)) {
          AD_LOGD("pinMode for %d", tmp.pin);
          switch (tmp.pin_logic) {
            case PinLogic::InputActiveHigh:
              gpio.pinMode(tmp.pin, INPUT);
              break;
            case PinLogic::InputActiveLow:
              gpio.pinMode(tmp.pin, INPUT_PULLUP);
              break;
            case PinLogic::Input:
              gpio.pinMode(tmp.pin, INPUT);
              break;
            case PinLogic::Output:
            case PinLogic::OutputActiveLow:
              gpio.pinMode(tmp.pin, OUTPUT);
              break;
            default:
              // do nothing
              break;
          }
        } else {
          AD_LOGW("Pin '%d' not set up because of conflict", tmp.pin);
          tmp.active = false;
        }
      } else {
        AD_LOGD("Pin is -1");
      }
    }
  }
 
  bool hasConflict(int pin) {
    return hasSPIConflict(pin) || hasI2CConflict(pin);
  }
 
  bool hasSPIConflict(int pin) {
    if (sd_active) {
      auto sd = getSPIPins(PinFunction::SD);
      if (!sd) return false;
      InfoSPI spi = sd.value();
      return spi.cs == pin || spi.clk == pin || spi.miso == pin ||
             spi.mosi == pin;
    }
    return false;
  }
 
  bool hasI2CConflict(int pin) {
    for (auto& i2c_entry : i2c) {
      if (i2c_entry.scl == pin || i2c_entry.sda == pin) {
        return true;
      }
    }
    return false;
  }
};
 
using DriverPins = DriverDeviceInfo;
 
class DriverTouchClass : public DriverDeviceInfo {
  bool isKeyPressed(uint8_t key) override {
    bool result = false;
#if defined(ESP32) && defined(ARDUINO)
#if SOC_TOUCH_SENSOR_SUPPORTED
    auto pin_opt = getPin(PinFunction::KEY, key);
    if (!pin_opt) return false;
    auto pin = pin_opt.value();
    int value = touchRead(pin.pin);
    result = value <= touch_limit;
    if (result) {
      // retry to confirm reading
      value = touchRead(pin.pin);
      result = value <= touch_limit;
    }
#endif
#endif
    return result;
  }
  void setTouchLimit(int limit) { touch_limit = limit; }
 
 protected:
  int touch_limit = TOUCH_LIMIT;
};
 
 
// -- Pins
static DriverDeviceInfo NoPins;
}  // namespace audio_driver
 
#endif