ESP32

Executive summary

• ESP32 is the family of SoCs (System-on-Chip) from Espressif Systems that combines a microcontroller, Wi-Fi, Bluetooth Classic/BLE, and optionally Zigbee/Thread/Matter on a single chip—starting at ~3 USD. It is the entry-level hardware par excellence for anyone exploring what IoT is and wanting to move from theory to their first prototypes.
• The successor to the ESP8266 (Wi-Fi only). Current families: classic ESP32 (Xtensa LX6 dual-core), ESP32-S3 (Xtensa LX7 + AI acceleration), ESP32-C3/C6 (RISC-V single-core), ESP32-H2 (RISC-V + 802.15.4 for Matter/Thread).
• The leader in consumer, maker, and many commercial IoTITermIoT (Internet of Things)The IoT (Internet of Things) is the network of physical objects with sensors, software and connectivity that collect and exchange data and act autonomously.View profile products (Sonoff, Shelly, Tasmota).
• Frameworks: Arduino, ESP-IDF (official), PlatformIO, MicroPython, CircuitPython, Espruino.
• When NOT to use it: applications with strict industrial certification requirements (STM32 with certification is better), ultra-low-power projects (BLEBTermBluetooth Low Energy (BLE)Bluetooth Low Energy (BLE) is the low-power variant of Bluetooth, for sending small amounts of data intermittently with minimal battery. It dominates wearables and proximity. Maintained by the Bluetooth SIG.View profile-only is better on the nRF52), LoRa-only projects (STM32WLSTermSTM32WLThe STM32WL is an STMicroelectronics microcontroller with a sub-GHz LoRa radio integrated on the same chip, designed for LoRaWAN nodes.View profile is better).

Families and differences

Quick takeaway: for Matter, choose the ESP32-C6 or H2. For a modern general-purpose chip, the C3 or S3. The classic ESP32 is still relevant but already 7 years on the market.

The logic behind this fragmentation is deliberate. Espressif migrated from the Xtensa architecture (proprietary, licensed from Cadence) to RISC-V (open) in the C and H families to cut the core's licensing cost and gain control over its own silicon. For someone designing a product, the practical consequence is direct: an ESP32-C3 delivers performance equivalent to the old ESP8266 at a similar price but with BLE included, while the C6 and H2 families open the door to Matter and Thread without changing vendors or toolchains. Choosing a variant, then, is not a matter of raw power but of which radios the project demands and how many years of SDK support you'll need to maintain.

Technical specifications (classic ESP32 — reference)

These figures hide the design decisions that most affect a real product. The ~320 KB of RAM available to the application looks generous next to an 8-bit MCU, but it runs out fast once TLS, a display buffer, and an MQTTProtocolMQTTThe standard pub/sub protocol of IoTView profile stack coexist at the same time: sizing memory is the first bottleneck in serious projects. The ~80 mA draw during Wi-Fi transmission dooms any battery design that doesn't manage deep sleep well, and the ADC's well-known non-linearity makes calibration mandatory whenever you measure analog signals with precision. Reading the table isn't enough; you have to translate each row into a concrete design constraint before committing to the chip.

Real-world use cases

Frameworks and development environments

Arduino IDE (easy entry point)

The following example connects the ESP32 to an MQTT broker using PubSubClient:

#include <WiFi.h>
#include <PubSubClient.h>

WiFiClient espClient;
PubSubClient client(espClient);

void setup() {
  Serial.begin(115200);
  WiFi.begin("ssid", "pass");
  while (WiFi.status() != WL_CONNECTED) delay(500);
  
  client.setServer("broker.local", 1883);
  client.connect("esp32-01");
  client.publish("home/livingroom/temp", "22.5");
}

void loop() {
  client.loop();
}

ESP-IDF (official Espressif, production)

C / C++ with FreeRTOS, maximum control. CMake build system. A steeper curve, but access to every feature.

#include "esp_wifi.h"
#include "mqtt_client.h"

void app_main() {
  esp_wifi_init(...);
  esp_mqtt_client_handle_t client = esp_mqtt_client_init(...);
  esp_mqtt_client_publish(client, "home/livingroom/temp", "22.5", 0, 1, 0);
}

PlatformIO (Arduino IDE alternative)

A modern CLI, dependency management, multi-board profiles. Recommended for serious projects without going to pure ESP-IDF.

MicroPython / CircuitPython

For rapid prototyping without compiling:

import network, time
from umqtt.simple import MQTTClient

wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect("ssid", "pass")

client = MQTTClient("esp32-01", "broker.local")
client.connect()
client.publish(b"home/livingroom/temp", b"22.5")

Connectivity: how it connects to the internet

The ESP32 handles an internal TCP/IP stack (LwIP). One of its most common production combinations is connecting to cloud IoT platforms such as AWS IoT Core over MQTT. It natively supports:

• Simultaneous Wi-Fi STA + AP ("AP+STA" mode)
• HTTP/HTTPS server and client (esp_http_server, esp_http_client)
• MQTT 3.1.1/5 (esp_mqtt_client)
• WebSocket
• mDNS (local discovery)
• ESP-NOW (proprietary peer-to-peer 2.4 GHz protocol, no Wi-Fi)
• OTA updates (over-the-air firmware)

ESP32 vs the alternatives

The conclusion of this comparison is not that the ESP32 always wins, but that it wins on the price-versatility-community axis. When the deciding factor is extreme battery life, the nRF52840 clearly beats it; when it's kilometer-scale range, the STM32WL with integrated LoRa has no rival in its class; and when strict industrial certification is required, MCUs from NXP or ST with enterprise support justify their premium. The ESP32 is the reasonable default for most prototyping and consumer-production projects precisely because it isn't the best at any single extreme, but it is very capable across all of them at once.

Pros and cons

Pros

• Unbeatable price: 3 USD for an ESP32-C3 chip, ~10 USD for a complete dev board
• Huge ecosystem: ArduinoCompanyArduinoOpen source hardware and software platform for makersView profile libraries, frameworks, an active Spanish-speaking community
• Multi-radio: Wi-Fi + BT/BLE + (C6/H2) Thread/ZigbeeProtocolZigbeeVeteran 2.4 GHz mesh — backbone of many smart home hubsView profile on a single chip
• Good documentation: the ESP-IDF docs are solid
• Active Espressif: new chips every year, the classic ESP32 still supported
• OTA updates out of the box
• Matter ready: official ESP32-C6/H2 with the ESP-Matter SDK

Cons

• Power consumption: the classic ESP32 is not a low-power leader (vs the nRF52, which is better for BLE-only)
• Variable module quality: cheap Chinese modules can have inconsistent components
• Certification: for CE/FCC you need a pre-certified module (don't use a bare chip)
• GPIO ADC noise: the classic ESP32's ADC has known non-linearity—always calibrate
• No industrial spec: it isn't a chip for -40 to +125 °C automotive environments
• Security: the ESP32 has secure boot and flash encryption, but you have to enable them explicitly. Review the IoT security guide for best practices before taking any project to production.

Getting started: your first project

Hardware

• Recommended dev board: ESP32-DevKit-C-32 or LilyGO TTGO T-Display (with a screen)
• Programming: USB-C cable
• Power: USB from the PC during development

Software

1. Install Arduino IDE 2.x or VSCode + PlatformIO
2. Add the board manager: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
3. Select the "ESP32 Dev Module" board
4. Load the WiFi > WiFiScan example

Hello World: Wi-Fi + LED

#include <WiFi.h>

const int LED = 2; // On-board LED

void setup() {
  pinMode(LED, OUTPUT);
  Serial.begin(115200);
  WiFi.begin("ssid", "pass");
  
  while (WiFi.status() != WL_CONNECTED) {
    digitalWrite(LED, !digitalRead(LED));
    delay(500);
  }
  
  digitalWrite(LED, HIGH);
  Serial.println(WiFi.localIP());
}

void loop() {}

Primary sources

• Espressif ESP32 product page (accessed: 2026-05)
• ESP-IDF docs (accessed: 2026-05)
• Arduino-ESP32 GitHub
• ESPHome — for Home AssistantHTermHome AssistantHome Assistant is an open-source home automation platform focused on local control and privacy, with broad integration support.View profile
• PlatformIO
• Random Nerd Tutorials (EN maker-community reference)