Configuring Single-Channel, Software-Triggered ADC Conversions

1. From Analog Voltage to Digital Number

An Analog-to-Digital Converter (ADC) is a circuit that converts a continuous analog voltage into a discrete digital value. The precision of this conversion is defined by its resolution.

Your STM32F103C8T6 microcontroller has a 12-bit ADC. This means it can represent an analog voltage range with $2^{12}=4096$ discrete steps.

• If the input voltage is 0V, the ADC output will be the digital value 0.
• If the input voltage is the reference voltage (typically 3.3V for your board), the ADC output will be the digital value 4095.
• Any voltage in between will be represented by a proportional integer between 0 and 4095.

For a more detailed explanation of this relationship, you can refer to the following article.

In this lesson, we'll focus on getting that raw digital value (0-4095). In the next lesson, we will use the formula you just read about to convert it into a meaningful physical unit like voltage.

2. Configuring the ADC in STM32CubeIDE

To use the ADC, we first need to configure the peripheral and the associated GPIO pin. We will use STM32CubeIDE's graphical tool for this. We'll set up the ADC in the simplest configuration: single-channel, software-triggered "polling" mode. This means we will use one pin to read one analog signal, and our code will manually start a conversion and then wait (poll) for it to finish.

The video below from ControllersTech provides an excellent walkthrough of the ADC configuration options. While the main demonstration uses a more advanced STM32 chip, the instructor specifically compares the settings to the STM32F103, which is perfect for our needs.

Activity: Configure Your Project

Now, it's your turn. Create a new STM32CubeIDE project for your Blue Pill board and follow these steps to configure the ADC.

1. Enable Peripherals:
   • In the System Core -> SYS category, set Debug to Serial Wire.
   • In the Analog -> ADC1 category, check the box for one of the input channels. For example, check IN0, which will assign pin PA0 as an analog input.
2. Configure ADC1:
   • Click on the ADC1 peripheral in the configuration panel.
   • Verify the settings based on the video you just watched. The most important ones for our single-channel polling mode are:
     • Data Alignment: Right alignment
     • Scan Conversion Mode: Disable
     • Continuous Conversion Mode: Disable
     • End of Conversion Selection: End of single conversion
   • Under Regular Conversion Mode, ensure the External Trigger Conversion Source is set to Regular Conversion launched by software. This is the key to our software-triggered approach.

This is what your configuration should look like:

3. Generate the code by saving the .ioc file.

3. Reading the ADC Value with HAL Functions

With the code generated, we can now write the logic in main.c to perform a conversion. The process involves a sequence of four HAL functions that you'll place inside the while(1) loop.

The following article from ControllersTech (the text version of the video you watched) provides the exact code snippet we need.

Here is a summary of the polling sequence:

1. HAL_ADC_Start(&hadc1);: This function "wakes up" the ADC and starts a single conversion.
2. HAL_ADC_PollForConversion(&hadc1, HAL_MAX_DELAY);: This is a blocking function. The CPU will pause here and wait until the ADC hardware sets its "End of Conversion" (EOC) flag. This is the "polling" step.
3. HAL_ADC_GetValue(&hadc1);: Once the conversion is complete, this function reads the 16-bit data register containing our 12-bit result.
4. HAL_ADC_Stop(&hadc1);: This function can be called to power down the ADC to save energy, though it's optional for this simple test.

While simple, this polling method is inefficient because the CPU is stuck waiting in HAL_ADC_PollForConversion and can't do other work. In future lessons, we will see how interrupts and DMA provide far more efficient solutions.

4. Hands-On Lab: Reading a Potentiometer

Let's put everything together and read a real analog signal.

Hardware Setup

You will need a 10k Ohm potentiometer. Connect it to your Blue Pill board as follows:

• Connect one of the outer pins of the potentiometer to a 3.3V pin on your board.
• Connect the other outer pin to a GND pin.
• Connect the middle pin (the "wiper") to your chosen ADC pin, PA0.

As you turn the potentiometer's knob, the voltage on the middle pin will vary smoothly between 0V and 3.3V, providing a perfect analog input for our test.

Code and Debug

1. In your main.c file, declare a variable to hold the ADC result just before the while(1) loop:

   /* USER CODE BEGIN 2 */
   uint16_t adc_value;
   /* USER CODE END 2 */
   

2. Inside the while(1) loop, implement the polling sequence:

   /* USER CODE BEGIN WHILE */
   while (1)
   {
     HAL_ADC_Start(&hadc1);
     HAL_ADC_PollForConversion(&hadc1, HAL_MAX_DELAY);
     adc_value = HAL_ADC_GetValue(&hadc1);
     HAL_ADC_Stop(&hadc1);
     
     HAL_Delay(100); // Wait 100ms before the next reading
   /* USER CODE END WHILE */
   

3. Now, let's verify our code using the debugger's "Live Expressions" feature. This powerful tool lets you watch variables change in real-time.

Follow the process shown in the video. Start a debug session, add your adc_value variable to the Live Expressions window, and run the code. Turn the potentiometer knob. You should see the value in the debugger change in real-time, ranging from a number close to 0 to one close to 4095.

Conclusion

Excellent work! You have successfully configured and read from an ADC channel using the fundamental software-triggered polling method. You have taken an external analog voltage, converted it into a digital number, and verified its value inside the MCU using professional debugging tools.

Key Takeaways:

• The ADC converts an analog voltage into a digital number. For the STM32F103, this is a 12-bit value ranging from 0 to 4095.
• Polling mode uses a Start -> Poll -> GetValue sequence, which is simple to implement but makes the CPU wait, reducing efficiency.
• STM32CubeIDE simplifies the configuration of GPIO pins for analog input and ADC parameters like triggers and conversion modes.
• The debugger's "Live Expressions" view is an invaluable tool for monitoring real-time sensor data without having to use a serial port.

Preview of the Next Lesson:
Getting a raw value from 0-4095 is a great first step, but it's not very useful on its own. In our next lesson, you will learn how to convert this raw ADC digital value into a corresponding physical unit, such as voltage. This will allow you to display meaningful data and make decisions based on real-world measurements. We will then explore the central theme of this module: using the Direct Memory Access (DMA) controller to read the ADC without any CPU intervention.