AutoAnalogAudio.h

Go to the documentation of this file.

    /*
    AutoAnalogAudio streaming via DAC & ADC by TMRh20
    Copyright (C) 2016-2020  TMRh20 - tmrh20@gmail.com, github.com/TMRh20
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
    */
#ifndef __AUTO_ANALOG_H__
#define __AUTO_ANALOG_H__
 
#include "AutoAnalog_config.h"
#if defined (ESP32)
  #include "driver/i2s.h"
#endif
 
 
#define AAA_CHANNEL0 0
#define AAA_CHANNEL1 1
#define AAA_MODE_STEREO 2
 
class AutoAnalog
{
 
public:
 
  AutoAnalog();
 
  void begin(bool enADC, bool enDAC);
 
  void triggerADC();
 
  void getADC(uint32_t samples = MAX_BUFFER_SIZE);
 
  void feedDAC(uint8_t dacChannel = 0, uint32_t samples = MAX_BUFFER_SIZE, bool startInterrupts = false);
 
  uint8_t dacBuffer[MAX_BUFFER_SIZE];
 
  uint8_t adcBuffer[MAX_BUFFER_SIZE];
 
  uint16_t dacBuffer16[MAX_BUFFER_SIZE];
 
  #if !defined (ARDUINO_ARCH_NRF52840) && !defined (ARDUINO_ARCH_NRF52) && !defined ARDUINO_NRF52840_FEATHER
  uint16_t adcBuffer16[MAX_BUFFER_SIZE];
  #elif defined __MBED__
  inline static uint16_t adcBuffer16[MAX_BUFFER_SIZE];  
  #else
  static uint16_t adcBuffer16[MAX_BUFFER_SIZE];
  #endif
  
  void setSampleRate(uint32_t sampRate = 0, bool stereo = true);
 
  void dacHandler(void);
 
  bool autoAdjust;
 
 
  uint8_t adcBitsPerSample;
 
  uint8_t dacBitsPerSample;
 
  void enableAdcChannel(uint8_t pinAx);
 
  void disableAdcChannel(uint8_t pinAx);
 
  void disableDAC(bool withinTask = false);
 
  void adcInterrupts(bool enabled = true);
 
  void dacInterrupts(bool enabled = true, bool withinTask = false);
 
  #if defined (ESP32) || defined (DOXYGEN_FORCED)
  void rampOut(uint8_t sample);
  void rampIn(uint8_t sample);
  TaskHandle_t dacTaskHandle;
  #endif
 
#if defined (ARDUINO_ARCH_NRF52840) || defined (ARDUINO_ARCH_NRF52) && !defined ARDUINO_NRF52840_FEATHER && defined __MBED__
  inline static uint8_t aCtr;
  inline static uint32_t aSize;
  inline static uint16_t *buf0 = NULL;
  inline static uint16_t *buf1 = NULL;
  inline static void (*_onReceive)(uint16_t *buf, uint32_t buf_len) = NULL;
  inline static void adcCallback(uint16_t *buf, uint32_t buf_len);
  inline static void set_callback(void(*function)(uint16_t *buf, uint32_t buf_len));
  inline static bool adcReady;
  inline static uint16_t dacBuf0[MAX_BUFFER_SIZE];
  inline static uint16_t dacBuf1[MAX_BUFFER_SIZE];
  bool micOn;
  int pwrPin;
  int dinPin;
  int clkPin;
  int8_t gain;
  inline static uint32_t sampleCounter;
  
#elif defined (ARDUINO_ARCH_NRF52840) || defined (ARDUINO_ARCH_NRF52) || defined (ARDUINO_NRF52840_FEATHER) && !defined __MBED__
  uint16_t dacBuf0[MAX_BUFFER_SIZE];
  uint16_t dacBuf1[MAX_BUFFER_SIZE];
  static uint8_t aCtr;
  static uint32_t aSize;
  static uint16_t *buf0;
  static uint16_t *buf1;
  static void (*_onReceive)(uint16_t *buf, uint32_t buf_len);
  static void adcCallback(uint16_t *buf, uint32_t buf_len);
  void set_callback(void(*function)(uint16_t *buf, uint32_t buf_len));
  static bool adcReady;
  bool micOn;
  int pwrPin;
  int dinPin;
  int clkPin;
  int8_t gain;
  uint32_t sampleCounter;
  //void DACC_Handler();
#endif
 
private:
 
#if defined (ARDUINO_ARCH_SAM) 
  bool whichDma = 0;
  bool whichDac;
  bool dacChan;
 
  uint8_t aCtr = 0;                    /* Internal counter for ADC data */
  uint16_t realBuf[MAX_BUFFER_SIZE];   /* Internal DAC buffer */
  uint16_t adcDma[MAX_BUFFER_SIZE]; /* Buffers for ADC DMA transfers */
  uint16_t dataReady;                  /* Internal indicator for DAC data */
 
  uint32_t dataTimer;                  /* Internal timer tracks timing of incoming data */
  uint32_t sampleCount;                /* Internal counter for delaying analysis of timing */
  uint32_t tcTicks;                    /* Stores the current TC0 Ch0 counter value */
  uint32_t tcTicks2;                   /* Stores the current TC0 Ch1 counter value */
  uint32_t adjustDivider;              /* Internal variables for adjusting timers on-the-fly */
 
  uint32_t dacNumSamples;              /* Internal variable for number of samples sent to the DAC */
  uint32_t adcNumSamples;
  uint16_t adjustCtr;                  /* Internal variables for adjusting timers on-the-fly */
  uint16_t adjustCtr2;                 /* Internal variables for adjusting timers on-the-fly */
  uint32_t adcLastAdjust;
#endif
  void adcSetup(void);                 /* Enable the ADC */
  void dacSetup(void);                 /* Enable the DAC */
 
  void dacBufferStereo(uint8_t dacChannel);
 
  void tcSetup(uint32_t sampRate = 0);      /* Sets up Timer TC0 Channel 0 */
  void tc2Setup(uint32_t sampRate = 0);     /* Sets up Timer TC0 Channel 1 */
 
  uint32_t frequencyToTimerCount(uint32_t Frequency); /* Function to calculate timer counters */
 
#if defined ESP32
 
  uint32_t sampleRate;
  i2s_config_t i2s_cfg;
 
  bool i2sStopped;
  adc1_channel_t adcChannel;
 
  bool taskCreated;
 
  bool dacEnabled;
  uint8_t lastDacSample;
  i2s_event_t myI2SQueue[5];
  //void dacTask(void *args);
 
  bool adcTaskCreated;
  bool adcDisabled;
 
  #define DELAY_250MS (250 / portTICK_PERIOD_MS)
 
#endif
};
 
 
 
#endif