Reading Analog Sensors with ESP32 ADC

1. The What and Why of Analog-to-Digital Conversion

Microcontrollers like the ESP32 are digital devices; they operate on discrete values of 1s and 0s (HIGH and LOW). However, the physical world is largely analog. Sensors that measure temperature, pressure, light, or distance typically produce a continuously varying voltage. An Analog-to-Digital Converter (ADC) is the bridge between this analog world and the digital world of the microcontroller.

The ADC's job is to measure an incoming analog voltage and convert it into a digital number. This process involves a few key characteristics.

As you just read, here are the key takeaways for the ESP32's ADC:

• Resolution: The ESP32 ADC typically has a 12-bit resolution. This means it can represent an analog voltage with a digital number from 0 to 4095 (2¹² - 1). A 0V input maps to a digital value of 0, and the maximum input voltage (e.g., 3.3V) maps to 4095.
• Non-Linearity: The ESP32's ADC is not perfectly linear, especially at the low and high ends of its range. The ADC may not be able to distinguish between 0V and 0.1V, or between 3.2V and 3.3V. This is a hardware characteristic to be aware of.
• ADC Channels: The ESP32 has two ADCs (ADC1 and ADC2) with a total of 18 channels, each connected to a specific GPIO pin.

A critical point mentioned in the article is the conflict between ADC2 and Wi-Fi.

If you are using Wi-Fi, the Wi-Fi driver takes over ADC2. Therefore, if your application requires both Wi-Fi and analog readings, you must use GPIOs connected to ADC1.

2. Configuring the ADC's Input Range

The default input voltage range of the ADC might not match the output range of your sensor. The ESP32 provides two primary mechanisms to handle this: internal attenuation for adjusting the ADC's measurable range, and external voltage dividers for scaling down sensor voltages that exceed the ESP32's limits.

Attenuation

Attenuation is like changing the sensitivity of the ADC. It allows you to configure the full-scale voltage that corresponds to the maximum digital value (4095). By setting the attenuation, you can make the ADC accurately measure voltages higher than its default range.

The ESP-IDF provides four attenuation levels:

• ADC_ATTEN_DB_0: No attenuation (approx. 0-1.1V range).
• ADC_ATTEN_DB_2_5: 2.5 dB attenuation (approx. 0-1.5V range).
• ADC_ATTEN_DB_6: 6 dB attenuation (approx. 0-2.2V range).
• ADC_ATTEN_DB_11: 11 dB attenuation (approx. 0-3.3V range).

Choosing the right attenuation is crucial. You should select the setting that provides the smallest range that can still fully encompass your sensor's maximum output voltage. This maximizes the measurement resolution. For example, if your sensor outputs a maximum of 1.2V, ADC_ATTEN_DB_2_5 would be a better choice than ADC_ATTEN_DB_11.

Voltage Dividers

What if your sensor outputs a voltage higher than 3.3V, such as a common 5V sensor? Connecting this directly to an ESP32 GPIO pin will damage the chip. In this scenario, you must scale the voltage down externally using a voltage divider. As a mechanical engineer, you're familiar with scaling and dividing signals; this is the electronic equivalent. A voltage divider is a simple circuit made of two resistors that reduces a voltage by a fixed ratio.

The key formula for a voltage divider is:
$V_{out}=V_{in}\times \frac{R_2}{R_1+R_2}$
Your goal is to choose R1 and R2 such that $V_{out}$ is within the ESP32's measurable range (e.g., 0-3.3V) when $V_{in}$ is at its maximum.

3. Reading Values: From C API to C++ Wrapper

The ESP-IDF provides a C API for ADC operations. The most common and straightforward method is the One-Shot mode, where you request a single ADC reading when you need it. Let's look at the basic steps using the C API, which will form the foundation for our C++ class.

Based on the Random Nerd Tutorials article you reviewed, the process is:

1. Initialize the ADC unit: Create a configuration struct (adc_oneshot_unit_init_cfg_t) and call adc_oneshot_new_unit().
2. Configure the ADC channel: Create another configuration struct (adc_oneshot_chan_cfg_t) specifying the bit width and attenuation, then call adc_oneshot_config_channel().
3. Read the value: Call adc_oneshot_read() with the channel handle to get the raw integer value.

While this C API is functional, it's not very object-oriented. In keeping with the goals of this course, we'll wrap this functionality in a C++ class to provide a cleaner and more reusable interface.

The C++ wrapper provides two key benefits:

1. Encapsulation: It hides the complex ESP-IDF configuration structs and function calls behind a simple, intuitive interface.
2. Calibration: It elegantly integrates the esp_adc_cal library, which uses factory-calibrated values stored in the ESP32's eFuse to correct for the ADC's non-linearity, providing a much more accurate voltage reading than simple linear mapping.

4. Converting a Raw Value to a Physical Unit

Getting a raw value (0-4095) or even a calibrated voltage is only part of the job. The final goal is to convert this measurement into a meaningful physical quantity, like pressure in PSI, temperature in Celsius, or distance in meters. This requires a mathematical formula, which is usually found in the sensor's datasheet.

The process typically involves a few steps of linear scaling and conversion.

Let's summarize the general process shown in the video:

1. Convert Raw ADC to Voltage: First, determine the voltage measured by the ADC. The simplest way is a linear mapping:
   $V_{adc}=\text{raw\_value}\times \frac{{\text{V}}_{\text{ref}}}{\text{max\_raw\_value}}$
   where V_ref is the ADC's reference voltage (e.g., 3.3V) and max_raw_value is the max reading (e.g., 4095 for 12-bit). Using the esp_adc_cal library as shown in the GetVoltage() method is a more accurate way to do this.

2. Account for Voltage Divider (if used): If you used a voltage divider to scale down the sensor's voltage, you must now scale the measured voltage back up to find the sensor's original output.
   $V_{sensor}=V_{adc}\times \frac{R_1+R_2}{R_2}$

3. Apply Sensor Formula: Use the formula from the sensor's datasheet to convert $V_{sensor}$ to the physical unit. For example, a temperature sensor might have a linear relationship like:
   $\text{Temperature (°C)}=(V_{sensor}-{\text{V}}_{\text{0°C}})\times \text{Sensitivity (°C/V)}$

As demonstrated in the video, you can often combine these steps into a single, more computationally efficient formula for your code.

Conclusion

You have now learned how to interface the analog world with your ESP32. By configuring and reading from the ADC, you can build systems that are aware of their environment, which is the first step in creating any intelligent device.

Key Takeaways:

• The ADC converts a continuous analog voltage into a discrete digital number.
• The ESP32's ADC has 12-bit resolution (0-4095) but exhibits non-linearity, which can be partially corrected with factory calibration.
• ADC1 channels should be used if your application also uses Wi-Fi.
• Attenuation configures the ADC's internal voltage measurement range, while external voltage dividers are needed for sensors with outputs greater than 3.3V.
• Wrapping the ESP-IDF C API in a C++ class provides a clean, reusable, and stateful interface for ADC operations.
• The final step is always to convert the raw ADC reading into a meaningful physical unit using a formula derived from the sensor's datasheet and your circuit's configuration.

In our next lesson, we will briefly cover the final piece of the ESP32's basic analog I/O capabilities: the Digital-to-Analog Converter (DAC), which allows you to output a true analog voltage.