ADC Scan Mode with DMA

1. The Core Concepts: Scan Mode and Circular Mode

To achieve continuous multi-channel acquisition, we need to combine two new features: ADC Scan Mode and DMA Circular Mode.

ADC Scan Conversion Mode

Instead of converting just one channel, Scan Mode tells the ADC to automatically convert a whole sequence of pre-configured channels (e.g., Channel 0, then Channel 1, then Channel 5) after a single start trigger. The order of conversion is determined by a setting called Rank.

ADC Continuous Conversion Mode

When this mode is enabled, the ADC will automatically restart the entire scan sequence as soon as the last channel in the sequence is converted. It doesn't wait for another trigger.

DMA Circular Mode

In the previous lesson, we used Normal mode, where the DMA stops after transferring the requested number of data items. In Circular mode, the DMA treats the destination memory buffer like a ring. After it writes the last element, it automatically wraps around and starts writing to the first element again.

When you combine these three, you create a self-sustaining data pipeline:

1. The ADC starts, scans all channels, and places the results in its data register.
2. The DMA, triggered by the ADC, copies each result to your memory buffer.
3. Because the ADC is in continuous mode, it immediately starts the scan sequence again.
4. Because the DMA is in circular mode, it continues to copy the new results, overwriting the old ones in the buffer.

The CPU's only job is to start this process once. Afterward, the adc_values array in your code becomes a live, continuously updated snapshot of all your sensor readings.

This article from ControllersTech provides an excellent overview comparing the different DMA modes.

2. Hands-On Lab: Continuous Multi-Channel Acquisition

Let's implement this. We will configure the ADC to continuously read two external channels and store the results in an array using DMA circular mode.

Step 1: Project Configuration in STM32CubeIDE

1. Open your project from the last lesson. Go to the .ioc file for Pinout & Configuration.
2. Go to Analog > ADC1.
3. Ensure you have at least two channels enabled, for example, IN0 (on pin PA0) and IN1 (on pin PA1). You can connect potentiometers to these pins to simulate sensor inputs.
4. In the ADC1 Parameter Settings pane, configure the following:
   • Under ADC_Regular_ConversionMode:
     • Scan Conversion Mode: Set to Enabled.
     • Continuous Conversion Mode: Set to Enabled. This is critical for the "fire-and-forget" operation.
     • Number Of Conversions: Set to 2 (or the number of channels you enabled).
   • You will now see Rank settings appear. Configure them:
     • Rank 1: Channel Channel 0, Sampling Time can be left at a default like 1.5 Cycles.
     • Rank 2: Channel Channel 1, same Sampling Time.
5. Now, go to the DMA Settings tab. If you have a DMA channel for ADC1 from the last lesson, select it. If not, add one.
6. Verify or set these crucial DMA parameters:
   • Direction: Peripheral To Memory.
   • Mode: Circular. This is the key change from our previous lesson.
   • Increment Address: Check Memory, uncheck Peripheral.
   • Data Width: Half Word for both Peripheral and Memory.

The following video walks through this exact configuration. It also shows the specific settings for your STM32F103C8 board.

7. Save the .ioc file to generate the updated code.

Step 2: Writing the Application Code

The application code becomes remarkably simple.

1. In Core/Src/main.c, navigate to the private variables section /* USER CODE BEGIN PV */. Define an array to hold the results from your ADC channels. Since it will be accessed by the DMA hardware, it's good practice to declare it volatile.

   /* USER CODE BEGIN PV */
   volatile uint16_t adc_values[2]; // Buffer for 2 ADC channels
   /* USER CODE END PV */
   

2. Now, find the main() function. We need to start the ADC/DMA process once, before the main loop.

   int main(void)
   {
     /* MCU Configuration--------------------------------------------------------*/
   
     /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
     HAL_Init();
   
     /* Configure the system clock */
     SystemClock_Config();
   
     /* Initialize all configured peripherals */
     MX_GPIO_Init();
     MX_DMA_Init();
     MX_ADC1_Init();
     /* USER CODE BEGIN 2 */
   
     // Start the ADC in DMA mode. This is a one-time call.
     HAL_ADC_Start_DMA(&hadc1, (uint32_t*)adc_values, 2);
   
     /* USER CODE END 2 */
   
     /* Infinite loop */
     /* USER CODE BEGIN WHILE */
     while (1)
     {
       // The CPU is now completely free.
       // The 'adc_values' array is being updated in the background.
       // We could do other tasks here, like process the data,
       // run a control loop, or handle communication.
       
       // For demonstration, we'll just add a delay.
       HAL_Delay(100);
       
       /* USER CODE END WHILE */
       /* USER CODE BEGIN 3 */
     }
     /* USER CODE END 3 */
   }
   

   Notice the elegance here. There are no flags, no callbacks, and no HAL_ADC_Start_DMA call inside the while(1) loop. The hardware is now running an autonomous data acquisition engine.

Step 3: Verification with the Debugger

The best way to see this in action is with the live debugger.

1. Build the project and start a Debug Session.
2. Open the Expressions view (Window > Show View > Expressions).
3. Click "Add new expression" and enter adc_values.
4. In the toolbar, find and enable "Continuous Refresh". This tells the debugger to constantly poll the values from the microcontroller.
5. Resume (F8) the program execution.
6. You should now see the adc_values array in the Expressions view. If you expand it, you will see two elements. As you turn the potentiometers connected to PA0 and PA1, you will see the corresponding values in the array change in real-time.

The debugging section of the video you watched earlier demonstrates this exact process.

3. A More Robust Approach: Timer-Triggered Scans

The Continuous Conversion Mode is simple and effective. However, in professional applications requiring precise timing (like control systems or signal processing), it's better to trigger ADC scans with a hardware timer. This ensures that your samples are taken at an exact, deterministic rate (e.g., precisely every 10ms).

You would configure a timer (like TIM3) to generate a trigger output (TRGO) on its update event, and then set the ADC's external trigger source to that timer.

While we won't implement this today to keep the lesson focused, the article "STM32 Internal Temperature Sensor Reading" provides a complete guide on this timer-triggered architecture. It's an excellent resource for future reference.

Conclusion

Congratulations! You have now built a truly efficient, multi-channel data acquisition system. By using ADC Scan Mode with DMA Circular Mode, you've created a fire-and-forget data pipeline that continuously updates a memory buffer with sensor readings, leaving the CPU almost entirely free to perform other tasks.

Key Takeaways:

• ADC Scan Mode converts a ranked sequence of channels with a single trigger.
• DMA Circular Mode makes the destination buffer a ring, allowing for continuous data overwriting.
• Combining ADC Continuous Conversion with these two modes creates an autonomous data acquisition engine.
• The HAL_ADC_Start_DMA() function is called only once to kick off this self-sustaining process.
• The debugger's Live Expressions view is the perfect tool for observing the continuously updated data buffer.

Preview of the Next Lesson:
Our adc_values buffer is now "live," but how do we safely process this data in our main application without reading it while the DMA is in the middle of an update (a "torn read")? In our next lesson, we will explore using DMA interrupts (Transfer Complete and Half-Transfer) to create a robust double-buffering scheme. This is the standard professional technique for processing continuous streams of data safely and efficiently.