SAMDCurrentSenseADCDMA class

Author: maxlem

src/current_sense/LowSideCurrentSense.cpp

@@ -55,8 +55,8 @@ PhaseCurrent_s LowSideCurrentSense::getPhaseCurrents(){
     // current.b = (_readADCVoltage(pinB) - offset_ib)*gain_b;// amps
     // current.c = (!_isset(pinC)) ? 0 : (_readADCVoltage(pinC) - offset_ic)*gain_c; // amps
 
-    adc._read3PinsDMA(pinA, pinB, pinC, current.a, current.b, current.c);
-    adc._start3PinsDMA();
+    adc.readResults(current.a, current.b, current.c);
+    adc.startADCScan();
 
     return current;
 }

src/current_sense/LowSideCurrentSense.h

@@ -53,7 +53,7 @@ class LowSideCurrentSense: public CurrentSense{
     double offset_ib; //!< zero current B voltage value (center of the adc reading)
     double offset_ic; //!< zero current C voltage value (center of the adc reading)
 
-    SAMDCurrentSensceADC adc;
+    SAMDCurrentSenseADCDMA adc;
 
 };
 

src/current_sense/hardware_specific/samd21_mcu.cpp

@@ -1,9 +1,10 @@
 
 #include "samd21_mcu.h"
 
+ // Credit: significant portions of this code were pulled from Paul Gould's git https://github.com/gouldpa/FOC-Arduino-Brushless
 
-void adc_stop_with_DMA(void);
-void adc_start_with_DMA(void);
+static void adcStopWithDMA(void);
+static void adcStartWithDMA(void);
 
 /**
  * @brief  ADC sync wait 
@@ -16,91 +17,66 @@ static void   ADCsync() {
 
 //  ADC DMA sequential free running (6) with Interrupts /////////////////
 
-typedef struct {
-  uint16_t btctrl;
-  uint16_t btcnt;
-  uint32_t srcaddr;
-  uint32_t dstaddr;
-  uint32_t descaddr;
-} dmacdescriptor ;
-volatile dmacdescriptor wrb[12] __attribute__ ((aligned (16)));
-dmacdescriptor descriptor_section[12] __attribute__ ((aligned (16)));
-dmacdescriptor descriptor __attribute__ ((aligned (16)));
-DmacDescriptor *desc; // DMA descriptor address (so we can change contents)
 
 
 
-SAMDCurrentSensceADC::SAMDCurrentSensceADC(int pinA, int pinB, int pinC, float arefaVoltage, uint32_t adcBits) 
-: _ADC_VOLTAGE(arefaVoltage), _ADC_RESOLUTION(1 << adcBits)
+
+SAMDCurrentSenseADCDMA::SAMDCurrentSenseADCDMA(int pinA, int pinB, int pinC, int pinAREF, float voltageAREF, uint32_t adcBits, uint32_t channelDMA) 
+: pinA(pinA), pinB(pinB), pinC(pinC), pinAREF(pinAREF), channelDMA(channelDMA), voltageAREF(voltageAREF), maxCountsADC(1 << adcBits)
 {
-  ADC_CONV_ = ( _ADC_VOLTAGE / _ADC_RESOLUTION );
-  this->pinA = pinA;
-  this->pinB = pinB;
-  this->pinC = pinC;
+  countsToVolts = ( voltageAREF / maxCountsADC );
 }
 
-void SAMDCurrentSensceADC::init()
-{
-  _configure3PinsDMA();
-  _start3PinsDMA(); //s
+void SAMDCurrentSenseADCDMA::init(){
+  initPins();
+  initADC();
+  initDMA();
+  startADCScan(); //so we have something to read next time we call readResults()
 }
 
 
-void SAMDCurrentSensceADC::_start3PinsDMA()
-{
-  adc_dma(adcBuffer + ADC_OneBeforeFirstPin, BufferSize);
-  adc_start_with_DMA();
+void SAMDCurrentSenseADCDMA::startADCScan(){
+  adcToDMATransfer(adcBuffer + oneBeforeFirstAIN, BufferSize);
+  adcStartWithDMA();
 }
-void SAMDCurrentSensceADC::_read3PinsDMA(const int pinA,const int pinB,const int pinC, float & a, float & b, float & c)
-{
+
+void SAMDCurrentSenseADCDMA::readResults(float & a, float & b, float & c){
   while(ADC->CTRLA.bit.ENABLE) ;
-  uint32_t adcA = g_APinDescription[pinA].ulADCChannelNumber;
-  uint32_t adcB = g_APinDescription[pinB].ulADCChannelNumber;
-  a = adcBuffer[adcA] * ADC_CONV_;
-  b = adcBuffer[adcB] * ADC_CONV_;
+  uint32_t ainA = g_APinDescription[pinA].ulADCChannelNumber;
+  uint32_t ainB = g_APinDescription[pinB].ulADCChannelNumber;
+  uint32_t ainC = g_APinDescription[pinC].ulADCChannelNumber;
+  a = adcBuffer[ainA] * countsToVolts;
+  b = adcBuffer[ainB] * countsToVolts;
   if(_isset(pinC))
   {
-    uint32_t adcC = g_APinDescription[pinC].ulADCChannelNumber;
-    c = adcBuffer[adcC] * ADC_CONV_;
+    c = adcBuffer[ainC] * countsToVolts;
   }
 }
 
-// function reading an ADC value and returning the read voltage
-void SAMDCurrentSensceADC::_configure3PinsDMA(){
+void SAMDCurrentSenseADCDMA::initPins(){
 
-  uint32_t adcA = g_APinDescription[pinA].ulADCChannelNumber;
-  uint32_t adcB = g_APinDescription[pinB].ulADCChannelNumber;
-  uint32_t adcC = g_APinDescription[pinC].ulADCChannelNumber;
-
-  pinMode(42, INPUT);
-  ADC_FirstPin = min(adcA, adcB);
-  ADC_LastPin = max(adcA, adcB);
+  pinMode(pinAREF, INPUT);
   pinMode(pinA, INPUT);
   pinMode(pinB, INPUT);
+
+  uint32_t ainA = g_APinDescription[pinA].ulADCChannelNumber;
+  uint32_t ainB = g_APinDescription[pinB].ulADCChannelNumber;
+  uint32_t ainC = g_APinDescription[pinC].ulADCChannelNumber;
+  firstAIN = min(ainA, ainB);
+  lastAIN = max(ainA, ainB);
   if( _isset(pinC) ) 
   {
     pinMode(pinC, INPUT);
-    ADC_FirstPin = min(ADC_FirstPin, adcC);
-    ADC_LastPin = max(ADC_LastPin, adcC);
+    firstAIN = min(firstAIN, ainC);
+    lastAIN = max(lastAIN, ainC);
   }
 
-  ADC_OneBeforeFirstPin = ADC_FirstPin - 1; //hack to discard noisy first readout
-  BufferSize = ADC_LastPin - ADC_OneBeforeFirstPin + 1;
+  oneBeforeFirstAIN = firstAIN - 1; //hack to discard noisy first readout
+  BufferSize = lastAIN - oneBeforeFirstAIN + 1;
 
-  // ADC and DMA
-  adc_init();
-  dma_init();
 }
 
-
-
-
-
-/**
- * @brief  Initialize ADC
- * @retval void
- */
-void SAMDCurrentSensceADC::adc_init(){
+void SAMDCurrentSenseADCDMA::initADC(){
 
   analogRead(pinA);  // do some pin init  pinPeripheral() 
   analogRead(pinB);  // do some pin init  pinPeripheral() 
@@ -155,9 +131,9 @@ void SAMDCurrentSensceADC::adc_init(){
   0x1C DAC DAC output
   0x1D-0x1F Reserved
   */
-  ADC->INPUTCTRL.bit.MUXPOS = ADC_OneBeforeFirstPin;
+  ADC->INPUTCTRL.bit.MUXPOS = oneBeforeFirstAIN;
   ADCsync();
-  ADC->INPUTCTRL.bit.INPUTSCAN = ADC_LastPin; // so the adc will scan from AIN[1] to AIN[ADC_Number+1] 
+  ADC->INPUTCTRL.bit.INPUTSCAN = lastAIN; // so the adc will scan from oneBeforeFirstAIN to lastAIN (inclusive) 
   ADCsync();
   ADC->INPUTCTRL.bit.INPUTOFFSET = 0; //input scan cursor
   ADCsync();
@@ -169,12 +145,9 @@ void SAMDCurrentSensceADC::adc_init(){
   ADCsync();
 }
 
+volatile dmacdescriptor wrb[12] __attribute__ ((aligned (16)));
 
-/**
- * @brief  dma_init
- * @retval void
- */
-void SAMDCurrentSensceADC::dma_init() {
+void SAMDCurrentSenseADCDMA::initDMA() {
   // probably on by default
   PM->AHBMASK.reg |= PM_AHBMASK_DMAC ;
   PM->APBBMASK.reg |= PM_APBBMASK_DMAC ;
@@ -184,68 +157,46 @@ void SAMDCurrentSensceADC::dma_init() {
   DMAC->CTRL.reg = DMAC_CTRL_DMAENABLE | DMAC_CTRL_LVLEN(0xf);
 }
 
-/**
- * @brief  adc_dma 
- * @retval void
- */
-void SAMDCurrentSensceADC::adc_dma(void *rxdata,  size_t hwords) {
-  uint32_t temp_CHCTRLB_reg;
 
-  DMAC->CHID.reg = DMAC_CHID_ID(ADC_DMA_chnl);
+void SAMDCurrentSenseADCDMA::adcToDMATransfer(void *rxdata,  size_t hwords) {
+
+  DMAC->CHID.reg = DMAC_CHID_ID(channelDMA);
   DMAC->CHCTRLA.reg &= ~DMAC_CHCTRLA_ENABLE;
   DMAC->CHCTRLA.reg = DMAC_CHCTRLA_SWRST;
-  DMAC->SWTRIGCTRL.reg &= (uint32_t)(~(1 << ADC_DMA_chnl));
-  temp_CHCTRLB_reg = DMAC_CHCTRLB_LVL(0) |
-  DMAC_CHCTRLB_TRIGSRC(ADC_DMAC_ID_RESRDY) | DMAC_CHCTRLB_TRIGACT_BEAT;
-  DMAC->CHCTRLB.reg = temp_CHCTRLB_reg;
+  DMAC->SWTRIGCTRL.reg &= (uint32_t)(~(1 << channelDMA));
+  
+  DMAC->CHCTRLB.reg = DMAC_CHCTRLB_LVL(0) 
+  | DMAC_CHCTRLB_TRIGSRC(ADC_DMAC_ID_RESRDY) 
+  | DMAC_CHCTRLB_TRIGACT_BEAT;
   DMAC->CHINTENSET.reg = DMAC_CHINTENSET_MASK ; // enable all 3 interrupts
   descriptor.descaddr = 0;
   descriptor.srcaddr = (uint32_t) &ADC->RESULT.reg;
   descriptor.btcnt =  hwords;
   descriptor.dstaddr = (uint32_t)rxdata + hwords*2;   // end address
   descriptor.btctrl =  DMAC_BTCTRL_BEATSIZE_HWORD | DMAC_BTCTRL_DSTINC | DMAC_BTCTRL_VALID;
-  memcpy(&descriptor_section[ADC_DMA_chnl],&descriptor, sizeof(dmacdescriptor));
+  memcpy(&descriptor_section[channelDMA],&descriptor, sizeof(dmacdescriptor));
 
   // start channel
-  DMAC->CHID.reg = DMAC_CHID_ID(ADC_DMA_chnl);
+  DMAC->CHID.reg = DMAC_CHID_ID(channelDMA);
   DMAC->CHCTRLA.reg |= DMAC_CHCTRLA_ENABLE;
 }
 
 
-
-
-/**
- * @brief  adc_stop_with_DMA
- * @retval void
- */
-void adc_stop_with_DMA(void)
-{
+void adcStopWithDMA(void){
   ADC->CTRLA.bit.ENABLE = 0x00;
-  // SerialUSB.println("DMA stopped!");
 }
 
-/**
- * @brief  adc_start_with_DMA
- * @retval void
- */
-void adc_start_with_DMA(void)
-{
-  // SerialUSB.println("strating DMA...");
-  // ADC->INPUTCTRL.bit.MUXPOS = ADC_OneBeforeFirstPin;
-  // ADC->INPUTCTRL.bit.INPUTSCAN = ADC_LastPin;
+void adcStartWithDMA(void){
   ADC->INPUTCTRL.bit.INPUTOFFSET = 0;
   ADC->SWTRIG.bit.FLUSH = 1;
   ADC->CTRLA.bit.ENABLE = 0x01; 
 }
-/**
- * @brief  DMAC_Handler
- * @retval void
- */
+
 void DMAC_Handler() {
   uint8_t active_channel;
   active_channel =  DMAC->INTPEND.reg & DMAC_INTPEND_ID_Msk; // get channel number
   DMAC->CHID.reg = DMAC_CHID_ID(active_channel);
-  adc_stop_with_DMA();
+  adcStopWithDMA();
   DMAC->CHINTFLAG.reg = DMAC_CHINTENCLR_TCMPL; // clear
   DMAC->CHINTFLAG.reg = DMAC_CHINTENCLR_TERR;
   DMAC->CHINTFLAG.reg = DMAC_CHINTENCLR_SUSP;

src/current_sense/hardware_specific/samd21_mcu.h

@@ -1,60 +1,52 @@
 
 #include "../hardware_api.h"
 
-
-class SAMDCurrentSensceADC
+  typedef struct {
+    uint16_t btctrl;
+    uint16_t btcnt;
+    uint32_t srcaddr;
+    uint32_t dstaddr;
+    uint32_t descaddr;
+  } dmacdescriptor ;
+
+class SAMDCurrentSenseADCDMA
 {
 
 public:
 
-  SAMDCurrentSensceADC(int pinA, int pinB, int pinC, float arefaVoltage = 3.3, uint32_t adcBits = 12);
+  SAMDCurrentSenseADCDMA(int pinA, int pinB, int pinC, int pinAREF = 42, float voltageAREF = 3.3, uint32_t adcBits = 12, uint32_t channelDMA = 3);
 
   void init();
-  // this code was pulled from Paul Gould's git https://github.com/gouldpa/FOC-Arduino-Brushless
-  uint32_t ADC_OneBeforeFirstPin; // hack to discard first noisy readout
-  uint32_t ADC_FirstPin; // PA04
-  uint32_t ADC_LastPin;  // PA06
-  uint32_t BufferSize = 0;
-
-  uint16_t adcBuffer[20];
-
-
-  uint32_t pinA = A4;
-  uint32_t pinB = A5;
-  uint32_t pinC = 8;
-
-  float _ADC_VOLTAGE;
-  float _ADC_RESOLUTION;
-  float ADC_CONV_;
+  void startADCScan();
+  void readResults(float & a, float & b, float & c);
 
-  void _start3PinsDMA();
-  void _read3PinsDMA(const int pinA,const int pinB,const int pinC, float & a, float & b, float & c);
-  // function reading an ADC value and returning the read voltage
-  void _configure3PinsDMA();
+private:
 
+  void adcToDMATransfer(void *rxdata,  size_t hwords);
 
+  void initPins();
+  void initADC();
+  void initDMA();
+ 
+  uint32_t oneBeforeFirstAIN; // hack to discard first noisy readout
+  uint32_t firstAIN;
+  uint32_t lastAIN; 
+  uint32_t BufferSize = 0;
 
-
-  uint32_t ADC_DMA_chnl = 3;  // DMA channel
-
-
-  /**
-   * @brief  Initialize ADC
-   * @retval void
-   */
-  void adc_init();
+  uint16_t adcBuffer[20];
 
 
-  /**
-   * @brief  dma_init
-   * @retval void
-   */
-  void dma_init();
+  uint32_t pinA;
+  uint32_t pinB;
+  uint32_t pinC;
+  uint32_t pinAREF;
+  uint32_t channelDMA;  // DMA channel
 
-  /**
-   * @brief  adc_dma 
-   * @retval void
-   */
-  void adc_dma(void *rxdata,  size_t hwords);
+  float voltageAREF;
+  float maxCountsADC;
+  float countsToVolts;
+  
+  dmacdescriptor descriptor_section[12] __attribute__ ((aligned (16)));
+  dmacdescriptor descriptor __attribute__ ((aligned (16)));
 
 };