AdvancedADC: Add support for dual ADC mode.

Author: jmdodd95682

src/AdvancedADC.cpp

@@ -97,6 +97,20 @@ static void dac_descr_deinit(adc_descr_t *descr, bool dealloc_pool) {
     }
 }
 
+int AdvancedADC::id() {
+    if (descr) {
+        ADC_TypeDef *adc = descr->adc.Instance;
+        if (adc == ADC1) {
+            return 1;
+        } else if (adc == ADC2) {
+            return 2;
+        } else if (adc == ADC3) {
+            return 3;
+        }
+    }
+    return -1;
+}
+
 bool AdvancedADC::available() {
     if (descr != nullptr) {
         return descr->pool->readable();
@@ -115,9 +129,9 @@ DMABuffer<Sample> &AdvancedADC::read() {
     return NULLBUF;
 }
 
-int AdvancedADC::begin(uint32_t resolution, uint32_t sample_rate, size_t n_samples, size_t n_buffers) {
+int AdvancedADC::begin(uint32_t resolution, uint32_t sample_rate, size_t n_samples, size_t n_buffers, bool start) {
+    
     ADCName instance = ADC_NP;
-
     // Sanity checks.
     if (resolution >= AN_ARRAY_SIZE(ADC_RES_LUT) || (descr && descr->pool)) {
         return 0;
@@ -159,6 +173,8 @@ int AdvancedADC::begin(uint32_t resolution, uint32_t sample_rate, size_t n_sampl
 
     // Configure ADC pins.
     pinmap_pinout(adc_pins[0], PinMap_ADC);
+    
+    //If ADC was not specified ensure the remaining channels are mappable to same ADC
     uint8_t ch_init = 1;
     for (size_t i=1; i<n_channels; i++) {
         for (size_t j=0; j<AN_ARRAY_SIZE(adc_pin_alt); j++) {
@@ -177,7 +193,6 @@ int AdvancedADC::begin(uint32_t resolution, uint32_t sample_rate, size_t n_sampl
             }
         }
     }
-
     // All channels must share the same instance; if not, bail out.
     if (ch_init < n_channels) {
         return 0;
@@ -188,6 +203,8 @@ int AdvancedADC::begin(uint32_t resolution, uint32_t sample_rate, size_t n_sampl
     if (descr->pool == nullptr) {
         return 0;
     }
+
+    // Allocate the two DMA buffers used for double buffering.
     descr->dmabuf[0] = descr->pool->allocate();
     descr->dmabuf[1] = descr->pool->allocate();
 
@@ -212,56 +229,110 @@ int AdvancedADC::begin(uint32_t resolution, uint32_t sample_rate, size_t n_sampl
     hal_dma_enable_dbm(&descr->dma, descr->dmabuf[0]->data(), descr->dmabuf[1]->data());
     HAL_NVIC_EnableIRQ(descr->dma_irqn);
 
-    // Init, config and start the ADC timer.
+    if (start) {
+        return this->start(sample_rate);
+    }
+
+    return id();
+}
+
+int AdvancedADC::start(uint32_t sample_rate){
+    // Initialize and configure the ADC timer.
     hal_tim_config(&descr->tim, sample_rate);
+    
+    // Start the ADC timer. Note, if dual ADC mode is enabled,
+    // this will also start ADC2.
     if (HAL_TIM_Base_Start(&descr->tim) != HAL_OK) {
         return 0;
     }
-    
+
     return 1;
 }
 
-int AdvancedADC::stop()
-{
+int AdvancedADC::stop() {
     dac_descr_deinit(descr, true);
     return 1;
 }
 
-AdvancedADC::~AdvancedADC()
-{
+void AdvancedADC::clear() {
+    if (descr && descr->pool) {
+        descr->pool->flush();
+    }
+}
+
+size_t AdvancedADC::channels() {
+    return n_channels;
+}
+
+AdvancedADC::~AdvancedADC() {
     dac_descr_deinit(descr, true);
 }
 
+int AdvancedADCDual::begin(uint32_t resolution, uint32_t sample_rate, size_t n_samples, size_t n_buffers) {
+    // The two ADCs must have the same number of channels.
+    if (adc1.channels() != adc2.channels()) {
+        return 0;
+    }
+
+    // Configure the ADCs.
+    // Note only ADC1 (master) and ADC2 can be used in dual mode.
+    if (adc1.begin(resolution, sample_rate, n_samples, n_buffers, false) != 1) {
+        return 0;
+    }
+
+    if (adc2.begin(resolution, sample_rate, n_samples, n_buffers, false) != 2) {
+        return -3;
+    }
+
+    // Enable dual ADC mode.
+    hal_adc_enable_dual_mode(true);
+
+    // Start ADC1, note ADC2 is also automatically started.
+    return adc1.start(sample_rate);
+}
+
+int AdvancedADCDual:: stop(){
+    adc1.stop();
+    adc2.stop();
+    // Disable dual mode.
+    hal_adc_enable_dual_mode(false);
+    return 1;
+}
+
+AdvancedADCDual::~AdvancedADCDual(){
+    stop();
+}
+
 extern "C" {
-void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *adc) {
-    adc_descr_t *descr = adc_descr_get(adc->Instance);
-    // NOTE: CT bit is inverted, to get the DMA buffer that's Not currently in use.
-    size_t ct = ! hal_dma_get_ct(&descr->dma);
+    void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *adc) {
+        adc_descr_t *descr = adc_descr_get(adc->Instance);
+        // NOTE: CT bit is inverted, to get the DMA buffer that's Not currently in use.
+        size_t ct = ! hal_dma_get_ct(&descr->dma);
 
-    // Timestamp the buffer.
-    descr->dmabuf[ct]->timestamp(us_ticker_read());
+        // Timestamp the buffer.
+        descr->dmabuf[ct]->timestamp(us_ticker_read());
 
-    if (descr->pool->writable()) {
-        // Make sure any cached data is discarded.
-        descr->dmabuf[ct]->invalidate();
+        if (descr->pool->writable()) {
+            // Make sure any cached data is discarded.
+            descr->dmabuf[ct]->invalidate();
 
-        // Move current DMA buffer to ready queue.
-        descr->pool->enqueue(descr->dmabuf[ct]);
+            // Move current DMA buffer to ready queue.
+            descr->pool->enqueue(descr->dmabuf[ct]);
 
-        // Allocate a new free buffer.
-        descr->dmabuf[ct] = descr->pool->allocate();
+            // Allocate a new free buffer.
+            descr->dmabuf[ct] = descr->pool->allocate();
 
-        // Currently, all multi-channel buffers are interleaved.
-        if (descr->dmabuf[ct]->channels() > 1) {
-            descr->dmabuf[ct]->setflags(DMA_BUFFER_INTRLVD);
+            // Currently, all multi-channel buffers are interleaved.
+            if (descr->dmabuf[ct]->channels() > 1) {
+                descr->dmabuf[ct]->setflags(DMA_BUFFER_INTRLVD);
+            }
+        } else {
+            descr->dmabuf[ct]->setflags(DMA_BUFFER_DISCONT);
         }
-    } else {
-        descr->dmabuf[ct]->setflags(DMA_BUFFER_DISCONT);
-    }
 
-    // Update the next DMA target pointer.
-    // NOTE: If the pool was empty, the same buffer is reused.
-    hal_dma_update_memory(&descr->dma, descr->dmabuf[ct]->data());
-}
+        // Update the next DMA target pointer.
+        // NOTE: If the pool was empty, the same buffer is reused.
+        hal_dma_update_memory(&descr->dma, descr->dmabuf[ct]->data());
+    }
 
 } // extern C

src/AdvancedADC.h

@@ -41,24 +41,44 @@ class AdvancedADC {
             for (auto p : {p0, args...}) {
                 adc_pins[n_channels++] = analogPinToPinName(p);
             }
-        }
         AdvancedADC(): n_channels(0), descr(nullptr) {
         }
         ~AdvancedADC();
+        int id();
         bool available();
         SampleBuffer read();
-        int begin(uint32_t resolution, uint32_t sample_rate, size_t n_samples, size_t n_buffers);
-        int begin(uint32_t resolution, uint32_t sample_rate, size_t n_samples, size_t n_buffers,
-                size_t n_pins, pin_size_t *pins) {
+        int begin(uint32_t resolution, uint32_t sample_rate, size_t n_samples,
+                size_t n_buffers, bool start=true);
+        int begin(uint32_t resolution, uint32_t sample_rate, size_t n_samples,
+                size_t n_buffers, size_t n_pins, pin_size_t *pins, bool start=true) {
             if (n_pins > AN_MAX_ADC_CHANNELS) {
                 n_pins = AN_MAX_ADC_CHANNELS;
             }
             for (size_t i = 0; i < n_pins; ++i) {
                 adc_pins[i] = analogPinToPinName(pins[i]);
             }
+
             n_channels = n_pins;
-            return begin(resolution, sample_rate, n_samples, n_buffers);
+            return begin(resolution, sample_rate, n_samples, n_buffers, start);
+        }
+        int start(uint32_t sample_rate);
+        int stop();
+        void clear();
+        size_t channels();
+};
+
+class AdvancedADCDual {
+    private:
+        AdvancedADC &adc1;
+        AdvancedADC &adc2;
+        size_t n_channels;
+
+    public:
+        AdvancedADCDual(AdvancedADC &adc1_in, AdvancedADC &adc2_in):
+            n_channels(0), adc1(adc1_in), adc2(adc2_in) {
         }
+        ~AdvancedADCDual();
+        int begin(uint32_t resolution, uint32_t sample_rate, size_t n_samples, size_t n_buffers);
         int stop();
 };
 

src/HALConfig.cpp

@@ -173,7 +173,7 @@ static uint32_t ADC_RANK_LUT[] = {
 int hal_adc_config(ADC_HandleTypeDef *adc, uint32_t resolution, uint32_t trigger, PinName *adc_pins, uint32_t n_channels) {
     // Set ADC clock source.
     __HAL_RCC_ADC_CONFIG(RCC_ADCCLKSOURCE_CLKP);
-
+   
     // Enable ADC clock
     if (adc->Instance == ADC1) {
         __HAL_RCC_ADC12_CLK_ENABLE();
@@ -209,7 +209,7 @@ int hal_adc_config(ADC_HandleTypeDef *adc, uint32_t resolution, uint32_t trigger
     sConfig.OffsetNumber = ADC_OFFSET_NONE;
     sConfig.SingleDiff   = ADC_SINGLE_ENDED;
     sConfig.SamplingTime = ADC_SAMPLETIME_8CYCLES_5;
-
+    
     for (size_t rank=0; rank<n_channels; rank++) {
         uint32_t function = pinmap_function(adc_pins[rank], PinMap_ADC);
         uint32_t channel = STM_PIN_CHANNEL(function);
@@ -223,6 +223,16 @@ int hal_adc_config(ADC_HandleTypeDef *adc, uint32_t resolution, uint32_t trigger
     return 0;
 }
 
+int hal_adc_enable_dual_mode(bool enable) {
+    if (enable) {
+        LL_ADC_SetMultimode(__LL_ADC_COMMON_INSTANCE(ADC1), LL_ADC_MULTI_DUAL_REG_SIMULT);
+    } else {
+        LL_ADC_SetMultimode(__LL_ADC_COMMON_INSTANCE(ADC1), LL_ADC_MULTI_INDEPENDENT);
+    }
+    return 0;
+}
+
+
 int hal_i2s_config(I2S_HandleTypeDef *i2s, uint32_t sample_rate, uint32_t mode, bool mck_enable) {
     // Set I2S clock source.
     RCC_PeriphCLKInitTypeDef pclk_init = {0};

src/HALConfig.h

@@ -30,6 +30,7 @@ void hal_dma_enable_dbm(DMA_HandleTypeDef *dma, void *m0 = nullptr, void *m1 = n
 void hal_dma_update_memory(DMA_HandleTypeDef *dma, void *addr);
 int hal_dac_config(DAC_HandleTypeDef *dac, uint32_t channel, uint32_t trigger);
 int hal_adc_config(ADC_HandleTypeDef *adc, uint32_t resolution, uint32_t trigger, PinName *adc_pins, uint32_t n_channels);
+int hal_adc_enable_dual_mode(bool enable);
 int hal_i2s_config(I2S_HandleTypeDef *i2s, uint32_t sample_rate, uint32_t mode, bool mck_enable);
 
 #endif  // __HAL_CONFIG_H__