ADC Digital to Physical Unit Conversion

1. The Fundamental Conversion: From Digital Value to Voltage

The raw digital value from a 12-bit ADC (0-4095) represents a fraction of the reference voltage, Vref. The conversion is a straightforward ratiometric calculation.

The relationship is defined by this essential formula:

$\text{Input Voltage}=\left(\frac{\text{ADC Raw Value}}{4095}\right)\times V_{\text{ref}}$

Here, Vref is the voltage that corresponds to the maximum ADC reading of 4095. On your STM32F103 Blue Pill board, the ADC's reference voltage is typically connected to the analog power supply (VDDA), which in turn is connected to your main 3.3V supply.

To understand this concept in more detail, let's turn to a clear written explanation.

Activity: Calculating Voltage from the Potentiometer

Let's apply this formula to the project from our last lesson.

1. Open the potentiometer project where you were reading a raw ADC value.

2. In main.c, declare a new floating-point variable for the calculated voltage:

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

3. Inside the while(1) loop, after you get the adc_value, add the conversion formula. We'll assume an ideal Vref of 3.3V for now.

   /* 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);
   
     // Convert raw value to voltage
     voltage = ((float)adc_value / 4095.0f) * 3.3f;
     
     HAL_Delay(100); 
   /* USER CODE END WHILE */
   

   Note the use of (float) and f to ensure the calculation is done using floating-point arithmetic for precision.

4. Start a debug session. Add both adc_value and voltage to the "Live Expressions" window. As you turn the potentiometer, you should now see the raw value change from ~0 to ~4095, and the voltage variable change correspondingly from ~0.0V to ~3.3V.

2. The Professional Approach: Achieving Accurate Readings

Assuming Vref is exactly 3.3V is fine for a simple demo, but in a professional setting, especially for automotive or battery-powered devices, this assumption is flawed. The supply voltage (VDD) can fluctuate due to load changes or battery discharge. Since Vref is tied to VDD, your reference changes, and your calculations become inaccurate.

The Solution: STM32 microcontrollers include a precise, internal, factory-calibrated voltage reference called VREFINT. It provides a stable voltage (typically around 1.2V) that does not change with VDD.

By measuring our own VREFINT with the ADC, we can work backward to calculate the actual current Vref (VDDA). This allows us to create highly accurate and robust measurement systems.

The video below explains this concept and shows how to implement it on your STM32F103 board.

This technique is the foundation for our next lab, where we'll read the internal temperature sensor. The temperature formula requires an accurate voltage reading, so we'll use a VREFINT-based calculation to provide it.

3. Case Study: Reading the Internal Temperature Sensor

Now let's move beyond a simple potentiometer to a real sensor. Your STM32 has a built-in temperature sensor connected to an internal ADC channel. Converting its reading to degrees Celsius is more complex than a simple voltage conversion; it requires a specific formula and parameters found in the microcontroller's datasheet.

The general formula for the STM32F1 series is:

$T{(}^{\circ }\text{C})=\frac{(V_{25}-V_{\text{sense}})}{\text{Avg\_Slope}}+25$

Where:

• $V_{\text{sense}}$ is the actual voltage measured from the temperature sensor ADC channel.
• $V_{25}$ is the sensor's voltage output at 25°C.
• Avg_Slope is the sensor's average change in voltage per degree Celsius (in mV/°C).

The values for $V_{25}$ and Avg_Slope are device-specific and must be found in the datasheet.

The article below provides a fantastic summary and the complete code structure for implementing this.

4. Hands-On Lab: Implementing the Temperature Sensor

Let's build a project that accurately measures the MCU's core temperature.

Hardware Setup

No external components are needed! We are using only the internal peripherals of the STM32.

STM32CubeIDE Configuration

1. Create a new project or start from a clean configuration.
2. Enable the Serial Wire debug interface.
3. In the Analog -> ADC1 section, enable two channels:
   • Check the box for IN16, which is the Temperature Sensor Channel.
   • Check the box for IN17, which is the Vrefint Channel.
4. Under ADC1 Parameter Settings, configure the following:
   • Data Alignment: Right alignment
   • Scan Conversion Mode: Enable (because we are now reading more than one channel).
   • Continuous Conversion Mode: Disable.
   • Number Of Conversions: 2.
5. Expand the Regular Conversion Mode section. You will see two Ranks (Rank 1 and Rank 2). Configure them as follows:
   • Rank 1: Channel = Temperature Sensor, Sampling Time = 71.5 Cycles (a longer sampling time is recommended for the temp sensor).
   • Rank 2: Channel = VREFINT, Sampling Time = 71.5 Cycles.
6. Generate the code.

Code and Debugging

1. In main.c, before the while(1) loop, declare the necessary variables. We'll use HAL's polling method to read both channels into an array.

   /* USER CODE BEGIN 2 */
   uint16_t adc_buf[2]; // To store results for Temp Sensor and VREFINT
   float temperature, vsense, vref_actual;
   
   // Datasheet values for STM32F103C8
   const float AVG_SLOPE = 4.3f; // mV/°C
   const float V25 = 1.43f;      // Volts
   const float VREFINT_TYP = 1.2f; // Volts, typical value from datasheet
   /* USER CODE END 2 */
   

2. Inside the while(1) loop, implement the conversion logic.

   /* USER CODE BEGIN WHILE */
   while (1)
   {
     // Start ADC conversion for both channels. Polling will wait for both to complete.
     HAL_ADC_Start(&hadc1);
     HAL_ADC_PollForConversion(&hadc1, HAL_MAX_DELAY);
     adc_buf[0] = HAL_ADC_GetValue(&hadc1); // Get Temp Sensor result
     
     HAL_ADC_PollForConversion(&hadc1, HAL_MAX_DELAY);
     adc_buf[1] = HAL_ADC_GetValue(&hadc1); // Get VREFINT result
     HAL_ADC_Stop(&hadc1);
   
     // 1. Calculate the actual Vref using the VREFINT measurement
     // Vref_actual = VREFINT_TYP * (ADC_MAX_VALUE / ADC_VREFINT_RAW)
     vref_actual = (VREFINT_TYP * 4095.0f) / (float)adc_buf[1];
   
     // 2. Convert the temperature sensor's raw ADC value to voltage (Vsense)
     vsense = (vref_actual / 4095.0f) * (float)adc_buf[0];
   
     // 3. Calculate the temperature in Celsius
     temperature = ((V25 - vsense) * 1000.0f / AVG_SLOPE) + 25.0f;
     
     HAL_Delay(500);
   /* USER CODE END WHILE */
   

   Note: The code polls for each conversion individually. We will learn a much better way to handle multiple channels with DMA in an upcoming lesson.

3. Start a debug session. Add temperature, vsense, and vref_actual to the Live Expressions window.

4. Run the code. You should see a plausible room temperature reading. Try gently touching the top of the microcontroller chip with your finger for a few seconds. You should observe the temperature value rise slightly, proving your conversion is working!

Conclusion

Congratulations! You have successfully moved beyond raw data to meaningful physical measurements. This is a significant step toward building professional embedded systems that interact with the real world.

Key Takeaways:

• The fundamental formula to convert a raw ADC value to voltage is Voltage = (ADC_Value / ADC_Max_Value) * Vref.
• Relying on a fixed Vref is risky in real-world applications. The internal VREFINT provides a robust way to measure the actual supply voltage and compensate for fluctuations.
• Converting sensor data often requires specific formulas and calibration constants (V25, Avg_Slope) that you must find in the device datasheet—a critical engineering skill.
• By combining VREFINT measurements with sensor-specific formulas, you can achieve accurate and reliable data acquisition.

Preview of the Next Lesson:
In our lab, we used HAL_ADC_PollForConversion, which forces the CPU to stop and wait for the ADC. This is highly inefficient. Imagine needing to read 5 different sensors while also managing a communication protocol. The CPU would be constantly blocked. In the next lesson, we will introduce the solution: the Direct Memory Access (DMA) controller. You will learn how this powerful peripheral can transfer ADC results directly to memory with zero CPU intervention, unlocking the true potential of your microcontroller.