Analog Inputs: Reading a Potentiometer

By the end of this project, you will:

• Understand the difference between digital and analog signals.
• Learn how the ESP32's Analog-to-Digital Converter (ADC) works.
• Read a potentiometer (variable resistor) and convert its analog voltage to a numeric value (0–4095).
• Use the analogRead() function and the Serial Monitor to observe real-time sensor data.
• Convert raw ADC readings into voltage using a simple proportional formula.

• A digital input sees only HIGH or LOW (Project 1).
• An analog input measures a continuous voltage 0–3.3 V and converts it to a number via the ADC.

The ESP32 ADC is 12‑bit, so readings run 0 … 4095:

The ADC pin here

We use GPIO 4 ANALOG (ADC2, channel 0): the same physical pin that was a digital input in Project 1, now used with analogRead().

Which pins can do analog input?

Grab your ESP32 board and locate the pins highlighted with a red border in the figure below: these are your analog-capable pins:

Notice that not every pin can read an analog signal. The red‑outlined pins are the ones connected to the internal ADC hardware. In this project we use GPIO 4, but you could use any of the other ADC pins just as well.

1. One outer leg → 3.3 V
2. Other outer leg → GND
3. Middle leg (wiper) → GPIO 4

Turning the knob taps off 0 V → 3.3 V, and the ADC reports the matching 0–4095 value.

Let's walk through the key parts of the sketch so you understand what each line does and why.

Step 1: Pin definition & variables

// The potentiometer's middle leg (wiper) connects to GPIO 4
const int potPin = 4;    // ADC2, channel 0, an analog-capable pin

int potValue = 0;           // Variable to store the ADC reading (0–4095)

const int potPin = 4; gives the pin a human-readable name. Using a constant (const) prevents accidentally changing the pin number later. The variable potValue will hold whichever value analogRead() returns.

Step 2: one-time preparation in setup()

void setup() {
  Serial.begin(115200);     // Open the serial connection at 115200 baud
  delay(500);                // give the Serial Monitor a moment to connect
  ...                        // then print the banner
}

Serial.begin(115200) opens a USB link between the ESP32 and your computer. Without this, the Serial Monitor would stay blank. Think of it as turning on the communication channel.

Step 3: loop() reads → converts → prints → repeats

void loop() {
  // 1️⃣ READ the analog voltage on GPIO 4
  potValue = analogRead(potPin);          // returns 0 .. 4095

  // 2️⃣ CONVERT the raw number to actual voltage (0–3.3 V)
  float voltage = potValue * 3.3 / 4095.0;

  // 3️⃣ PRINT both values to the Serial Monitor
  Serial.printf("Pot: %4d / 4095   (~%.2f V)\n", potValue, voltage);

  // 4️⃣ WAIT 500 ms before the next reading
  delay(500);
}

Key concepts: what each line really does

Expected output on the Serial Monitor

==============================================
 Project 2: ESP32 Analog Inputs (ADC)
==============================================
Potentiometer -> GPIO 4
12-bit ADC: 0 = 0 V ... 4095 = 3.3 V
Turn the knob and watch the value change.
----------------------------------------------
Pot:    0 / 4095   (~0.00 V)
Pot: 2047 / 4095   (~1.65 V)
Pot: 4095 / 4095   (~3.30 V)

This matters for precise measurements; for a knob or light sensor it's fine.

Going further: analogReadMilliVolts() and attenuation

The ESP32 ships with a factory‑measured calibration curve for its ADC, and analogReadMilliVolts() applies it for you:

int millivolts = analogReadMilliVolts(potPin);   // calibrated, in mV

Where analogRead() gives you a raw 0–4095 number you then scale yourself (and scale wrong near the ends, per the graph above), analogReadMilliVolts() returns an already‑corrected voltage in millivolts, straightening out most of the non‑linearity you just saw.

The other half of the calibration is attenuation: how much the ADC's input range is scaled before conversion. The default lets the ESP32 read up to about 3.3 V, but you can narrow that window for more precision on a smaller range:

analogSetAttenuation(ADC_11db);   // default: ~0-3.3 V (what this project assumes)
// ADC_0db    ~0-1.1 V  (finest resolution, smallest range)
// ADC_2_5db  ~0-1.5 V
// ADC_6db    ~0-2.2 V
// ADC_11db   ~0-3.3 V  (widest range)

Call analogSetAttenuation() once in setup(), before you start reading. A lower attenuation trades range for precision: useful if your sensor's signal never actually reaches 3.3 V and you want more of the ADC's 4096 steps spent on the range it does use.

Going further: swap in a photoresistor (LDR)

The kit's photoresistor module reads exactly like the potentiometer you just wired: three pins, one of them an analog signal.

Swap the potentiometer for the LDR module on those three pins and the sketch above needs no changes: analogRead(potPin) now reports more light → higher voltage → a bigger number, instead of turning a knob. Some modules also break out a DO (digital out) pin, driven by an onboard comparator and trimmer, useful for a simple "is it dark" threshold without touching the ADC at all.

This is the sensor Project 13's idea menu (Smart room monitor, Light‑and‑sound alert) expects.

In this project you've learned how to read analog inputs using the ESP32 with the Arduino IDE. Here's a summary of the key takeaways:

• The ESP32 DEVKIT V1 DOIT board (30‑pin version) has 15 ADC pins you can use to read analog inputs.
• These pins have a 12‑bit resolution, which means you can get values from 0 to 4095.
• To read a value in the Arduino IDE, you simply use the analogRead() function.
• The ESP32 ADC pins don't have a linear behavior at the extremes of the voltage range. You'll probably won't be able to distinguish between 0 and 0.1 V, or between 3.2 and 3.3 V. Keep that in mind when using the ADC pins for precise measurements.

Now try

• Map the pot to LED brightness: Combine this project's analogRead() with Project 3's PWM to fade an LED using the potentiometer knob.
• Swap in a photoresistor: Replace the potentiometer with an LDR (light-dependent resistor) using the same wiring pattern. The code stays the same; only the physical behavior changes.