ESP32

What is the ESP32?

The ESP32 is a low-cost Wi-Fi + Bluetooth microcontroller from Espressif Systems. It has a dual-core 32-bit processor at up to 240 MHz, 520 KB of RAM and a big set of peripherals. That makes it the go-to chip for IoT: smart switches, sensor loggers, web dashboards and BLE gadgets.

You rarely use the bare chip. Most people buy a development board such as the ESP32 DevKitC (38 pins) or the popular DevKit V1 (30 pins). The board carries the ESP32-WROOM-32 module plus everything needed to power and program it over one USB cable.

The ESP32 DevKitC: the WROOM-32 module does the work. The USB bridge, regulator and buttons let you power and program it from a PC.

Parts of the DevKitC board

The ESP32-WROOM-32 Module

The metal can on the board is the ESP32-WROOM-32, an 18 × 25.5 mm module. It holds the ESP32 chip together with the parts it needs to run. The module is radio-certified, so board makers can solder it down without doing any RF design.

Outside: RF shield, PCB antenna and 38 castellated pads. Under the shield: the ESP32 chip, 4 MB SPI flash and a 40 MHz crystal.

• WROOM-32 / 32D / 32E: PCB antenna. The D and E versions use newer chip revisions (E fixes early silicon bugs).
• WROOM-32U / 32UE: a u.FL connector instead of the PCB antenna, for an external antenna and longer range.
• WROVER: adds 4–8 MB PSRAM for cameras and large buffers. GPIO16/17 are then used by the PSRAM.

Inside the ESP32 Chip

The ESP32 is a full system-on-chip (SoC). It has two Xtensa LX6 cores, an ultra-low-power (ULP) co-processor, on-chip memory, a 2.4 GHz radio and dozens of peripherals.

Two CPU cores, memory, a radio and a large set of peripherals on one chip. The flash and antenna sit beside it inside the module.

• Two cores: with the Arduino core, Wi-Fi and Bluetooth run on core 0 and your loop() runs on core 1. FreeRTOS lets you add tasks on either core.
• ULP co-processor: a tiny CPU that can read sensors while the main cores sleep, which is key for battery life.
• Memory: 520 KB SRAM for variables, 448 KB ROM for boot code, 16 KB RTC RAM that survives deep sleep, and 4 MB external flash for your program.
• Crypto hardware: AES, SHA, RSA and a true random-number generator for secure TLS connections.

Full ESP32 DevKitC Pinout

Here is the complete 38-pin ESP32 DevKitC pinout. Every header pin shows its GPIO number, its ADC channel, touch channel and alternate functions: DAC, SPI, I2C, UART, strapping and flash.

The full ESP32 DevKitC pinout. Header J2 is on the left, header J3 on the right, colour-coded by function.

Want a quicker map? This colour-coded overview shows both headers with the GPIO numbers as printed on most boards:

Pinout at a glance. Numbers are GPIOs; the grey SD0–SD3 / CMD / CLK pins belong to the flash chip.

Every ESP32 Pin Explained

Now let's go through each group of pins and what it does. In Arduino code you use the GPIO number directly, for example pinMode(23, OUTPUT).

Power & control pins

General-purpose GPIO

Any GPIO can be an input or an output with pinMode(), digitalWrite() and digitalRead(). They also have internal pull-up and pull-down resistors (INPUT_PULLUP, INPUT_PULLDOWN). Logic is 3.3 V. Keep each pin to about 12–20 mA (40 mA absolute max), and drive relays and motors through a MOSFET or transistor.

Special pins to respect

• Strapping pins (GPIO0, 2, 5, 12, 15): read once at reset to choose the boot mode and flash voltage. GPIO0 LOW = download mode; GPIO12 HIGH at boot selects 1.8 V flash and stops a WROOM-32 from booting. Don't connect anything that forces these pins to the wrong level at power-up.
• GPIO1 (TX0) & GPIO3 (RX0): UART0, wired to the USB bridge for uploading and Serial. Using them as I/O breaks the Serial Monitor.
• GPIO6–11 (SD0–SD3, CMD, CLK): connected to the module's SPI flash. Never use them, or the chip crashes.
• GPIO2: drives the on-board blue LED on many DevKit V1 boards. It must be LOW or floating when you flash the chip.

Which ESP32 Pins Are Safe to Use?

The question every beginner asks. Here are all the DevKit GPIOs sorted into four groups:

Start with the green pins. Use amber pins only once you understand strapping. Use blue pins for inputs only. Never touch the red ones.

Powering the ESP32

The ESP32 chip runs on 3.3 V. The DevKit board takes 5 V from USB or its 5V pin and uses an on-board LDO voltage regulator to make the 3.3 V.

USB or 5V pin → LDO → 3.3 V for the ESP32 and the 3V3 pin. A diode stops the 5V pin back-feeding your PC.

Wi-Fi transmit bursts draw up to ~250 mA. Brown-outs and random resets usually mean a weak USB cable or supply, so add a 10–100 µF capacitor across 3V3–GND if you power it from a battery or a long cable.

PWM on the ESP32 (LEDC)

The ESP32 has a dedicated LEDC peripheral: 16 PWM channels with adjustable frequency and resolution, which can drive any output-capable GPIO. The duty cycle sets the average voltage (see pulse & PWM signals).

At 3.3 V logic, 25/50/75 % duty gives 0.83/1.65/2.48 V average. The frequency and bit-resolution are yours to pick.

// fade an LED on GPIO2 (Arduino-ESP32 core 3.x)
void setup() {
  ledcAttach(2, 5000, 8);      // pin, 5 kHz, 8-bit (0..255)
}
void loop() {
  for (int d = 0; d <= 255; d++) { ledcWrite(2, d); delay(4); }
  for (int d = 255; d >= 0; d--) { ledcWrite(2, d); delay(4); }
}

On the older core 2.x use ledcSetup(0, 5000, 8); ledcAttachPin(2, 0); ledcWrite(0, duty); (channel-based). analogWrite() also works on core 2.0.14+ and 3.x.

Analog In & Out: ADC and DAC

The ESP32 has a 12-bit ADC (18 channels) that reads 0–3.3 V as 0 to 4095, and two 8-bit DACs that output a real analog voltage.

ADC: 0–3.3 V → 0–4095. DAC: dacWrite(25, 0…255) → 0–3.3 V. Use ADC1 pins when Wi-Fi is on.

// read a potentiometer on GPIO34 (ADC1)
void setup() { Serial.begin(115200); }
void loop() {
  int raw = analogRead(34);               // 0..4095
  int mv  = analogReadMilliVolts(34);      // calibrated millivolts
  Serial.printf("raw=%d  mV=%d\n", raw, mv);
  delay(200);
}

Capacitive Touch Sensing

Ten ESP32 pins can sense touch with no extra parts. A finger adds a little capacitance to a pad or wire, and the reading from touchRead() drops.

Untouched ≈ 70, touched ≈ 15, so a threshold of ~30 turns any metal pad into a button.

Touch pads work through thin plastic or glass, which is great for sealed buttons, and a touch can even wake the ESP32 from deep sleep (touchSleepWakeUpEnable()). Readings depend on wire length and board, so print them first and pick your own threshold.

Communication: UART, I2C & SPI

The ESP32 has 3 UARTs, 2 I2C buses and 4 SPI controllers (two free for you: VSPI and HSPI). Thanks to the GPIO matrix, most of them can be moved to almost any pin. These are the defaults the libraries use:

Default pins: I2C 21/22, VSPI 23/19/18/5, UART2 17/16. UART0 (1/3) is the USB port.

// use a second serial port and custom I2C pins
#include <Wire.h>
void setup() {
  Serial.begin(115200);                      // USB (UART0)
  Serial2.begin(9600, SERIAL_8N1, 16, 17);   // UART2: RX=16, TX=17
  Wire.begin(21, 22);                        // SDA, SCL (any pins work)
}
void loop() {
  if (Serial2.available()) Serial.write(Serial2.read());  // e.g. GPS bridge
}

Wi-Fi & Bluetooth

Wireless is the ESP32's superpower. One 2.4 GHz radio handles Wi-Fi 802.11 b/g/n, Bluetooth Classic and Bluetooth Low Energy (BLE).

Station joins your router, AP makes its own hotspot, BLE talks to phone apps, and ESP-NOW links boards directly.

// connect to Wi-Fi and print the IP address
#include <WiFi.h>
void setup() {
  Serial.begin(115200);
  WiFi.begin("YOUR_SSID", "YOUR_PASSWORD");
  while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); }
  Serial.println(WiFi.localIP());          // e.g. 192.168.1.42
}
void loop() {}

Power Modes & Deep Sleep

An ESP32 with Wi-Fi on can draw ~240 mA, but in deep sleep the chip needs only ~10 µA. Waking up, doing a job and sleeping again is how ESP32 sensors run for months on a battery.

Each step down cuts current by roughly 10–100×. Deep sleep keeps only the RTC, the ULP and 8 KB of RTC memory alive.

Programming the ESP32 & Uploading Code

You can program the ESP32 in the Arduino IDE, Espressif's ESP-IDF, PlatformIO or MicroPython. For beginners, the Arduino IDE is the easiest start.

The USB bridge auto-resets the chip into its ROM bootloader, and esptool writes your program to flash.

Set up the Arduino IDE

1. Open File → Preferences and add this to Additional boards manager URLs:
   https://espressif.github.io/arduino-esp32/package_esp32_index.json
2. Open Boards Manager, search esp32 and install esp32 by Espressif Systems.
3. Select Tools → Board → ESP32 Dev Module and your board's Port. No port? Install the CP210x or CH340 USB driver.
4. Click Upload. Open the Serial Monitor at 115200 baud, the ESP32 default.

ESP32 Code Examples

Short, copy-paste sketches for the Arduino IDE that cover the ESP32 essentials.

Example 1 wiring: an LED on GPIO2 through a 220 Ω resistor. Many boards already have this LED built in.

1. Blink an LED

#define LED 2
void setup() {
  pinMode(LED, OUTPUT);
}
void loop() {
  digitalWrite(LED, HIGH);
  delay(500);
  digitalWrite(LED, LOW);
  delay(500);
}

2. Read a button with the internal pull-up

void setup() {
  pinMode(4, INPUT_PULLUP);           // button between GPIO4 and GND
  pinMode(2, OUTPUT);
}
void loop() {
  digitalWrite(2, digitalRead(4) == LOW);   // LED on while pressed
}

3. Touch pin as a button

void setup() { Serial.begin(115200); pinMode(2, OUTPUT); }
void loop() {
  int v = touchRead(4);              // T0 = GPIO4
  Serial.println(v);                   // check your own values first
  digitalWrite(2, v < 30);
  delay(50);
}

4. Deep sleep with a timer wake-up

RTC_DATA_ATTR int bootCount = 0;      // kept in RTC memory during sleep
void setup() {
  Serial.begin(115200);
  bootCount++;
  Serial.printf("Boot number %d\n", bootCount);
  esp_sleep_enable_timer_wakeup(60ULL * 1000000);   // 60 s
  esp_deep_sleep_start();              // setup() runs again on wake
}
void loop() {}

Beginner ESP32 Mini-Projects

Each project uses a handful of cheap parts and complete code. Upload it and it works.

#include <WiFi.h>
#include <WebServer.h>
WebServer server(80);
void setup() {
  pinMode(2, OUTPUT);
  Serial.begin(115200);
  WiFi.begin("YOUR_SSID", "YOUR_PASSWORD");
  while (WiFi.status() != WL_CONNECTED) delay(500);
  Serial.println(WiFi.localIP());
  server.on("/",    [](){ server.send(200, "text/html",
    "<h1>ESP32</h1><a href='/on'>ON</a> | <a href='/off'>OFF</a>"); });
  server.on("/on",  [](){ digitalWrite(2, HIGH); server.sendHeader("Location", "/"); server.send(303); });
  server.on("/off", [](){ digitalWrite(2, LOW);  server.sendHeader("Location", "/"); server.send(303); });
  server.begin();
}
void loop() { server.handleClient(); }

bool on = false;
void setup() { pinMode(2, OUTPUT); }
void loop() {
  if (touchRead(4) < 30) {            // touched
    on = !on;
    digitalWrite(2, on);
    while (touchRead(4) < 30) delay(10);  // wait for release
  }
}

void setup() {
  ledcAttach(2, 5000, 12);         // 12-bit PWM: 0..4095
}
void loop() {
  ledcWrite(2, analogRead(34));      // ADC 0..4095 -> duty 0..4095
  delay(10);
}

void setup() {
  Serial.begin(115200);
  int light = analogRead(35);         // 0..4095
  Serial.printf("Light level: %d\n", light);
  Serial.flush();
  esp_sleep_enable_timer_wakeup(5ULL * 60 * 1000000);  // 5 min
  esp_deep_sleep_start();
}
void loop() {}

ESP32 vs Arduino Uno

Both run Arduino sketches, but they are built for different jobs.

The ESP32 wins on speed, memory and wireless; the Arduino Uno wins on 5 V simplicity and shield support.

ESP32 vs ESP8266: the older ESP8266 has a single 80/160 MHz core, only one ADC input, no Bluetooth and fewer GPIOs. The ESP32 is the better pick for new projects at almost the same price.

ESP32 Specifications

The ESP32 (WROOM-32) at a glance.

Key numbers for the original ESP32. The S2, S3 and C3 variants differ.

ESP32 family at a glance

Key Terms — Glossary

Related Topics & Common Searches

The ESP32 works with a whole world of parts. Explore these Power4All guides:

People Also Search For

esp32 · esp32 pinout · esp32 devkitc pinout · esp32 devkit v1 pinout · esp32 30 pin pinout · esp32 38 pin pinout · esp32-wroom-32 · esp32 wroom 32 datasheet · esp32 gpio pins · esp32 safe pins to use · esp32 strapping pins · esp32 input only pins · esp32 adc pins · esp32 adc2 wifi · esp32 dac · esp32 touch pins · esp32 pwm · esp32 ledcWrite · esp32 i2c pins · esp32 spi pins · esp32 uart pins · esp32 wifi · esp32 bluetooth · esp32 ble · esp32 web server · esp32 deep sleep · esp32 power consumption · esp32 5v tolerant · esp32 arduino ide setup · esp32 board manager url · esp32 failed to connect · esp32 boot button · esp32 blink · esp32 projects for beginners · esp32 vs arduino · esp32 vs esp8266 · esp32 specifications.

Frequently Asked Questions

Quick answers to the questions people ask most about the ESP32.

Conclusion & Key Takeaways

The ESP32 gives you a fast dual-core processor, Wi-Fi and Bluetooth for the price of a basic microcontroller. Once you know which pins are safe and remember it's a 3.3 V chip, it is the best board for connected projects.

Continue Learning