DMA with ADC for continuous sampling in Embedded C

Introduction

DMA with ADC lets your microcontroller collect data continuously without using the CPU all the time. This saves power and makes your program faster.

You want to measure sensor data like temperature or light continuously.

You need to record analog signals without missing any samples.

You want to free the CPU to do other tasks while data is collected.

You want smooth and fast data collection for real-time processing.

You want to avoid delays caused by manual reading of ADC values.

Syntax

Embedded C

1. Configure ADC for continuous conversion mode.
2. Set up DMA to transfer ADC data to memory buffer.
3. Enable DMA and ADC.
4. Start ADC conversion.
5. Use interrupts or polling to process data when buffer is full.

DMA automatically moves ADC data to memory without CPU help.

Continuous mode means ADC keeps sampling without stopping.

Examples

This sets the ADC to keep sampling automatically.

Embedded C

/* Configure ADC in continuous mode */
ADC_InitTypeDef ADC_InitStruct = {0};
ADC_InitStruct.ContinuousConvMode = ENABLE;
ADC_Init(&ADC_InitStruct);

DMA is set to circular mode to keep filling the buffer repeatedly.

Embedded C

/* Configure DMA to transfer ADC data to buffer */
DMA_InitTypeDef DMA_InitStruct = {0};
DMA_InitStruct.Direction = DMA_PERIPH_TO_MEMORY;
DMA_InitStruct.PeriphInc = DMA_PINC_DISABLE;
DMA_InitStruct.MemInc = DMA_MINC_ENABLE;
DMA_InitStruct.Mode = DMA_CIRCULAR;
DMA_InitStruct.BufferSize = BUFFER_SIZE;
DMA_Init(&DMA_InitStruct);

This starts the ADC conversions and DMA transfers.

Embedded C

/* Start ADC and DMA */
DMA_Cmd(ENABLE);
ADC_Cmd(ENABLE);
ADC_SoftwareStartConv();

Sample Program

This program sets up ADC1 to sample channel 0 continuously. DMA2 Stream0 moves ADC data to adc_buffer in circular mode. The CPU can use adc_buffer anytime without stopping ADC.

Embedded C

#include "stm32f4xx.h"

#define BUFFER_SIZE 10
uint16_t adc_buffer[BUFFER_SIZE];

void ADC_DMA_Config(void) {
    // Enable clocks
    RCC->AHB1ENR |= RCC_AHB1ENR_DMA2EN;
    RCC->APB2ENR |= RCC_APB2ENR_ADC1EN;

    // Configure DMA2 Stream0 for ADC1
    DMA2_Stream0->CR = 0;
    DMA2_Stream0->PAR = (uint32_t)&ADC1->DR; // ADC data register
    DMA2_Stream0->M0AR = (uint32_t)adc_buffer; // Memory buffer
    DMA2_Stream0->NDTR = BUFFER_SIZE;
    DMA2_Stream0->CR |= DMA_SxCR_CHSEL_0; // Channel 0 for ADC1
    DMA2_Stream0->CR |= DMA_SxCR_MINC; // Memory increment
    DMA2_Stream0->CR |= DMA_SxCR_CIRC; // Circular mode
    DMA2_Stream0->CR |= DMA_SxCR_PL_1; // Priority high
    DMA2_Stream0->CR |= DMA_SxCR_DIR_0; // Peripheral to memory
    DMA2_Stream0->CR |= DMA_SxCR_EN; // Enable DMA stream

    // Configure ADC1
    ADC1->CR2 = 0;
    ADC1->CR2 |= ADC_CR2_DMA;
    ADC1->CR2 |= ADC_CR2_DDS; // DMA requests continuous
    ADC1->CR2 |= ADC_CR2_CONT; // Continuous conversion
    ADC1->SQR3 = 0; // Channel 0
    ADC1->SMPR2 = ADC_SMPR2_SMP0_0 | ADC_SMPR2_SMP0_1; // Sample time

    ADC1->CR2 |= ADC_CR2_ADON; // Enable ADC
    for (volatile int i=0; i<1000; i++); // Delay
    ADC1->CR2 |= ADC_CR2_SWSTART; // Start conversion
}

int main(void) {
    ADC_DMA_Config();

    while(1) {
        // Main loop can process adc_buffer data
        // For example, check adc_buffer[0] value
        if (adc_buffer[0] > 2000) {
            // Do something
        }
    }
}

Important Notes

Make sure DMA and ADC clocks are enabled before configuration.

Use circular DMA mode to keep filling the buffer without stopping.

Remember to set ADC sample time to get stable readings.

Summary

DMA with ADC lets you collect analog data continuously without CPU load.

Configure ADC in continuous mode and DMA in circular mode for smooth data flow.

Use the buffer filled by DMA to process data anytime in your program.

Practice

1. What is the main advantage of using DMA with ADC in continuous sampling mode?

easy

A. It disables ADC interrupts to save power.

B. It transfers ADC data to memory automatically without CPU intervention.

C. It allows manual control of each ADC conversion.

D. It increases the ADC resolution beyond hardware limits.

Solution

1. Step 1: Understand DMA role with ADC

   DMA (Direct Memory Access) moves data from ADC to memory automatically, reducing CPU load.

2. Step 2: Identify continuous sampling benefit

   Continuous mode means ADC keeps sampling without CPU restarting it each time.

3. Final Answer:

   It transfers ADC data to memory automatically without CPU intervention. -> Option B

4. Quick Check:

   DMA automates data transfer = It transfers ADC data to memory automatically without CPU intervention. [OK]

Hint: DMA automates ADC data transfer, no CPU needed [OK]

Common Mistakes:

• Thinking DMA increases ADC resolution
• Confusing manual and automatic data transfer
• Assuming DMA disables ADC interrupts

2. Which of the following is the correct way to configure DMA for circular mode with ADC in embedded C?

easy

A. DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;

B. DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;

C. DMA_InitStructure.DMA_Mode = DMA_Mode_Manual;

D. DMA_InitStructure.DMA_Mode = DMA_Mode_Interrupt;

Solution

1. Step 1: Recall DMA modes for continuous ADC sampling

   DMA_Mode_Circular allows buffer to be reused endlessly for continuous data.

2. Step 2: Match correct DMA mode setting

   DMA_Mode_Normal stops after one transfer; DMA_Mode_Circular repeats automatically.

3. Final Answer:

   DMA_InitStructure.DMA_Mode = DMA_Mode_Circular; -> Option A

4. Quick Check:

   Circular mode enables continuous buffer reuse = DMA_InitStructure.DMA_Mode = DMA_Mode_Circular; [OK]

Hint: Use DMA_Mode_Circular for endless ADC data buffering [OK]

Common Mistakes:

• Using DMA_Mode_Normal for continuous sampling
• Confusing DMA_Mode_Manual which doesn't exist
• Selecting interrupt mode instead of circular

3. Given the following code snippet, what will be the content of the buffer after 3 ADC conversions with DMA in circular mode?

uint16_t adc_buffer[4] = {0};
// DMA and ADC configured in circular mode
// ADC conversions produce values: 100, 200, 300
// DMA transfers these values into adc_buffer sequentially
// After 3 conversions, what is adc_buffer content?

medium

A. [300, 200, 100, 0]

B. [0, 100, 200, 300]

C. [100, 200, 300, 0]

D. [100, 200, 0, 300]

Solution

1. Step 1: Understand DMA circular buffer filling

   DMA fills buffer sequentially from index 0 upwards with ADC values.

2. Step 2: Map ADC values to buffer after 3 transfers

   First 3 elements get 100, 200, 300; last element remains 0 as no 4th conversion yet.

3. Final Answer:

   [100, 200, 300, 0] -> Option C

4. Quick Check:

   Buffer fills sequentially = [100, 200, 300, 0] [OK]

Hint: DMA fills buffer from start sequentially [OK]

Common Mistakes:

• Assuming buffer shifts values on each new sample
• Thinking DMA fills buffer backwards
• Confusing buffer initialization with data content

4. Identify the error in this DMA + ADC continuous sampling setup code snippet:

ADC_InitTypeDef ADC_InitStructure;
DMA_InitTypeDef DMA_InitStructure;

// ADC and DMA configuration omitted for brevity
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_Init(DMA1_Channel1, &DMA_InitStructure);
ADC_Cmd(ADC1, ENABLE);
ADC_SoftwareStartConvCmd(ADC1, ENABLE);

medium

A. DMA_Mode_Normal should be DMA_Mode_Circular for continuous sampling.

B. ADC_SoftwareStartConvCmd should be called before DMA_Init.

C. DMA1_Channel1 is not valid for ADC1 DMA transfers.

D. ADC_Cmd should be called after starting conversion.

Solution

1. Step 1: Check DMA mode for continuous ADC sampling

   DMA_Mode_Normal stops after one transfer; continuous sampling needs DMA_Mode_Circular.

2. Step 2: Verify other calls order and parameters

   Calling ADC_SoftwareStartConvCmd after DMA_Init is correct; DMA1_Channel1 is valid for many MCUs; ADC_Cmd before conversion start is correct.

3. Final Answer:

   DMA_Mode_Normal should be DMA_Mode_Circular for continuous sampling. -> Option A

4. Quick Check:

   Continuous DMA needs circular mode = DMA_Mode_Normal should be DMA_Mode_Circular for continuous sampling. [OK]

Hint: Use circular mode for continuous DMA transfers [OK]

Common Mistakes:

• Using normal mode for continuous DMA
• Misordering ADC and DMA initialization calls
• Assuming DMA channel is invalid without checking MCU

5. You want to continuously sample 8 ADC channels using DMA in circular mode into a buffer of size 16 (uint16_t). Which approach correctly handles the buffer to process the latest samples without data loss?

hard

A. Disable circular mode and manually restart DMA after each 8 samples.

B. Process the entire buffer only after DMA transfer completes once, then restart DMA.

C. Use polling to check ADC conversion complete flag before reading buffer.

D. Use half-transfer and transfer-complete DMA interrupts to process buffer halves alternately.

Solution

1. Step 1: Understand circular DMA buffer usage

   Circular DMA fills buffer continuously; half-transfer and transfer-complete interrupts signal when half/full buffer is ready.

2. Step 2: Choose method to avoid data loss

   Processing halves alternately on interrupts prevents overwriting unprocessed data and ensures continuous handling.

3. Final Answer:

   Use half-transfer and transfer-complete DMA interrupts to process buffer halves alternately. -> Option D

4. Quick Check:

   Half/full DMA interrupts enable safe continuous processing = Use half-transfer and transfer-complete DMA interrupts to process buffer halves alternately. [OK]

Hint: Use DMA half/full interrupts to process buffer safely [OK]

Common Mistakes:

• Waiting for full buffer before processing causes data loss
• Disabling circular mode loses continuous sampling benefit
• Polling ADC flags wastes CPU and misses DMA data