ESP32-S2

What is the ESP32-S2?

The ESP32-S2 is a Wi-Fi microcontroller (SoC) from Espressif. It is the first chip of the ESP32 “S” series and was designed to be cheaper, lower-power and more secure than the original ESP32, with one headline feature the ESP32 never had: native USB.

To get there Espressif made some trade-offs. The S2 has one CPU core instead of two and no Bluetooth, but it adds more GPIOs (43), a 13-bit ADC, 14 touch pads, a RISC-V ultra-low-power coprocessor and hardware security. That makes it a great fit for Wi-Fi sensors, USB gadgets (keyboards, MIDI controllers, flash drives) and battery-powered IoT devices.

A typical ESP32-S2 development board: the WROVER module holds the chip, flash, PSRAM and antenna; the rest powers it and connects it to your PC.

Inside the ESP32-S2 Chip

One chip, a whole system: a 240 MHz LX7 CPU, memory, a Wi-Fi radio, security hardware and a long list of peripherals, all joined by a GPIO matrix that can send most signals to almost any pin.

Inside the ESP32-S2: CPU + memory at the top, the GPIO matrix in the middle, peripherals and security below.

• CPU — one 32-bit Xtensa LX7 core up to 240 MHz. Fast enough for Wi-Fi, web servers, displays and audio.
• Memory — 320 KB SRAM and 128 KB ROM on chip, plus external SPI flash for your program and optional PSRAM (2 MB on WROVER) for big buffers.
• RTC memory (16 KB) — stays powered in deep sleep, so variables marked RTC_DATA_ATTR survive a sleep cycle.
• ULP coprocessors — a tiny RISC-V core and an FSM that can read sensors while the main CPU sleeps.
• Security — secure boot, flash encryption, AES/SHA/RSA accelerators, HMAC and a digital-signature peripheral protect your firmware and cloud keys.

ESP32-S2 Modules and Dev Boards

You rarely solder the bare chip. Espressif sells it in certified modules, and dev boards like the Saola-1, DevKitM-1 or the popular S2 Mini put a module on a breadboard-friendly PCB.

The four common module styles — check the laser marking on the shield to see which one your board uses.

Full ESP32-S2 GPIO Pinout

Dev boards arrange their headers differently, but the GPIO numbers and functions are fixed by the chip. This map shows all 43 GPIOs with their ADC channel, touch pad, DAC, USB, SPI, UART, JTAG, flash and strapping roles — use it with any ESP32-S2 board.

Every ESP32-S2 GPIO and its functions. Left: the RTC-domain pins GPIO0–21. Right: GPIO26–46.

For a quick overview, here are all pin numbers colour-coded by their main job:

GPIO0–46 at a glance — note the gap at 22–25 and the flash pins 26–32 you should leave alone.

Every Pin Explained

Let's go through each group of pins, what it can do, and which ones to avoid.

Power & control pins (on dev boards)

• 5V — 5 V from USB, or a 5 V input into the on-board LDO.
• 3V3 — the regulated 3.3 V rail for sensors (or a clean 3.3 V input if you skip USB).
• GND — ground; several pins on both headers.
• RST / EN — chip enable; pull LOW to reset.

Native USB OTG — the S2 Superpower

The ESP32-S2 has a full-speed USB OTG controller built in, on GPIO19 (D−) and GPIO20 (D+). With the TinyUSB stack your board can plug into a PC and appear as a keyboard, mouse, serial port, flash drive or MIDI instrument.

Two ways in: the classic USB-UART bridge, or the chip's own USB OTG port acting as a real USB device.

• CDC (serial) — Serial over native USB, no bridge chip needed (Arduino: Tools → USB CDC On Boot → Enabled).
• HID — USBHIDKeyboard and USBHIDMouse for macro pads, password typers and game controllers.
• MSC — expose flash or an SD card as a USB drive (CircuitPython uses this to show a CIRCUITPY drive).
• Firmware upload — boards without a bridge chip (such as the S2 Mini) are flashed straight over native USB.

Strapping Pins and Boot Modes

At the moment of reset the ESP32-S2 reads three strapping pins — GPIO0, GPIO45 and GPIO46 — to decide how to start.

Strapping pins decide the boot mode; the BOOT + RST sequence forces download mode by hand.

Powering the ESP32-S2

The chip needs 3.0–3.6 V. Dev boards take 5 V from USB or the 5V pin and drop it to 3.3 V with an LDO regulator.

USB or 5V pin → LDO → 3.3 V rail. Wi-Fi transmit bursts need a solid supply.

• Wi-Fi peaks — the radio pulls short bursts of a few hundred mA. Weak cables or long wires cause brown-out resets.
• Batteries — a single Li-ion cell (3.0–4.2 V) needs a low-dropout regulator or a buck/buck-boost converter to give a steady 3.3 V.
• Decoupling — add a 10 µF + 100 nF capacitor pair close to the 3V3 pin on custom boards.

Sleep Modes and the ULP Coprocessor

Low power is one of the ESP32-S2's design goals. Switching off what you don't need can stretch battery life from hours to months.

From active to hibernation: each step turns more of the chip off.

• Deep sleep keeps only the RTC domain alive; the chip restarts from setup() on wake. Save state in RTC_DATA_ATTR variables.
• Wake sources — timer, a level on an RTC GPIO (GPIO0–21), a touch pad or a ULP program.
• ULP RISC-V — can sample a sensor every few seconds and only wake the main CPU when a threshold is crossed.

ADC and DAC

The ESP32-S2 has 20 ADC channels with a 13-bit result (0–8191) and two 8-bit DACs for real analog output.

ADC: measure a voltage in 8192 steps. DAC: output 256 real voltage levels on GPIO17/18.

Need to measure more than 2.5 V? Use a resistor divider — our resistor guide explains the maths — and analogReadMilliVolts() for a calibrated reading.

Capacitive Touch Pins

14 touch pads (T1–T14 on GPIO1–14) sense a finger through plastic or glass — no mechanical button needed.

A finger adds capacitance; on the S2 the touchRead() value goes up when touched (the original ESP32 goes down).

Read a baseline at start-up and compare against it, because the raw value depends on pad size and wire length. Touch pads can also wake the chip from deep sleep.

PWM with the LEDC Controller

The LEDC peripheral provides 8 PWM channels that the GPIO matrix can route to almost any output pin.

Duty cycle sets brightness or speed; frequency and resolution are set per pin in code.

• ledcAttach(pin, freq, bits) then ledcWrite(pin, duty) (Arduino-ESP32 3.x). analogWrite() also works.
• Higher frequency means lower resolution: frequency × 2^bits must stay under the 80 MHz clock.
• Typical settings: LEDs 5 kHz / 8-bit, servos 50 Hz / 14–16-bit, motors 20 kHz / 10-bit.

UART, I2C, SPI, I2S, TWAI & RMT

Thanks to the GPIO matrix you can put most buses on the pins that suit your layout. These are the defaults the Arduino core uses.

Default pins: UART0 43/44, I2C 8/9, SPI 34–37 — and most can be moved.

Wi-Fi on the ESP32-S2

The S2 speaks 2.4 GHz 802.11 b/g/n. It can join your router (station), create its own network (access point), or do both — but it has no Bluetooth.

Station, access point, or both — using the same WiFi.h library as the original ESP32.

All the usual ESP32 networking libraries work: WebServer, HTTPClient, WiFiClientSecure (TLS), MQTT clients, OTA updates, ESP-NOW and mDNS.

Programming the ESP32-S2

The S2 works with the Arduino IDE, Espressif's ESP-IDF, MicroPython and CircuitPython.

1. Arduino IDE → Boards Manager → install esp32 by Espressif Systems.
2. Select ESP32S2 Dev Module (or your board, e.g. LOLIN S2 Mini) and the port.
3. Using native USB for serial? Set USB CDC On Boot → Enabled.
4. Click Upload. If nothing happens: hold BOOT, tap RST, release BOOT, upload, then press RST to run.

Code Examples

Short, copy-paste Arduino sketches for the main ESP32-S2 features.

1. Blink an LED on GPIO5

const int LED = 5;                     // LED + 220 Ω to GND
void setup() { pinMode(LED, OUTPUT); }
void loop() {
  digitalWrite(LED, HIGH); delay(500);
  digitalWrite(LED, LOW);  delay(500);
}

2. Scan for Wi-Fi networks

#include <WiFi.h>
void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
}
void loop() {
  int n = WiFi.scanNetworks();
  for (int i = 0; i < n; i++)
    Serial.printf("%-24s %4d dBm\n", WiFi.SSID(i).c_str(), WiFi.RSSI(i));
  Serial.println();
  delay(5000);
}

3. Read a touch pad

void setup() { Serial.begin(115200); }
void loop() {
  Serial.println(touchRead(T1));      // GPIO1 — value rises when touched
  delay(100);
}

4. ADC in, DAC out

void setup() { Serial.begin(115200); }
void loop() {
  int raw = analogRead(1);           // GPIO1 = ADC1_CH0, 0..8191
  int mv  = analogReadMilliVolts(1);  // calibrated millivolts
  Serial.printf("raw=%d  %d mV\n", raw, mv);
  dacWrite(17, raw >> 5);            // 13-bit -> 8-bit, out on GPIO17
  delay(200);
}

5. Deep sleep with a boot counter

RTC_DATA_ATTR int boots = 0;          // kept in RTC memory
void setup() {
  Serial.begin(115200);
  delay(1000);
  boots++;
  Serial.printf("Boot number %d\n", boots);
  esp_sleep_enable_timer_wakeup(10ULL * 1000000);  // 10 s
  esp_deep_sleep_start();
}
void loop() {}

Beginner Mini-Projects

Four small builds that show off what makes the ESP32-S2 different: touch, Wi-Fi and native USB.

Wiring for the projects — LED + 220 Ω on GPIO5, button on GPIO4, touch pad on GPIO1. Other LED values: LED resistor calculator.

uint32_t base;
bool lamp = false, wasTouched = false;

void setup() {
  pinMode(5, OUTPUT);
  delay(500);
  base = touchRead(T1);                // untouched baseline
}
void loop() {
  bool touched = touchRead(T1) > base * 1.2;   // 20% above baseline
  if (touched && !wasTouched) { lamp = !lamp; digitalWrite(5, lamp); }
  wasTouched = touched;
  delay(30);
}

#include <WiFi.h>
#include <WebServer.h>
WebServer server(80);

void setup() {
  Serial.begin(115200);
  pinMode(5, OUTPUT);
  WiFi.begin("MySSID", "password");
  while (WiFi.status() != WL_CONNECTED) delay(500);
  server.on("/",    []() { server.send(200, "text/html", "<a href='/on'>ON</a> | <a href='/off'>OFF</a>"); });
  server.on("/on",  []() { digitalWrite(5, HIGH); server.send(200, "text/plain", "LED ON"); });
  server.on("/off", []() { digitalWrite(5, LOW);  server.send(200, "text/plain", "LED OFF"); });
  server.begin();
  Serial.println(WiFi.localIP());
}
void loop() { server.handleClient(); }

#include "USB.h"
#include "USBHIDKeyboard.h"
USBHIDKeyboard Keyboard;

void setup() {
  pinMode(4, INPUT_PULLUP);
  Keyboard.begin();
  USB.begin();
}
void loop() {
  if (digitalRead(4) == LOW) {        // pressed
    Keyboard.println("Hello from the ESP32-S2!");
    delay(500);                         // simple debounce / repeat delay
  }
}

RTC_DATA_ATTR int readings = 0;

void setup() {
  Serial.begin(115200);
  delay(1000);
  int mv = analogReadMilliVolts(2);    // GPIO2 = ADC1_CH1
  readings++;
  Serial.printf("Reading %d: %d mV\n", readings, mv);
  esp_sleep_enable_timer_wakeup(30ULL * 1000000);
  esp_deep_sleep_start();              // ~tens of µA until the next wake
}
void loop() {}

ESP32-S2 vs ESP32 vs ESP32-S3 vs ESP32-C3

All four chips do 2.4 GHz Wi-Fi at 3.3 V, but they differ in cores, Bluetooth and USB. Here is how to choose.

The ESP32 family side by side.

• Pick the ESP32-S2 for USB devices, Wi-Fi-only sensors, touch interfaces and the lowest cost per Wi-Fi node.
• Pick the original ESP32 when you need Bluetooth Classic (audio, serial SPP) or two cores.
• Pick the ESP32-S3 for camera, AI/vector maths, BLE 5 and native USB together.
• Pick the ESP32-C3 for the cheapest Wi-Fi + BLE with a RISC-V core.

Specifications

The ESP32-S2 at a glance.

Key ESP32-S2 numbers: CPU, memory, radio, USB, GPIO, analog, buses, low power and security.

Key Terms — Glossary

Related Topics & Common Searches

Keep building your microcontroller and electronics knowledge with these Power4All guides:

People Also Search For

esp32-s2 · esp32-s2 pinout · esp32 s2 gpio · esp32-s2 datasheet · esp32-s2 vs esp32 · esp32-s2 vs esp32-s3 · esp32-s2 vs esp32-c3 · does esp32-s2 have bluetooth · esp32-s2 native usb · esp32-s2 usb hid keyboard · esp32-s2 tinyusb · esp32-s2 saola-1 pinout · esp32-s2 wroom vs wrover · esp32-s2 mini-1 · lolin s2 mini pinout · esp32-s2 strapping pins · esp32-s2 boot mode · esp32-s2 not detected · esp32-s2 adc resolution · esp32-s2 dac · esp32-s2 touch pins · esp32-s2 pwm · esp32-s2 i2c pins · esp32-s2 spi pins · esp32-s2 deep sleep current · esp32-s2 ulp risc-v · esp32-s2 arduino ide · esp32-s2 micropython · esp32-s2 circuitpython · esp32-s2 web server · esp32-s2 projects · esp32-s2 5v tolerant.

Frequently Asked Questions

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

Conclusion & Key Takeaways

The ESP32-S2 trades Bluetooth and a second core for native USB, more GPIOs, better analog and lower power — making it the go-to chip for Wi-Fi USB gadgets and efficient IoT sensors.

Continue Learning