AudioBoardStream.h

Go to the documentation of this file.

#pragma once
 
#include "AudioToolsConfig.h"
#include "AudioTools/AudioLibs/I2SCodecStream.h"
#include "AudioTools/CoreAudio/AudioActions.h"
 
void* p_lastAudioBoardStream = nullptr; 
 
 
namespace audio_tools {
 
class AudioBoardStream : public I2SCodecStream {
 
  struct AudioBoardAction : public AudioActions::Action {
    AudioBoardAction(AudioBoard &board, AudioDriverKey key) {
      this->key = key;
      this->p_board = &board;
    }
    AudioDriverKey key;
    AudioBoard *p_board;
    int id() override { return (int) key | 0x400; }
    bool readValue() override { return p_board->isKeyPressed((int)key); }
  };
 
 public:
  AudioBoardStream(audio_driver::AudioBoard &board) : I2SCodecStream(board) {
    // pin mode already set up by driver library
    actions.setPinMode(false);
    // use the AudioBoard
    actions.setReadCallback(readPinCB, this);
    p_lastAudioBoardStream = this;
  }
 
  bool begin() override { return I2SCodecStream::begin(); }
 
  bool begin(I2SCodecConfig cfg) override { return I2SCodecStream::begin(cfg); }
 
  void processActions() {
    //  TRACED();
    actions.processActions();
    delay(1);
  }
 
  void addAction(AudioDriverKey key, void (*action)(bool, digital_pin_t, void *),
                 void *ref = nullptr) {
      AudioBoardAction *abo = new AudioBoardAction(board(), key);
      if (abo == nullptr) {
        LOGE("Failed to allocate AudioBoardAction");
        return;
      }
      abo->actionOn = action;
      abo->ref = (ref == nullptr) ? this : ref;
      actions.add(*abo);
  }
 
  void addAction(AudioDriverKey key, void (*actionOn)(bool, digital_pin_t, void *),
                void (*actionOff)(bool, digital_pin_t, void *),
                void *ref = nullptr) {
 
      AudioBoardAction *abo = new AudioBoardAction(board(), key);
      if (abo == nullptr) {
        LOGE("Failed to allocate AudioBoardAction");
        return;
      }
      abo->actionOn = actionOn;
      abo->actionOff = actionOff;
      abo->ref = (ref == nullptr) ? this : ref;
      actions.add(*abo);
    }
 
  void addAction(digital_pin_t pin, void (*action)(bool, digital_pin_t, void *),
                 void *ref = nullptr) {
    TRACEI();
    // determine logic from config
    AudioActions::ActiveLogic activeLogic = getActionLogic(pin);
    actions.add(pin, action, activeLogic, ref == nullptr ? this : ref);
  }
 
  void addAction(digital_pin_t pin, void (*action)(bool, digital_pin_t, void *),
                 AudioActions::ActiveLogic activeLogic, void *ref = nullptr) {
    TRACEI();
    actions.add(pin, action, activeLogic, ref == nullptr ? this : ref);
  }
 
  AudioActions &audioActions() { return actions; }
 
  AudioActions &getActions() { return actions; }
 
  void incrementVolume(float inc) {
    float current_volume = getVolume();
    float new_volume = current_volume + inc;
    LOGI("incrementVolume: %f -> %f", current_volume, new_volume);
    setVolume(new_volume);
  }
 
  static void actionVolumeUp(bool, digital_pin_t, void *ref) {
    TRACEI();
    AudioBoardStream *self = (AudioBoardStream *)ref;
    if (self == nullptr) self = (AudioBoardStream *)p_lastAudioBoardStream;
    self->incrementVolume(+self->actionVolumeIncrementValue());
  }
 
  static void actionVolumeDown(bool, digital_pin_t, void *ref) {
    TRACEI();
    AudioBoardStream *self = (AudioBoardStream *)ref;
    if (self == nullptr) self = (AudioBoardStream *)p_lastAudioBoardStream;
    self->incrementVolume(-self->actionVolumeIncrementValue());
  }
 
  static void actionStartStop(bool, digital_pin_t, void *ref) {
    TRACEI();
    AudioBoardStream *self = (AudioBoardStream *)ref;
    if (self == nullptr) self =  (AudioBoardStream *)p_lastAudioBoardStream;
    self->active = !self->active;
    self->setActive(self->active);
  }
 
  static void actionStart(bool, digital_pin_t, void *ref) {
    TRACEI();
    AudioBoardStream *self = (AudioBoardStream *)ref;
    if (self == nullptr) self =  (AudioBoardStream *)p_lastAudioBoardStream;
    self->active = true;
    self->setActive(self->active);
  }
 
  static void actionStop(bool, digital_pin_t, void *ref) {
    TRACEI();
    AudioBoardStream *self = (AudioBoardStream *)ref;
    if (self == nullptr) self =  (AudioBoardStream *)p_lastAudioBoardStream;
    self->active = false;
    self->setActive(self->active);
  }
 
  static void actionHeadphoneDetection(bool, digital_pin_t, void *ref) {
    AudioBoardStream *self = (AudioBoardStream *)ref;
    if (self == nullptr) self =  (AudioBoardStream *)p_lastAudioBoardStream;
    if (self->pinHeadphoneDetect() != GPIO_NONE) {
      // detect changes
      bool isConnected = self->headphoneStatus();
      if (self->headphoneIsConnected != isConnected) {
        self->headphoneIsConnected = isConnected;
 
        // update if things have stabilized
        bool powerActive = !isConnected;
        LOGW("Headphone jack has been %s",
             isConnected ? "inserted" : "removed");
        self->setSpeakerActive(powerActive);
      }
    }
    delay(1);
  }
 
  digital_pin_t pinAuxin() { return getPinID(PinFunction::AUXIN_DETECT); }
 
  digital_pin_t pinHeadphoneDetect() {
    return getPinID(PinFunction::HEADPHONE_DETECT);
  }
 
  digital_pin_t pinPaEnable() { return getPinID(PinFunction::PA); }
 
  //   /**
  //    * @brief  Get the gpio number for adc detection
  //    *
  //    * @return  -1      non-existent
  //    *          Others  gpio number
  //    */
  //   digital_pin_t pinAdcDetect() { return getPin(AUXIN_DETECT); }
 
  digital_pin_t pinInputRec() { return getPinID(PinFunction::KEY, 1); }
 
  digital_pin_t pinInputMode() { return getPinID(PinFunction::KEY, 2); }
 
  digital_pin_t pinInputSet() { return getPinID(PinFunction::KEY, 4); }
 
  digital_pin_t pinInputPlay() { return getPinID(PinFunction::KEY, 3); }
 
  digital_pin_t pinVolumeUp() { return getPinID(PinFunction::KEY, 6); }
 
  digital_pin_t pinVolumeDown() { return getPinID(PinFunction::KEY, 5); }
 
  digital_pin_t pinLed(int idx) { return getPinID(PinFunction::LED, idx); }
 
  void setSpeakerActive(bool active) { setPAPower(active); }
 
  bool headphoneStatus() {
    digital_pin_t headphoneGpioPin = pinHeadphoneDetect();
    return headphoneGpioPin != GPIO_NONE ? !digitalRead(headphoneGpioPin) : false;
  }
 
  void setActive(bool active) { setMute(!active); }
 
  void addStartStopAction() {
    // pin conflicts for pinInputMode() with the SD CS pin for AIThinker and
    // buttons
    digital_pin_t sd_cs = getSdCsPin();
    digital_pin_t input_mode = pinInputMode();
    if (input_mode != GPIO_NONE && (input_mode != sd_cs || !cfg.sd_active)) {
      LOGD("actionInputMode")
      addAction(input_mode, actionStartStop);
    }
  }
 
  void addVolumeActions() {
    // pin conflicts with SD Lyrat SD CS digital_pin_t and buttons / Conflict on
    // Audiokit V. 2957
    digital_pin_t sd_cs = getSdCsPin();
    digital_pin_t vol_up = pinVolumeUp();
    digital_pin_t vol_down = pinVolumeDown();
    if ((vol_up != GPIO_NONE && vol_down != GPIO_NONE) &&
        (!cfg.sd_active || (vol_down != sd_cs && vol_up != sd_cs))) {
      LOGD("actionVolumeDown")
      addAction(vol_down, actionVolumeDown);
      LOGD("actionVolumeUp")
      addAction(vol_up, actionVolumeUp);
    } else {
      LOGW("Volume Buttons ignored because of conflict");
    }
  }
 
  void addHeadphoneDetectionAction() {
    // pin conflicts with AIThinker A101: key6 and headphone detection
    digital_pin_t head_phone = pinHeadphoneDetect();
    if (head_phone != GPIO_NONE && (getPinID(PinFunction::KEY, 6) != head_phone)) {
      actions.add(head_phone, actionHeadphoneDetection,
                  AudioActions::ActiveChange, this);
    }
  }
 
  void addDefaultActions() {
    TRACEI();
    addHeadphoneDetectionAction();
    addStartStopAction();
    addVolumeActions();
  }
 
  void setActionVolumeIncrementValue(float value) {
    action_increment_value = value;
  }
 
  float actionVolumeIncrementValue() { return action_increment_value; }
 
  bool isKeyPressed(int key) {
    if (!board()) return false;
    return board().isKeyPressed(key);
  }
 
  void setUsePinInterrupt(bool active) { actions.setUsePinInterrupt(active); }
 
 protected:
  static bool readPinCB(digital_pin_t pin, void* ref) {
    return static_cast<AudioBoardStream*>(ref)->digitalRead(pin);
  }
 
  AudioActions actions;
  bool headphoneIsConnected = false;
  bool active = true;
  float action_increment_value = 0.02;
 
  digital_pin_t getSdCsPin() {
    static digital_pin_t sd_cs = GPIO_NONE;
    // execute only once
    if (sd_cs != GPIO_NONE) return sd_cs;
 
    auto sd_opt = getPins().getSPIPins(PinFunction::SD);
    if (sd_opt) {
      sd_cs = sd_opt.value().cs;
    } else {
      // no spi -> no sd
      LOGI("No sd defined -> sd_active=false")
      cfg.sd_active = false;
      sd_cs = GPIO_NONE;
    }
    return sd_cs;
  }
 
  AudioActions::ActiveLogic getActionLogic(digital_pin_t pin) {
    auto opt = board().getPins().getPin(pin);
    PinLogic logic = PinLogic::Input;
    if (opt) logic = opt.value().pin_logic;
    switch (logic) {
      case PinLogic::Input:
      case PinLogic::InputActiveLow:
        return AudioActions::ActiveLow;
      case PinLogic::InputActiveHigh:
        return AudioActions::ActiveHigh;
      case PinLogic::InputActiveTouch:
        return AudioActions::ActiveTouch;
      default:
        return AudioActions::ActiveLow;
    }
  }
};
 
}  // namespace audio_tools