ESP32 ADC

#What is an ADC?

Analog-to-Digital Conversion (ADC) is the process of converting an analog voltage signal into a digital value that can be processed by a microcontroller. The ESP32's ADC allows it to interface with various analog sensors, converting their continuous signals into digital values ranging from 0 to a specified resolution (e.g., 12-bit resolution gives a range of 0 to 4095).

Imagine you have a dimmer switch at home that lets you control the brightness of a light bulb. When you twist the knob, you’re adjusting how much electricity flows to the bulb, making it brighter or dimmer. Now, what if you wanted to tell a computer exactly how bright the light is? This is where something called an Analog-to-Digital Converter (ADC) comes in.

In simple terms, an ADC is like a translator for your computer or microcontroller (like the ESP32). It takes an analog signal—something that can have any value within a range, like the voltage coming from your dimmer switch—and converts it into a digital number that the computer can understand.

For example, let’s say you have a sensor that measures temperature, and it outputs a varying voltage based on the temperature it senses. The ADC in the ESP32 reads this voltage and converts it into a number between 0 and 4095. The exact number depends on how high or low the voltage is, giving your ESP32 a way to understand and process the temperature data.

#Introduction to ADC on ESP32

The ESP32 is equipped with two ADCs: ADC1 and ADC2, each having multiple channels. These ADCs can read analog voltages on the GPIO pins and convert them into a digital value ranging from 0 to 4095, corresponding to the input voltage (typically 0 to 3.3V). However, the ADC2 is shared with other peripherals like Wi-Fi, so it’s generally recommended to use ADC1 to avoid conflicts.

#Hardware and Requirements

• ESP32 Development Board
• Potentiometer (e.g., 10kΩ)
• Breadboard and Jumper Wires
• Power Supply or USB Cable

#Setting Up the Development Environment

Before diving into the code, ensure that you have the Arduino IDE installed along with the ESP32 board package.

1. Install the Arduino IDE: Download and install the Arduino IDE from here.
2. Install the ESP32 Board Package:
   • Open the Arduino IDE.
   • Go to File -> Preferences.
   • In the "Additional Board Manager URLs" field, enter the following URL : arduino Copy codehttps://dl.espressif.com/dl/package_esp32_index.json
   • Go to Tools -> Board -> Boards Manager and search for "ESP32".
   • Install the "ESP32 by Espressif Systems" package.

#Understanding the ADC on ESP32

The ESP32 features multiple ADC channels, each capable of reading analog signals. Here are key points to understand:

• ADC Channels: The ESP32 has 18 ADC channels, divided between two ADC modules (ADC1 and ADC2). ADC1 is typically preferred for general use as ADC2 shares pins with Wi-Fi functions, potentially causing conflicts.
• Resolution: The default resolution is 12 bits, but it can be configured between 9 and 12 bits. A higher resolution gives more precise readings but increases the time required for conversion.
• Voltage Reference: The ESP32's ADC reads input voltages between 0 and 3.3V. The resolution divides this range into equal intervals.

#Reading Analog Values with ADC

Let’s start with a simple example where we read the value from a potentiometer connected to one of the ADC pins.

Wiring:

• Connect the middle pin of the potentiometer to GPIO 34 (ADC1 Channel 6).
• Connect one of the outer pins to 3.3V.
• Connect the other outer pin to GND.

// Sample Code is Written By OceanLabz.in

const int potPin = 34; // GPIO 34 (ADC1 Channel)

void setup() { Serial.begin(115200); // Initialize serial communication at 115200 baud }

void loop() { int potValue = analogRead(potPin); // Read the analog value Serial.println(potValue); // Print the value to the Serial Monitor delay(500); // Delay for stability }

Explanation:

• analogRead(potPin): This function reads the analog value from GPIO 34.
• The ADC converts the voltage from the potentiometer into a value between 0 and 4095.
• The value is printed to the Serial Monitor every 500 milliseconds.

#Scaling and Calibration

To convert the raw ADC readings into meaningful values (e.g., voltage), you may need to scale and calibrate the output.

Example: Converting the ADC value to voltage.

const float voltageMax = 3.3; // Maximum voltage const int adcMax = 4095; // Maximum ADC value (12-bit resolution)

void loop() { int potValue = analogRead(potPin); float voltage = (potValue * voltageMax) / adcMax; // Convert to voltage Serial.println(voltage); // Print the voltage delay(500); }

#Advanced ADC Applications

#Reading a Temperature Sensor

Analog temperature sensors like the LM35 provide a voltage output proportional to the temperature. You can use the ADC to read this voltage and convert it to a temperature value.

Example: Reading temperature from an LM35 sensor.

//

const int tempPin = 34; // GPIO 34 const float voltageRef = 3.3; // Reference voltage

void loop() { int adcValue = analogRead(tempPin); float voltage = (adcValue * voltageRef) / 4095.0; float temperatureC = voltage * 100.0; // LM35 gives 10mV/°C Serial.print("Temperature: "); Serial.print(temperatureC); Serial.println(" °C"); delay(1000); }

#Using Multiple ADC Channels

The ESP32 allows you to read from multiple ADC channels simultaneously. Here’s how you can monitor two analog sensors (e.g., a potentiometer and a photoresistor).

Wiring:

• Potentiometer middle pin to GPIO 34.
• Photoresistor (LDR) connected in series with a 10kΩ resistor between 3.3V and GND. The junction of the LDR and resistor connects to GPIO 35 (ADC1 Channel 7).

// Sample Code is Written By OceanLabz.in

void setup() { Serial.begin(115200); }

void loop() { int potValue = analogRead(34); // Read potentiometer int ldrValue = analogRead(35); // Read LDR

Serial.print("Potentiometer: "); Serial.print(potValue); Serial.print(" | LDR: "); Serial.println(ldrValue);

delay(500); }

Explanation:

• analogRead(34) and analogRead(35) are used to read from two different ADC channels.
• The readings are printed side by side to the Serial Monitor.

#Troubleshooting and Tips

• Floating Inputs: Unused ADC pins can float, leading to unstable readings. To prevent this, connect unused ADC pins to ground through a pull-down resistor.
• ADC Accuracy: The ESP32’s ADC is not perfect and might have some non-linearity or noise. Consider averaging multiple readings for more stable results.
• Wi-Fi Interference: When using ADC2, avoid using Wi-Fi simultaneously, as it can cause ADC readings to be inaccurate.

#Other Functions

• analogReadResolution(resolution):
  • Set the sample bits and resolution between 9 to 12 bits.
  • Default is 12-bit resolution.
• analogSetWidth(width):
  • Similar to analogReadResolution(), set sample bits and resolution.
  • Default is 12-bit resolution.
• analogSetCycles(cycles):
  • Set the number of cycles per sample.
  • Default is 8, range: 1 to 255.
• analogSetSamples(samples):
  • Set the number of samples in the range, affecting sensitivity.
  • Default is 1 sample.
• analogSetClockDiv(attenuation):
  • Set the divider for the ADC clock.
  • Default is 1, range: 1 to 255.
• analogSetAttenuation(attenuation):
  • Set input attenuation for all ADC pins.
  • Default is ADC_11db.
  • Accepted values:
    • ADC_0db: No attenuation (measures up to approximately 800 mV).
    • ADC_2_5db: Attenuated input, measuring up to approx. 1100 mV.
    • ADC_6db: Attenuated input, measuring up to approx. 1350 mV.
    • ADC_11db: Attenuated input, measuring up to approx. 2600 mV.
• analogSetPinAttenuation(pin, attenuation):
  • Set the input attenuation for a specified pin.
• adcAttachPin(pin):
  • Attach a pin to ADC, clearing any other analog mode.
  • Returns TRUE or FALSE result.
• adcStart(pin), adcBusy(pin), and adcEnd(pin):
  • Start an ADC conversion on the attached pin’s bus.
  • Check if conversion on the pin’s ADC bus is running (returns TRUE or FALSE).
  • Get the result of the conversion (returns a 16-bit integer).