DriverDeviceInfoZephyr.h

Go to the documentation of this file.

 
#pragma once
#include "DriverCommon.h"
#ifdef __zephyr__
#include "Platforms/GPIO_Zephyr.h"
#include "Platforms/IDriverDeviceInfo.h"
 
namespace audio_driver {
 
class DriverDeviceInfoZephyr : public IDriverDeviceInfo {
 public:
  DriverDeviceInfoZephyr(const DriverDeviceInfoZephyr&) = delete;
  DriverDeviceInfoZephyr& operator=(const DriverDeviceInfoZephyr&) = delete;
  DriverDeviceInfoZephyr() = default;
  bool addI2S(InfoI2S info) {
    i2s.push_back(info);
    return true;
  }
 
  bool addI2S(PinFunction function, device* dev_i2s, int port = 0) {
    InfoI2S info(function, dev_i2s, port);
    return addI2S(info);
  }
 
  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, device* dev_spi) {
    InfoSPI pin(function, dev_spi);
    return addSPI(pin);
  }
 
  bool setSPI(InfoSPI info) { return set<InfoSPI>(info, spi); }
 
  bool addI2C(InfoI2C info) {
    i2c.push_back(info);
    return true;
  }
 
  bool addI2C(PinFunction function, device* dev_i2c, int address = -1,
              bool active = true) {
    InfoI2C info(function, dev_i2c, address, active);
    return addI2C(info);
  }
  bool setI2C(InfoI2C info) { return set<InfoI2C>(info, i2c); }
 
  bool addPin(InfoGPIO info) {
    pins.push_back(info);
    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(GpioPin 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 GPIO_UNDEFINED;
  }
 
  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};
  GPIO 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 != GPIO_UNDEFINED) {
          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:
              gpio.pinMode(tmp.pin, OUTPUT);
              break;
            default:
              // do nothing
              break;
          }
      } else {
        AD_LOGD("Pin is -1");
      }
    }
  }
 
  bool hasConflict(int pin) {
    return false;
  }
 
  bool hasSPIConflict(int pin) {
    return false;
  }
 
  bool hasI2CConflict(int pin) {
    return false;
  }
};
 
using DriverDeviceInfo = DriverDeviceInfoZephyr;
 
 
// -- Pins
static DriverDeviceInfoZephyr NoPins;
 
}  // namespace audio_driver
 
#endif