The DFRobot FireBeetle 2 ESP32-UE addresses several of those practical requirements. It has an external antenna connector, built-in Li-ion battery charging, low-power hardware, 16 MB flash, and 2 MB PSRAM. It also includes a connector for compatible displays.

In this article, we'll cover what these features do, set up the board in Arduino IDE, and show how to check its Wi-Fi signal strength and sleep current.

What Is the FireBeetle 2 ESP32-UE?

The FireBeetle 2 ESP32-UE uses an ESP32-WROOM-32UE-N16R2 module. This is based on the original dual-core ESP32, not a newer ESP32-S3 or ESP32-C6. You still get the familiar Wi-Fi, Bluetooth, PWM, ADC, DAC, touch sensing, UART, SPI, and I2C features.

Here are the main specifications:

• Dual-core Xtensa LX6 processor, up to 240 MHz
• 16 MB external flash and 2 MB PSRAM
• 520 KB internal SRAM
• 2.4 GHz Wi-Fi (802.11 b/g/n)
• Bluetooth 4.2 Classic (BR/EDR) and BLE
• USB-C for programming and power
• Single-cell Li-ion battery connector and onboard charging
• GDI display connector and onboard LEDs
• Board dimensions: 25.4 × 60 mm

DFRobot lists 17 digital pins and 11 analog-capable pins among the board's interfaces. Check the exact pins and their restrictions before wiring a project.

The processor is familiar. The differences are mostly in how DFRobot has packaged it for projects that need to work away from a desk.

Why Use an External Antenna?

If you've used a regular ESP32-WROOM module, you've probably seen the exposed PCB antenna at one end. The ESP32-WROOM-32UE replaces that antenna with a small RF connector for an external 2.4 GHz Wi-Fi/Bluetooth antenna.

This matters when the ESP32 sits inside an enclosure. A nearby battery, display, ground plane, wiring, or metal surface can affect antenna performance. An external antenna lets you choose a better location without moving the entire circuit board.

Imagine an outdoor environmental monitor. The board and sensors sit inside a weather-resistant enclosure, while the antenna can be placed away from the crowded electronics or outside the enclosure using suitable weatherproof hardware.

That does not automatically make the FireBeetle a long-range ESP32. Signal strength also depends on antenna gain, orientation, cable loss, obstacles, interference, and the access point. An external antenna gives you more control over placement, not a guaranteed increase in range. We'll return to a simple Wi-Fi comparison after setting up the board.

Battery Power Without a Separate Charger Board

A better antenna location solves one problem for a remote sensor. The next is power.

The FireBeetle has a PH2.0 connector for a single-cell 3.7 V nominal Li-ion/LiPo battery. A fully charged cell can reach about 4.2 V. The board also includes charging circuitry, so you can connect USB power to charge the attached battery while you develop or service the device.

On a typical ESP32 prototype, you might need a separate battery charger and a suitable regulator. The FireBeetle already includes much of that hardware, which can reduce the number of extra modules and wires.

Before connecting a battery, check the connector polarity against the board documentation. PH2.0 connectors on different products do not always use the same wiring order. Use a suitable protected cell or battery pack and follow the manufacturer's charging and handling requirements.

If you're building a solar-powered device, you still need a charging and power-management arrangement suitable for the solar panel and battery. The battery connector alone is not a solar charge controller.

How Low Can the FireBeetle Go?

Battery power becomes much more useful when the ESP32 can sleep between readings.

The ESP32 itself supports deep sleep, but a development board contains more than the ESP32. Its regulator, USB interface, LEDs, and other circuits may continue drawing current even while the processor sleeps.

DFRobot includes a low-power solder jumper, connected by default. According to DFRobot, disconnecting it reduces static consumption by approximately 500 µA, and the board can reach about 13 µA in deep sleep under the manufacturer's stated conditions. Treat that number as a published specification rather than a measured result for your complete project.

There is a tradeoff. With the jumper disconnected, DFRobot says the onboard RGB LED can only be driven when USB power is present. If you don't need that LED in a battery-powered design, the reduced standby current may be worthwhile.

We'll use a short deep-sleep sketch later and measure current from the battery connection. The actual result will also depend on sensors, displays, pull-ups, and other connected hardware.

What Do 16 MB Flash and 2 MB PSRAM Add?

The ESP32-UE module carries 16 MB flash, compared with the 4 MB found on many basic ESP32 development boards. That extra storage can make room for larger firmware images, OTA update partitions, web pages, fonts, and other files.

The amount available to a sketch or filesystem still depends on the selected flash-size settings and partition scheme. A 16 MB chip doesn't mean one Arduino sketch can automatically use all 16 MB.

PSRAM serves a different purpose. It adds 2 MB of external working memory, which can help when an application needs large buffers, such as a graphical interface, web response data, or image content. PSRAM is slower than internal RAM and is not a substitute for it in every application.

Also, having PSRAM on the module doesn't mean every allocation automatically uses it. The selected firmware configuration must initialize PSRAM, and applications may need PSRAM-aware allocations or libraries. We'll check shortly whether Arduino detects it.

The GDI Display Connector

The board also has DFRobot's GDI display interface. It uses an 18-pin FPC connection for compatible displays, helping reduce the jumper-wire clutter found in some display prototypes.

For example, a sensor node could read temperature and humidity, update a local dashboard, and send the same measurements over Wi-Fi:

This is one reason the extra flash and PSRAM are useful together. They leave more room for assets and display buffers in projects using graphical libraries such as LVGL. Make sure the specific display and its library support the FireBeetle's GDI pin mapping; GDI isn't a universal connector for all displays.

Understanding the FireBeetle ESP32-UE Pinout

The pinout is mostly familiar, but DFRobot uses Arduino-style aliases alongside the underlying ESP32 GPIO numbers.

For example, the onboard indicator LED is on GPIO2, which DFRobot labels D9 in its FireBeetle Arduino examples. The onboard WS2812 RGB LED uses GPIO5/D8, while the user button uses GPIO27/D4.

Check the actual GPIO number when adapting a generic ESP32 example. Some pins have boot-strapping functions, connect to onboard components, or are reserved for module memory or programming. The module's flash/PSRAM connections also mean you should not assume every GPIO number mentioned in a generic ESP32 tutorial is available for general use.

For analog sensors, one restriction is especially important. The original ESP32 shares ADC2 with Wi-Fi. If your project needs Wi-Fi and analog readings at the same time, use an available ADC1 pin instead. On this board, GPIO34 and GPIO35 are useful ADC1 options. Both are input-only and have no internal pull-up or pull-down resistors.

That small pin choice can save a lot of debugging in a Wi-Fi sensor project.

Getting Started with Arduino IDE

You can program the ESP32-UE with Arduino IDE, ESP-IDF, or MicroPython. We'll use Arduino here because the first tests need only a few lines of code.

To set up the board in Arduino IDE:

1. Install the esp32 by Espressif Systems boards package through Boards Manager. If it isn't listed, add https://espressif.github.io/arduino-esp32/package_esp32_index.json under Additional Boards Manager URLs.
2. Go to Tools > Board > ESP32 Arduino > FireBeetle ESP32-E. This is the selection shown in DFRobot's ESP32-UE getting-started guide, despite the board itself being the UE antenna variant.
3. Connect the board with a USB-C data cable and select the correct serial port.
4. Upload the blink sketch below.

const int LED_PIN = D9;  // FireBeetle alias for GPIO2

void setup() {
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_PIN, HIGH);
  delay(500);
  digitalWrite(LED_PIN, LOW);
  delay(500);
}

The small onboard LED should turn on for half a second and off for half a second. It's a useful first check that the board, USB connection, and Arduino settings are working.

Checking PSRAM

Next, upload this sketch and open Serial Monitor at 115200 baud:

void setup() {
  Serial.begin(115200);
  delay(1000);

  if (psramFound()) {
    Serial.println("PSRAM detected");
    Serial.print("Total PSRAM: ");
    Serial.println(ESP.getPsramSize());
    Serial.print("Free PSRAM: ");
    Serial.println(ESP.getFreePsram());
  } else {
    Serial.println("PSRAM not detected");
  }
}

void loop() {
}

A correctly initialized N16R2 module should report about 2 MB of total PSRAM, with some memory already in use.

Connecting to Wi-Fi and Reading RSSI

Now for a test that relates directly to the external antenna. This sketch connects to a 2.4 GHz network and prints the received signal strength indicator (RSSI) every second.

#include <WiFi.h>

const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  unsigned long start = millis();
  while (WiFi.status() != WL_CONNECTED &&
         millis() - start < 15000) {
    delay(500);
    Serial.print(".");
  }

  if (WiFi.status() == WL_CONNECTED) {
    Serial.println("\nWi-Fi connected");
    Serial.print("IP address: ");
    Serial.println(WiFi.localIP());
  } else {
    Serial.println("\nWi-Fi connection timed out");
  }
}

void loop() {
  if (WiFi.status() == WL_CONNECTED) {
    Serial.print("RSSI: ");
    Serial.print(WiFi.RSSI());
    Serial.println(" dBm");
  } else {
    Serial.println("Wi-Fi disconnected");
  }
  delay(1000);
}

RSSI is expressed in dBm. -45 dBm indicates a stronger received signal than -80 dBm. The number will fluctuate as the radio environment changes.

Comparing Wi-Fi Signal Strength

To see what antenna placement changes in practice, compare the FireBeetle against a regular ESP32 board with a PCB antenna. Use the same access point, 2.4 GHz network, and test locations. Keep board and antenna orientation consistent, collect at least ten readings at each point, and calculate the average.

Record the external antenna model and any RF cable used. If possible, repeat the test with the FireBeetle antenna inside and outside the enclosure. That gives a more useful comparison than assuming an external antenna is always better.

Measuring Deep-Sleep Current

The other feature worth checking is power consumption. For a simple test, we can make the ESP32 sleep for 60 seconds, wake up, and then go back to sleep.

#include "esp_sleep.h"

void setup() {
  Serial.begin(115200);
  delay(500);

  esp_sleep_enable_timer_wakeup(60ULL * 1000000ULL);
  Serial.println("Entering deep sleep for 60 seconds");
  Serial.flush();
  esp_deep_sleep_start();
}

void loop() {
}

Use the Wi-Fi sketch from the previous section to record current while connected, then upload the deep-sleep sketch for the two sleep measurements. For current measurements, disconnect USB power and measure at the battery supply with a meter that can resolve microamp-level current. Keep the antenna connected but remove unnecessary external loads, such as a display or sensors, for the initial board-only comparison.

Measure with the low-power jumper intact, then repeat after disconnecting it, following DFRobot's instructions. Power the board down before changing the jumper, and note the meter and battery supply used. Wi-Fi active current changes rapidly, so a single instantaneous reading does not represent all operating conditions.

Is the FireBeetle 2 ESP32-UE Worth Choosing?

I wouldn't buy the FireBeetle just to blink LEDs or learn basic ESP32 programming. A cheaper, generic ESP32 board will do those jobs.

The FireBeetle becomes more interesting when several requirements appear together. Imagine a monitoring device in an enclosure that reads sensors every few minutes, reports data over Wi-Fi, and runs on a battery. In that case, you can position the antenna away from the electronics, use the onboard charger, and reduce standby current between readings. If you need a local dashboard, the extra memory and GDI interface are useful additions.

There are also reasons to choose something else. The FireBeetle uses the original ESP32 architecture. An ESP32-S3 board may be a better fit for newer processing features or native USB, while an ESP32-C6 is worth considering for Wi-Fi 6 or IEEE 802.15.4 support. Those boards have different peripheral and software tradeoffs, so the newer chip isn't automatically better for every project.

Final Thoughts

What makes the FireBeetle 2 ESP32-UE useful isn't a faster processor. It's the combination of an external antenna connection, battery-oriented power hardware, low-power options, and enough memory for a more complete IoT interface.

For a breadboard experiment, these details may not matter. But for an ESP32 that needs to sit inside a box, spend most of its time asleep, and communicate reliably, those details are exactly what I'd check before choosing a board.

Need board-specific pin mappings, power details, and reference drawings? See the official DFRobot FireBeetle 2 ESP32-UE documentation.

The post DFRobot FireBeetle 2 ESP32-UE: What Makes This ESP32 Board Different? appeared first on Teach Me Microcontrollers!.

An ESP32 can run small machine-learning models locally, recognize voice commands, classify sensor data, process images, and even communicate with much larger AI models through the Internet. Newer devices such as the ESP32-S3 are especially interesting because Espressif added processor instructions that accelerate neural-network and signal-processing operations.

However, the term ESP32 AI can mean several different things. It may refer to TinyML running directly on the microcontroller, an ESP32 acting as a client for cloud-based AI, an AI camera project, or even the popular AI-Thinker ESP32-CAM board. In this guide, I will separate those concepts and look at what AI on an ESP32 can realistically do.

What Does ESP32 AI Mean?

There isn't one specific technology called "ESP32 AI." Instead, there are several ways to combine artificial intelligence with an ESP32. The most important distinction is where the AI model actually runs.

1. AI Running Directly on the ESP32

In this setup, the trained machine-learning model is stored in the ESP32's flash memory and inference occurs directly on the microcontroller. For example, a microphone could continuously listen for the words "ON" and "OFF." Instead of sending every audio sample to a server, the ESP32 processes the audio locally and decides which word it heard. This is often called edge AI, embedded machine learning, or TinyML. I already have a complete TinyML with ESP32 tutorial that covers the model-training and deployment process in detail. This article will focus more on what is possible and which approach makes sense for a particular project.

2. ESP32 Connecting to Cloud AI

The ESP32 does not necessarily have to run the AI model. Because it has Wi-Fi, the ESP32 can collect data and send it to an AI service running on a much more powerful server.

The basic architecture looks like this:

3. ESP32 as Part of an AI System

There is also a middle ground. An ESP32 might preprocess sensor data locally and only send interesting events to a server. For example, it could detect unusual vibration using a small local model and then send the captured data to a more powerful AI service for further analysis. This hybrid approach can reduce bandwidth while still allowing the system to use large models.

ESP32 AI vs AI-Thinker ESP32-CAM

One source of confusion is worth clearing up early. Searching for "ESP32 AI" often returns results involving the AI-Thinker ESP32-CAM. Despite the name, AI-Thinker is the manufacturer/brand associated with the module. The "AI" in AI-Thinker does not mean that the ESP32-CAM itself contains a dedicated artificial-intelligence processor. The ESP32-CAM is still useful for AI projects because it combines an ESP32 with a camera. Images can either be processed locally with sufficiently small models or sent to another device or server for more demanding computer-vision tasks.

So:

The two concepts overlap, but they are not the same thing.

Can an ESP32 Really Run Artificial Intelligence?

Yes, but the important word is inference. Most ESP32 AI projects do not train their neural networks on the microcontroller. Training might require thousands or millions of calculations performed repeatedly over a large dataset. Instead, training normally takes place on a PC or cloud platform. Once training is finished, the much smaller resulting model is exported and placed on the ESP32.

The workflow therefore looks like this:

For example:

Why the ESP32-S3 Is Better for AI

The original ESP32 can run small machine-learning models, and that is exactly what I used in my earlier TinyML projects. However, if I were buying a board specifically for a new ESP32 AI project today, I would normally choose an ESP32-S3, preferably a version with PSRAM. The ESP32-S3 includes vector instructions that accelerate operations commonly found in neural networks and digital signal processing. It is important to describe this correctly: the ESP32-S3 does not have a large dedicated neural-processing unit comparable to the AI accelerator found in some application processors. Instead, its processor includes instructions that make certain mathematical operations considerably more efficient.

This matters because neural networks repeatedly perform operations such as multiplication and accumulation:

$y = \sum_{i=0}^{n} w_i x_i + b$

where:

• x represents input values,
• w represents trained weights,
• b is the bias, and
• y is the resulting output.

A neural network may perform these operations thousands or millions of times for a single inference. The ESP32-S3 can therefore execute appropriately optimized models faster than a classic ESP32.

PSRAM Also Matters

Processor speed isn't the only limitation. A machine-learning model needs memory for:

• model weights,
• input data,
• intermediate layer outputs,
• the tensor arena or working memory, and
• your normal application code and buffers.

For very small sensor models, internal RAM may be enough. Camera and audio applications become much more demanding. An ESP32-S3 board with external PSRAM gives you considerably more room for frame buffers and larger models. That does not mean PSRAM automatically makes inference fast. External memory is generally slower than internal SRAM. However, having a slower place to store something is much better than not having enough memory to run the model at all.

What Kind of AI Can an ESP32 Run?

"AI" covers an enormous range of applications. Some are well suited to microcontrollers while others are completely unrealistic. Here are several applications that fit the ESP32 particularly well.

Sensor Classification

This is one of the easiest places to start. Suppose an accelerometer is attached to a machine. Instead of simply checking whether vibration exceeds a fixed threshold, a trained model could classify several operating states:

• normal operation,
• idle,
• unbalanced load,
• excessive vibration,
• possible fault.

The input consists of relatively small numerical datasets, so the model can also remain small.

Anomaly Detection

Instead of teaching the ESP32 every possible fault condition, a model can learn what normal sensor readings look like and identify unusual patterns. Possible applications include:

• machine condition monitoring,
• water pump monitoring,
• battery monitoring,
• unexpected power consumption, and
• environmental sensors.

This is an area where embedded AI can be more useful than simply putting a fixed threshold inside an if() statement.

Voice and Sound Recognition

Audio is another good match for the ESP32-S3. Instead of converting speech into arbitrary sentences, a small model might recognize a limited vocabulary such as: LIGHT, ON, OFF, FAN, OPEN, CLOSE

That task is much easier than full speech-to-text. I have a separate ESP32 TinyML voice command project using Edge Impulse for a practical example.

Other audio applications include:

• glass-breaking detection,
• alarm detection,
• machine noise classification,
• clap or sound recognition, and
• wake-word detection.

Image Classification

A camera image can be reduced to a small resolution and passed through a lightweight neural network. The output could answer a question such as:

Is this object:

Person 0.91 Cat 0.05 Background 0.04

This is more realistic for an ESP32 than asking it to fully understand a high-resolution image.

Object Detection

Object detection is harder than simple image classification because the model must determine both what an object is and where it appears in the image. Optimized object-detection models can run on newer ESP32 hardware, but memory usage and inference time quickly become important. For a battery-operated camera expected to recognize one or two objects, an ESP32-S3 may make sense. For multi-object high-resolution detection at high frame rates, a Raspberry Pi or more powerful processor is normally a better choice.

Gesture Recognition

Gesture recognition can use either camera images or motion sensors. An accelerometer-based gesture recognizer is particularly attractive because the input data is tiny compared with an image. You could teach a device to recognize different movements and perform commands without buttons.

On-Device ESP32 AI vs Cloud AI

Running a model locally is not automatically better.

The right solution depends on what the project needs.

For example, imagine a smart door. A local ESP32 model could detect a particular sound or wake word without sending continuous microphone recordings anywhere.

However, if you want the user to ask:

"Was anyone standing near the front door while I was away this afternoon?"

that is a much more complicated task. Sending selected images or event data to a larger AI model would make more sense.

ESP32 AI Frameworks and Tools

There are now several ways to deploy AI models on ESP32 devices.

TensorFlow Lite for Microcontrollers

TensorFlow Lite for Microcontrollers, commonly called TFLM, is designed to run neural-network inference on microcontrollers with limited RAM. It is useful when you want to understand the model deployment process more directly. I have a separate TensorFlow Lite on ESP32 tutorial with a voice activity detection example.

ESP-DL

ESP-DL is Espressif's neural-network inference framework for ESP devices. Its current toolchain can take trained models, quantize them, and convert them into a format optimized for supported Espressif chips. This is particularly interesting for ESP32-S3 projects because the framework can make use of optimized kernels for the chip. If I were developing a new performance-sensitive ESP32-S3 AI project, ESP-DL would be one of the first frameworks I would investigate.

ESP-WHO

ESP-WHO is aimed more specifically at computer-vision applications.

Typical applications include:

• face detection,
• face recognition,
• camera-based classification, and
• other embedded vision projects.

It is therefore worth checking when your ESP32 AI project starts with a camera rather than a microphone or sensor.

ESP-SR

For audio applications, Espressif also provides ESP-SR. It contains components for functions such as:

• audio front-end processing,
• wake-word detection, and
• speech-command recognition.

For a product that only needs to understand a limited command vocabulary, this is much more realistic than running a general speech-to-text model.

Edge Impulse

Edge Impulse provides a higher-level workflow for collecting datasets, extracting features, training models, and deploying them to embedded devices. It is especially convenient when experimenting with:

• accelerometers,
• microphones,
• environmental sensors, and
• small image datasets.

It can save a lot of setup time when your main goal is testing whether machine learning improves the project rather than building the ML toolchain yourself.

How Much Faster Is ESP32-S3 for AI?

This is something I prefer to measure rather than answer only from specifications. A useful experiment is to run the same small neural-network model on a classic ESP32 and an ESP32-S3. The model from my existing TinyML tutorial can be reused so that the network itself remains constant.

The important measurements are:

• model size,
• inference time,
• available heap before loading the model,
• available heap while the model is running, and
• whether PSRAM is required.

Inference time can be measured around the model's Invoke() function:

unsigned long startTime = micros();

TfLiteStatus invokeStatus = interpreter->Invoke();

unsigned long inferenceTime = micros() - startTime;

Serial.print("Inference time: ");
Serial.print(inferenceTime);
Serial.println(" us");

Can an ESP32 Run an LLM?

Technically, extremely small experimental language models can be squeezed into surprisingly limited hardware. However, this needs some perspective. The language models people normally associate with AI assistants contain millions or billions of parameters and require far more memory and processing power than a normal ESP32 can provide.

So if the goal is something like this:

User: Should I water my tomato plants today?

ESP32: Based on the soil moisture, temperature, weather forecast and your previous watering schedule, I recommend waiting until tomorrow.

the practical architecture is usually:

The ESP32 handles sensors, actuators and networking while the LLM handles natural-language reasoning. That is the approach demonstrated in my ESP32 OpenRouter AI project. There are experimental reasons to run tiny language models locally, but I would not choose an ESP32 for a project that actually needs ChatGPT-like conversation.

When Should You Use AI Instead of Normal ESP32 Code?

Not every project benefits from machine learning. Suppose a soil moisture sensor reads between 0 and 4095 and you simply want to switch a pump on below a fixed threshold.

Normal code is better:

if (moisture < threshold) {
    startPump();
}

A neural network would add complexity without solving a real problem. AI becomes more useful when the input contains a pattern that is difficult to describe using simple rules.

Consider vibration monitoring. A normal program might say:

if (vibration > 500) {
    fault = true;
}

But suppose a healthy motor sometimes exceeds 500 during startup while a failing bearing creates a particular frequency pattern even though its peak vibration remains below 500. Now the problem is no longer just a threshold. A trained model may be able to distinguish those patterns.

A simple rule I use is:

Which ESP32 Should You Use for AI?

For most new projects, this is how I would choose:

The interesting part is that the most powerful AI does not necessarily require the most powerful ESP32. If the microcontroller only needs to send a JSON request to an online LLM, even a classic ESP32 may be perfectly adequate. It is local inference where the ESP32-S3's extra capabilities become important.

ESP32 AI Project Ideas

If you want to experiment with ESP32 AI, here are some projects that are realistic enough to build:

• Machine vibration classifier — use an accelerometer to distinguish normal and abnormal operation.
• Offline voice-controlled switch — recognize a handful of commands locally without sending audio to the cloud.
• Sound classifier — distinguish alarms, claps, machinery or other sounds using an I2S microphone.
• Smart camera — detect whether a person or object is present before saving or transmitting an image.
• Gesture controller — classify accelerometer movements and use them to control a device.
• Sensor anomaly detector — identify unusual temperature, current, pressure or vibration patterns.
• AI sensor assistant — collect sensor readings on the ESP32 and send them to an LLM to generate a human-readable explanation.

The first five can potentially operate entirely offline. The final example is better suited to a cloud AI service.

ESP32 AI Frequently Asked Questions

Is the ESP32 powerful enough for AI?

Yes, if the model and task are small enough. Sensor classification, anomaly detection, wake words, simple audio classification and lightweight vision applications can all be appropriate. Large generative AI models are not.

Do I need an ESP32-S3 for machine learning?

No. The original ESP32 can run small TinyML models. However, the ESP32-S3 is generally a better choice for new on-device AI projects because of its vector instructions and the availability of boards with substantial PSRAM.

Does the ESP32-S3 have an AI accelerator?

It has processor extensions designed to accelerate neural-network and signal-processing calculations. It is better to think of these as AI-friendly vector instructions rather than a separate high-performance NPU.

Do I need PSRAM?

Not always. Very small sensor models can run entirely from internal memory. PSRAM becomes increasingly useful for camera frames, audio buffers and larger neural networks.

Can ESP32 run ChatGPT locally?

Not in the sense most people expect from ChatGPT. Tiny experimental language models are possible, but practical conversational AI is better handled by having the ESP32 communicate with an online LLM.

Is ESP32-CAM an AI board?

The camera makes it useful for AI applications, but the "AI" in AI-Thinker ESP32-CAM refers to the module manufacturer rather than a dedicated AI processor.

Should I use TensorFlow Lite, ESP-DL or Edge Impulse?

TensorFlow Lite for Microcontrollers is useful for understanding conventional embedded ML deployment. ESP-DL is attractive when targeting Espressif hardware and taking advantage of optimized implementations. Edge Impulse provides a convenient end-to-end platform for collecting data, training a model and deploying it to the ESP32.

Final Thoughts

The ESP32 is not going to replace a GPU, Raspberry Pi, or cloud AI server. That is also not what makes ESP32 AI interesting. Microcontrollers operate directly beside sensors and actuators. If a tiny model can recognize the pattern you need, an ESP32 can make a decision locally within a small, inexpensive, and low-power device.

For simple machine-learning experiments, the classic ESP32 is still usable. For new projects that require local audio, vision, or larger models, the ESP32-S3 is the much more interesting platform, particularly when paired with PSRAM. And if the AI task is simply too large for a microcontroller, Wi-Fi gives us another option: let the ESP32 handle the physical world while a cloud model handles the heavy computation.

If you want to build your first model rather than just explore the possibilities, continue with my TinyML with ESP32 Tutorial. For voice projects, see my ESP32 voice command recognition tutorial. And if your goal is to connect an ESP32 to a large language model, see my ESP32 LLM/OpenRouter project.

The post ESP32 AI Guide: What Can ESP32 and ESP32-S3 Actually Do? appeared first on Teach Me Microcontrollers!.

The ESP32-S31 moves to a dual-core RISC-V processor running at up to 320 MHz, adds Wi-Fi 6, brings back Bluetooth Classic, includes an IEEE 802.15.4 radio for Zigbee and Thread, and adds considerably more hardware for displays, cameras, audio and edge AI.

Espressif announced the ESP32-S31 in March 2026 and moved the device into mass production in July. So unlike some chips that remain development announcements for months, the S31 is already moving into development boards and production modules.

What is the ESP32-S31?

The ESP32-S31 is a high-performance wireless microcontroller from Espressif intended for connected devices that need more processing power and more interfaces than a typical ESP32 application. Its two main processor cores use the 32-bit RISC-V architecture and can operate at up to 320 MHz. One of those cores includes a 128-bit data path and SIMD instructions intended to accelerate operations commonly found in signal processing, image processing and machine-learning workloads.

That already makes the architecture quite different from the ESP32-S3. The S3 uses two Xtensa LX7 cores running at up to 240 MHz.

The ESP32-S31 also provides 512 KB of internal SRAM, while external or in-package high-speed PSRAM can provide much larger working memory for applications such as graphical interfaces, cameras and AI models. Espressif currently lists ESP32-S31 chip variants with 16 MB or 32 MB of in-package Octal SPI PSRAM.

The important specifications can be summarized as follows:

Those specifications put the ESP32-S31 somewhere between the traditional ESP32 microcontrollers and Espressif's more application-processor-like devices.

ESP32-S31 Uses RISC-V

One of the biggest changes is the processor architecture. ESP32-S3 uses Espressif's familiar Xtensa LX7 cores. ESP32-S31 instead uses RISC-V, continuing Espressif's shift toward the open instruction-set architecture already found in chips such as the ESP32-C3 and ESP32-C6.

The two high-performance cores run at up to 320 MHz. Espressif also includes a 40 MHz low-power coprocessor, which allows some monitoring and low-power tasks to continue while the main processors are inactive. The increased clock frequency alone does not explain all of the performance improvement. One CPU core provides a 128-bit data path with SIMD instructions. SIMD, or Single Instruction Multiple Data, allows one instruction to operate on several pieces of data at the same time.

Consider image processing. If an algorithm needs to perform the same mathematical operation on thousands of pixels, processing several pixel values simultaneously can be much faster than processing each one individually. This is also useful for DSP operations, audio processing and neural-network inference. The S31 therefore isn't simply a faster ESP32 for blinking LEDs or reading sensors. Much of its additional hardware makes more sense once the application starts handling large streams of data.

Wi-Fi 6, Bluetooth and 802.15.4

Connectivity is probably the area where the ESP32-S31 separates itself most clearly from the ESP32-S3. The S31 supports 2.4 GHz Wi-Fi 6, or IEEE 802.11ax. Note the 2.4 GHz specification here: Wi-Fi 6 support does not mean that the ESP32-S31 suddenly becomes a 5 GHz Wi-Fi device. Its integrated radio operates in the 2.4 GHz band.

Bluetooth support is also considerably broader. ESP32-S31 supports both Bluetooth 5.4 Low Energy and Bluetooth Classic BR/EDR. This is interesting because Bluetooth Classic disappeared from several newer ESP32 variants, including the ESP32-S3. Bringing it back makes the S31 more useful for applications such as Bluetooth speakers and other devices that still need compatibility with traditional Bluetooth audio. Bluetooth LE support also extends to LE Audio, including the LC3 codec and multi-stream audio capabilities. Espressif specifically highlights audio as one of the intended application areas for the chip.

There is also an IEEE 802.15.4 radio, which provides the hardware foundation for protocols such as Zigbee and Thread. That means one ESP32-S31 can potentially act as a much more capable smart-home controller than an S3. For example, a gateway could communicate with Wi-Fi devices, Bluetooth devices and Thread or Zigbee sensors without requiring separate wireless microcontrollers for every protocol. This also makes the chip particularly interesting for Matter gateways and border-router-style devices.

Gigabit Ethernet

Another surprising addition is a 1000 Mbps Ethernet MAC. The important word here is MAC. The ESP32-S31 does not magically provide an RJ45 Ethernet connection directly from the chip. A design still needs the appropriate external Ethernet PHY and magnetics. Espressif's own ESP32-S31-Function-CoreBoard-1 demonstrates this approach. The board connects the S31's RGMII interface to an external Ethernet PHY and provides an RJ45 connector capable of 10/100/1000 Mbps auto-negotiation. Still, having a Gigabit-capable Ethernet MAC inside an ESP32-class SoC is significant. It makes applications such as network gateways, industrial controllers and high-bandwidth edge devices much more practical.

ESP32-S31 for Displays and Cameras

The S31 is clearly designed for products with more sophisticated user interfaces. It includes a DVP camera interface supporting 8- to 16-bit data, along with several LCD interfaces. These include parallel RGB displays up to 24 bits as well as I8080 and MOTO6800-style interfaces. Hardware can convert between formats including RGB565 and several YUV formats. Espressif also provides dedicated image-processing hardware such as a JPEG codec, Pixel Processing Accelerator (PPA) and 2D-DMA.

Why does that matter? Without dedicated hardware, operations such as moving a framebuffer, resizing an image or handling camera data can consume a large percentage of CPU time. The ESP32-S31 can offload some of those jobs. That gives the main processors more time for application logic, networking or AI inference. Up to 14 capacitive-touch channels are also available, making the chip suitable for touch panels and appliances where physical buttons are being replaced by interactive displays. I can see this being particularly useful for smart control panels, video doorbells, small instrument displays and voice-enabled appliances.

Edge AI on the ESP32-S31

Espressif has been promoting AI capabilities since the ESP32-S3, so we should be careful about what "AI" means here. The ESP32-S31 is not intended to compete with a desktop GPU running a large language model. Instead, its hardware acceleration makes it suitable for smaller edge AI inference tasks where data must be processed directly on the device. Examples include keyword recognition, wake-word detection, image classification, object detection, anomaly detection and signal classification.

The combination of SIMD instructions, a 128-bit data path, hardware image processing, fast PSRAM and dedicated mathematical acceleration makes these workloads considerably more practical than they were on earlier ESP32 devices. Espressif also lists CORDIC acceleration among the S31's dedicated hardware. This also explains the amount of PSRAM available. A simple sensor-reading program doesn't need 16 MB or 32 MB of RAM. Camera frame buffers, graphical interfaces, neural-network tensors and audio buffers certainly can.

Peripheral Interfaces

Despite its emphasis on multimedia, the ESP32-S31 is still a microcontroller. The chip provides traditional interfaces such as SPI, I2C, UART, I2S, PWM and GPIO alongside newer or higher-performance peripherals. It includes four main-system UART controllers plus a low-power UART. SPI interfaces support normal SPI as well as Dual, Quad and, on some controllers, Octal operation. There are also two high-performance I2C controllers plus a low-power I2C interface.

USB receives a major upgrade to USB 2.0 High-Speed OTG. High-Speed USB is a substantial improvement over the USB Full-Speed interface found on the ESP32-S3. The S31 also includes interfaces for CAN FD, SD/MMC, motor-control PWM, LED PWM, RMT, pulse counting and parallel I/O. On the analog side, the documentation lists ADC, DAC, a temperature sensor, touch sensing and an analog voltage comparator. With up to 60 programmable GPIOs, larger designs are less likely to run into the pin limitations that sometimes appear when an ESP32 project starts combining a display, camera, external memory and several peripherals.

ESP32-S31 vs ESP32-S3

The S31 may look like the natural replacement for the ESP32-S3, but that doesn't mean every S3 project needs one.

Espressif itself recommends the S31 for gateways, bridges and AI multimedia devices where multi-protocol connectivity or higher processing performance is important. The company still recommends the S3 for more cost-sensitive applications that don't need these capabilities. That seems like the sensible way to look at the two chips.

If your project is reading an I2C sensor and uploading a value to an MQTT server, an ESP32-S31 would probably be excessive. If your project combines a camera, display, voice interface, Wi-Fi, Bluetooth and Thread, then the advantages start to become obvious.

ESP32-S31 Modules and Development Boards

Espressif is already offering modules around the new chip. The ESP32-S31-WROOM-1 family is listed with different flash and PSRAM capacities, while the ESP32-S31-WROOM-3 is being used on Espressif's multimedia and function development boards.

One interesting example is the ESP32-S31-Korvo-1. This development board is clearly aimed at showing what the chip can do beyond ordinary IoT sensing. It includes audio hardware, dual microphones, speaker outputs, microSD support, USB High-Speed connectivity and connectors for an LCD and camera. A current WROOM-3 configuration used by the board includes 16 MB flash and 16 MB PSRAM. Espressif also provides the ESP32-S31-Function-CoreBoard-1, which adds Gigabit Ethernet and audio hardware while breaking out the important GPIO connections.

Programming the ESP32-S31

For now, ESP-IDF is the safest development environment for the ESP32-S31. Espressif says S31 support is available in the ESP-IDF master and v6.1 branches, with official tagged support planned from ESP-IDF 6.1.1 onward. Arduino support is a different story.

As of September 2026, the stable Arduino-ESP32 documentation still does not list the S31 among officially supported SoCs. Espressif developers have been working on S31 support for Arduino 4.x, which is based on ESP-IDF 6.1, but the Arduino team's current roadmap places the 4.0 release in November 2026. So if you purchase an ESP32-S31 board today expecting exactly the same Arduino IDE experience as an ESP32-S3 DevKit, expect some rough edges.

For developers already comfortable with ESP-IDF, however, the S31 can already be explored properly. This situation should improve as the software ecosystem catches up with the hardware.

Security Features

The ESP32-S31 also includes considerably more security hardware than is necessary for the average hobby project, but that becomes important in commercial products. The chip supports secure boot, flash and PSRAM encryption, hardware cryptographic acceleration and protected key handling. Hardware support includes AES-128/256, RSA, ECDSA and ECC operations. Espressif also includes TRNG and a RAM-based physical unclonable function, or PUF, as part of its security architecture.

Flash encryption uses XTS-AES-256, while secure boot can verify signed firmware before it executes. Together, these mechanisms make it more difficult to extract proprietary firmware or replace legitimate software with unauthorized code. These features may not matter while experimenting with a development board, but they become very important once an ESP32-based product leaves the lab.

Who is the ESP32-S31 For?

The ESP32-S31 makes the most sense when several previously separate requirements start appearing in the same project. A smart-home gateway is one example. It may need Wi-Fi for the local network, Thread or Zigbee for sensors, Bluetooth for commissioning, Ethernet for reliable wired connectivity and enough processing power to run local automation logic.

A smart display is another. Now the device may need LCD graphics, touch input, audio, Wi-Fi, Bluetooth and perhaps a camera.  The same applies to voice assistants, industrial gateways, security panels and camera-based edge devices. For those applications, the ESP32-S31 can potentially replace several chips with one highly integrated SoC.

For basic sensor nodes and conventional ESP32 projects, however, the S31 is unlikely to make the ESP32-S3, C3 or C6 obsolete. Those devices are cheaper, mature and already have a large software ecosystem.

Final Thoughts

The ESP32-S31 feels less like another variation of the ESP32 and more like Espressif stretching the definition of what an ESP32-class microcontroller can handle. You still get familiar microcontroller peripherals such as GPIO, SPI, I2C, UART and PWM. But those now sit beside a 320 MHz dual-core RISC-V processor, high-speed PSRAM, Wi-Fi 6, Bluetooth Classic and LE, Zigbee/Thread connectivity, High-Speed USB, Gigabit Ethernet, camera and display interfaces, and dedicated multimedia accelerators.

The hardware is impressive. The main limitation right now is software maturity. ESP-IDF is already the primary path for development, while Arduino support is still catching up. For developers who depend heavily on mature Arduino libraries, the ESP32-S3 remains easier to use today. But once the ecosystem matures, the ESP32-S31 could become one of Espressif's most interesting devices for smart displays, gateways, audio products and edge-AI projects. And considering how many interfaces Espressif has managed to put into a single microcontroller, there should be plenty of projects worth testing on it.

The post ESP32-S31 Explained: Specs, RISC-V, Wi-Fi 6 and ESP32-S3 Comparison appeared first on Teach Me Microcontrollers!.

I ran into this while testing an ESP32-S3 Mini. I knew the chip on my board was supposed to have 2 MB of PSRAM. One of my first tests successfully allocated a 1 MB buffer; however, it was surprisingly easy to read that result as if the board only had 1 MB available. Another memory test showed the actual 2 MB.

The important part was figuring out what each PSRAM value actually represented.

There is the total PSRAM physically available to the chip. Then there is the amount currently free. There is also the largest continuous block that your program can allocate. Those numbers are related, but they are not necessarily equal. In this tutorial, I'll show you how to enable PSRAM in the Arduino IDE, confirm that the ESP32-S3 actually detects it, allocate buffers inside it and check how much usable memory remains.

What is PSRAM on the ESP32-S3?

The ESP32-S3 already contains internal SRAM. This is where your program keeps variables, task stacks, temporary buffers, and other runtime data. Internal RAM becomes limited once the project starts using large buffers. A small sensor program will probably never care about PSRAM. This becomes noticeable in projects that:

• Store camera frame buffers
• Run TinyML models
• Build large JSON documents
• Process audio samples
• Buffer data before writing to an SD card
• Store images for a display
• Receive large network packets or files

These applications can quickly consume the available internal SRAM. PSRAM, or pseudo-static RAM, gives the ESP32-S3 an additional external memory space. Depending on the hardware configuration, the PSRAM can be connected through Quad SPI or Octal SPI.

Once initialized, PSRAM can be allocated much like normal RAM. However, it is still external memory and not simply another block of internal SRAM. Because it is external memory, it is slower and has some restrictions that internal SRAM does not.

If you are also deciding which ESP32-S3 pins are available for a project, see my ESP32-S3 pinout guide. Some GPIO pins are used internally by flash and PSRAM on certain modules.

Does Your ESP32-S3 Actually Have PSRAM?

Not every ESP32-S3 board has PSRAM. Two boards sold as "ESP32-S3" can have different flash and PSRAM configurations. For Espressif modules, the suffix printed on the chip or module often gives us a clue.

For PSRAM, look at the R suffix. R2 indicates 2 MB PSRAM, while R8 indicates 8 MB PSRAM. There are also ESP32-S3 variants without PSRAM, so don't assume every board includes it. On generic boards such as the ESP32-S3 Super Mini, I would not trust the product listing alone. Check the actual marking on the chip or module if possible. This is what I did with my own board. On the image below, you can see "FN4R2P415070," which means this board has 2MB of PSRAM. I trust the device marking more than the seller's listing.

Enabling ESP32-S3 PSRAM in Arduino IDE

The Arduino configuration also has to match the installed PSRAM. If you are using the generic ESP32-S3 board definition, select:

Tools > Board > ESP32 Arduino > ESP32S3 Dev Module

Then look for:

Tools > PSRAM

Depending on the Arduino-ESP32 version and selected board, you may see options such as:

• Disabled
• QSPI PSRAM
• OPI PSRAM

For a board with R2 PSRAM, select:

QSPI PSRAM

Then, for a board with R8 PSRAM, select:

OPI PSRAM

For example, if the device marking indicates an R2 configuration, I would select:

Tools > PSRAM > QSPI PSRAM

A wrong PSRAM or flash setting can also prevent the board from booting correctly. So if an ESP32-S3 starts rebooting after uploading even a simple sketch, the PSRAM setting is one of the first things I would check.

Detecting PSRAM from an Arduino Sketch

These are my Arduino settings for this article, so make sure you have the same before uploading and running the sketches here:

• Board: ESP32S3 Dev Module if your specific Mini board isn't listed
• USB CDC On Boot: Enabled
• Upload Mode: UART0 / Hardware CDC
• USB Mode: Hardware CDC and JTAG if that option is available
• Port: <your ESP32-S3's COM Port>
• Serial Monitor: 115200

Before allocating PSRAM, first check whether the Arduino core detects it. The simplest test is psramFound():

void setup() {
  Serial.begin(115200);
  delay(2000);

  if (psramFound()) {
    Serial.println("PSRAM detected!");
  } else {
    Serial.println("PSRAM not found.");
  }
}

void loop() {
}

If everything is configured correctly, you should see:

PSRAM detected!

If you get:

PSRAM not found.

A failed detection test can also be caused by the board or PSRAM configuration.

Check these first:

• The exact ESP32-S3 chip or module variant
• The board selected in Arduino IDE
• The QSPI or OPI PSRAM setting
• The memory specification supplied by the board manufacturer

Only after those checks would I start suspecting a hardware problem.

Checking ESP32-S3 PSRAM Size

The ESP object reports the total, free, minimum-free, and maximum allocatable PSRAM.

Try this sketch:

void setup() {
  Serial.begin(115200);
  delay(2000);

  Serial.println("ESP32-S3 PSRAM Test");
  Serial.println("-------------------");

  if (!psramFound()) {
    Serial.println("PSRAM not detected.");
    return;
  }

  Serial.println("PSRAM detected: YES");

  Serial.print("Total PSRAM: ");
  Serial.print(ESP.getPsramSize() / 1024.0 / 1024.0, 2);
  Serial.println(" MB");

  Serial.print("Free PSRAM: ");
  Serial.print(ESP.getFreePsram() / 1024.0);
  Serial.println(" KB");

  Serial.print("Minimum free PSRAM: ");
  Serial.print(ESP.getMinFreePsram() / 1024.0);
  Serial.println(" KB");

  Serial.print("Largest free block: ");
  Serial.print(ESP.getMaxAllocPsram() / 1024.0);
  Serial.println(" KB");
}

void loop() {
}

On a 2 MB ESP32-S3, the important result should be close to:

PSRAM detected: YES
Total PSRAM: 2.00 MB

The other numbers will vary depending on the Arduino core, libraries and anything your program has already allocated. The total PSRAM value alone is not enough when debugging memory use.

Total PSRAM Is Not the Same as Free PSRAM

There are four useful numbers in the previous program:

ESP.getMaxAllocPsram() is especially important when allocating large buffers.

For example, suppose the ESP32 reports:

Free PSRAM:          1200 KB
Largest free block:   700 KB

You have 1.2 MB free in total, but that does not mean you can allocate a single 1 MB buffer. The free memory may be split into several smaller regions. The heap is fragmented: the free memory exists, but it is split into smaller blocks. Free PSRAM and maximum allocatable PSRAM therefore need to be checked separately. This is what confused my earlier 1 MB allocation test. A successful 1 MB allocation tells me that a 1 MB block was available. It does not tell me that the board physically contains only 1 MB of PSRAM.

Allocating Memory with ps_malloc()

Next, we can allocate a buffer directly in PSRAM. Arduino-ESP32 provides ps_malloc(), which works much like the normal C malloc() function except that the allocation is specifically requested from PSRAM.

Here's a simple example that tries to allocate 1 MB:

void setup() {
  Serial.begin(115200);
  delay(2000);

  if (!psramFound()) {
    Serial.println("PSRAM not available.");
    return;
  }

  const size_t bufferSize = 1024 * 1024;

  uint8_t *buffer = (uint8_t *)ps_malloc(bufferSize);

  if (buffer == NULL) {
    Serial.println("PSRAM allocation failed!");
    return;
  }

  Serial.println("1 MB PSRAM allocation successful.");

  free(buffer);
  Serial.println("Buffer released.");
}

void loop() {
}

Always check whether the returned pointer is NULL. Large allocations can fail even when PSRAM is enabled. Also notice that we release the PSRAM buffer using:

free(buffer);

You don't need a special ps_free() function.

Actually Writing Data to PSRAM

I also wanted to verify that the allocated memory could be written and read back correctly. Let's allocate 1 MB, fill it with data and then verify the values.

void setup() {
  Serial.begin(115200);
  delay(2000);

  if (!psramFound()) {
    Serial.println("PSRAM not detected.");
    return;
  }

  const size_t bufferSize = 1024 * 1024;

  uint8_t *buffer = (uint8_t *)ps_malloc(bufferSize);

  if (buffer == NULL) {
    Serial.println("Could not allocate 1 MB in PSRAM.");
    return;
  }

  Serial.println("1 MB allocated successfully.");

  // Fill the buffer with a repeating pattern
  for (size_t i = 0; i < bufferSize; i++) {
    buffer[i] = i & 0xFF;
  }

  // Verify the contents
  bool passed = true;

  for (size_t i = 0; i < bufferSize; i++) {
    if (buffer[i] != (i & 0xFF)) {
      passed = false;
      break;
    }
  }

  if (passed) {
    Serial.println("PSRAM read/write test PASSED.");
  } else {
    Serial.println("PSRAM read/write test FAILED.");
  }

  free(buffer);
}

void loop() {
}

This verifies more than allocation alone:

• Confirms PSRAM initialization
• Confirms that a large contiguous block is available
• Writes across the allocated region
• Reads the data back
• Checks that the contents were preserved

A successful result should look like:

1 MB allocated successfully.
PSRAM read/write test PASSED.

ps_malloc() vs malloc() vs heap_caps_malloc()

ps_malloc() is not the only allocator that can use PSRAM. ESP32 applications also use malloc(). With PSRAM enabled, the ESP32 heap allocator can also place some ordinary allocations in external RAM. That means ordinary calls to malloc() may also use PSRAM depending on the allocation size, available memory, and configuration.

This lets existing libraries use the larger heap without calling ps_malloc() directly. For memory tests, I use ps_malloc() so I know the buffer is coming from PSRAM:

uint8_t *buffer = (uint8_t *)ps_malloc(bufferSize);

For even more control, we can use the ESP32 capability-based allocator:

#include "esp_heap_caps.h"

uint8_t *buffer = (uint8_t *)heap_caps_malloc(
    bufferSize,
    MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT
);

The MALLOC_CAP_SPIRAM flag specifically requests external PSRAM. For most Arduino projects, ps_malloc() is easier to read. I would reach for heap_caps_malloc() when I need more specific control over the type of memory being requested.

When Should You Use PSRAM?

PSRAM is best suited to large data where the lowest possible access latency is not required.

Good candidates include:

• Camera frames
• Image buffers
• Audio sample buffers
• Large arrays
• Machine-learning tensor arenas
• Large strings
• JSON documents
• Network receive buffers
• Temporary file buffers

For example, an ESP32-S3 used for TinyML may need hundreds of kilobytes just for model tensors and intermediate data. Moving this kind of bulk data to PSRAM leaves more internal SRAM available for the rest of the application. A 300 KB buffer might consume an uncomfortable amount of internal RAM. Put the same bulk data in PSRAM and you preserve internal memory for the operating system, Wi-Fi, task stacks, and peripherals.

PSRAM Is Not Just More Internal SRAM

An ESP32-S3 with 8 MB of PSRAM does not behave like a microcontroller with 8 MB of internal SRAM. External PSRAM sits behind the ESP32-S3's memory interface and cache. Frequently accessed data can perform reasonably well, but large accesses eventually exceed what the cache can hide. Use PSRAM when capacity matters. Keep frequently accessed or timing-sensitive data in internal SRAM. There is little benefit in moving small variables to PSRAM just because it is available. Use PSRAM for the large objects that actually justify it.

Some Data Still Needs Internal RAM

Some data cannot or should not be placed in PSRAM. Peripheral and DMA operations can have additional memory requirements. Some hardware structures must remain in internal memory even if the main data buffer lives in PSRAM. FreeRTOS task stacks are also normally kept in internal RAM.

PSRAM and external flash also share parts of the ESP32-S3 external-memory and cache system. This becomes relevant if you are writing lower-level code, performing flash operations, or debugging difficult timing-related crashes. This usually does not matter for a simple image or data buffer, but it matters more in drivers, networking, DMA, flash operations, and real-time applications.

A practical rule is:

Monitoring PSRAM While Your Program Runs

A memory leak or fragmentation problem may not become visible until the program has been running for a while. For debugging, I find it useful to periodically print both free PSRAM and the largest allocatable block.

void printPsramStatus() {
  Serial.print("Free PSRAM: ");
  Serial.print(ESP.getFreePsram() / 1024);
  Serial.println(" KB");

  Serial.print("Largest block: ");
  Serial.print(ESP.getMaxAllocPsram() / 1024);
  Serial.println(" KB");

  Serial.print("Minimum free PSRAM: ");
  Serial.print(ESP.getMinFreePsram() / 1024);
  Serial.println(" KB");
}

Call this at different stages of your program.

For example:

printPsramStatus();

camera.begin();

printPsramStatus();

loadModel();

printPsramStatus();

Comparing these readings shows which initialization step consumed the PSRAM. getMinFreePsram() records the lowest free-PSRAM level reached since boot. A temporary allocation might have already been released by the time you check the Serial Monitor, but the minimum value can reveal that memory usage briefly spiked.

Why Can an Allocation Fail When PSRAM Is Still Free?

Suppose your Serial Monitor says:

Free PSRAM: 1300 KB

Then this fails:

ps_malloc(1024 * 1024);

The reason becomes clear when you check the largest allocatable block.

Check:

ESP.getMaxAllocPsram()

You may discover something like:

Free PSRAM:       1300 KB
Largest block:     800 KB

The allocator has 1.3 MB available overall, but there is no single 1 MB continuous region. This can happen after many differently sized allocations and frees. If your application depends on a very large buffer, allocate it early during startup rather than waiting until the heap has been used heavily. If your application needs one large buffer, allocate it early before repeated allocations fragment the heap.

ESP32-S3 PSRAM Troubleshooting

PSRAM Size Shows 0 Bytes

First check:

psramFound()

If that also returns false, verify the Arduino IDE PSRAM configuration.

For R2 devices:

Tools > PSRAM > QSPI PSRAM

For R8 devices:

Tools > PSRAM > OPI PSRAM

Also confirm that your ESP32-S3 variant actually contains PSRAM.

The Board Keeps Rebooting

An incorrect flash or PSRAM mode can prevent some ESP32-S3 boards from starting correctly. Check the exact chip or module marking rather than guessing based on the development-board name.

ps_malloc() Returns NULL

Print:

ESP.getFreePsram()
ESP.getMaxAllocPsram()

The largest available block may be smaller than the buffer you are requesting. Also make sure the result of every allocation is checked before using the pointer.

My 2 MB Board Shows Slightly Less Than 2 MB Free

That is normal. ESP.getPsramSize() reports the total detected PSRAM, while ESP.getFreePsram() tells you how much remains available after system initialization and allocations. Don't use the free-memory value to identify how much memory is physically there.

I Allocated 1 MB. Does That Mean My Board Has 1 MB PSRAM?

No.

It only proves that the allocator successfully found a 1 MB continuous block.

Use:

ESP.getPsramSize()

to determine the total detected PSRAM.

Putting It All Together

I use the following sketch as a quick PSRAM check on a new ESP32-S3 board:

void setup() {
  Serial.begin(115200);
  delay(2000);

  Serial.println();
  Serial.println("ESP32-S3 PSRAM Check");
  Serial.println("====================");

  if (!psramFound()) {
    Serial.println("PSRAM: NOT DETECTED");
    return;
  }

  Serial.println("PSRAM: DETECTED");

  Serial.printf(
    "Total PSRAM: %.2f MB\n",
    ESP.getPsramSize() / 1024.0 / 1024.0
  );

  Serial.printf(
    "Free PSRAM: %.2f MB\n",
    ESP.getFreePsram() / 1024.0 / 1024.0
  );

  Serial.printf(
    "Largest block: %.2f MB\n",
    ESP.getMaxAllocPsram() / 1024.0 / 1024.0
  );

  const size_t testSize = 1024 * 1024;

  uint8_t *testBuffer = (uint8_t *)ps_malloc(testSize);

  if (testBuffer != NULL) {
    Serial.println("1 MB allocation: PASS");
    memset(testBuffer, 0x55, testSize);
    Serial.println("1 MB write: PASS");
   free(testBuffer);
  } else {
    Serial.println("1 MB allocation: FAIL");
  }
}

void loop() {
}

From this output I can verify that PSRAM is detected, see the total and available memory, check the largest block, and confirm that a reasonably large buffer can actually be allocated.

Conclusion

PSRAM is useful when an ESP32-S3 project needs large image, audio, machine-learning, or network buffers. It should not be treated the same as internal SRAM. First, make sure your particular ESP32-S3 actually contains PSRAM. Then configure the correct QSPI or OPI mode in Arduino IDE and verify it using psramFound() and ESP.getPsramSize(). After that, functions such as ps_malloc() make it straightforward to place large buffers in external memory.

My testing showed why total memory, free memory, and largest allocatable memory are three different things. Checking all three usually makes allocation problems much easier to trace.

In the next experiment, I will take this a step further and compare ESP32-S3 internal SRAM against PSRAM, including allocation size, read/write speed and what happens as the working buffer becomes larger.

The post ESP32-S3 PSRAM: How to Enable, Detect and Use It in Arduino appeared first on Teach Me Microcontrollers!.

There is one problem: documentation for these generic Super Mini boards is often incomplete. Different online sellers sometimes show different pin diagrams, memory specifications, and even different onboard LED connections.

In this guide, I will show you how to set up the ESP32-S3 Super Mini in the Arduino IDE, identify the hardware you actually received, test its flash and PSRAM, and control the onboard RGB LED. We will also look at the pinout and some common upload problems.

What is the ESP32-S3 Mini?

The ESP32-S3 Super Mini is a small third-party development board built around the ESP32-S3 microcontroller. The ESP32-S3 itself uses two Xtensa LX7 CPU cores running at up to 240 MHz and includes 2.4 GHz Wi-Fi and Bluetooth Low Energy.

The particular Super Mini version commonly sold online uses an ESP32-S3FH4R2. The letters at the end are important:

• F - the chip contains flash memory.
• H4 - 4 MB of flash is integrated into the package.
• R2 - 2 MB of PSRAM is integrated into the package.

This makes the small board considerably more capable than its physical size suggests. In particular, the PSRAM can be useful for frame buffers, image processing, web applications, and other programs that need more working memory than the ESP32-S3's internal RAM can comfortably provide.

However, not every board advertised as an "ESP32-S3 Mini" necessarily contains the same chip. Before relying on the memory specifications printed by a seller, I recommend checking the marking on the ESP32-S3 itself and then verifying the memory through software.

ESP32-S3 Mini vs ESP32-S3-MINI-1

There is also an official Espressif product named the ESP32-S3-MINI-1. Do not confuse this with the ESP32-S3 Super Mini development board shown in this tutorial.

The ESP32-S3-MINI-1 is an Espressif module intended to be soldered into another PCB. The ESP32-S3 Super Mini, meanwhile, is a complete development board with a USB-C connector, voltage regulator, buttons, and exposed pins.

Online stores sometimes shorten both names to "ESP32-S3 Mini", which is why the terminology can be confusing.

ESP32-S3 Super Mini Specifications

For the common ESP32-S3FH4R2-based version, the important specifications are:

The 3.3 V logic level is worth remembering. Do not apply 5 V directly to an ESP32-S3 GPIO pin.

ESP32-S3 Super Mini Pinout

The compact Super Mini board exposes fewer pins than a full-size ESP32-S3 development board. This is one of the compromises required to make the board so small.

The version used for this guide has GPIO1 through GPIO13 together with the default UART TX and RX pins.

*GPIO48 is commonly used for the RGB LED on this Super Mini layout. Generic boards can vary, so check your board if the RGB example later in this guide does not work.

Where are GPIO19 and GPIO20?

The ESP32-S3 has native USB support. GPIO19 and GPIO20 can serve as the USB D- and D+ signals, respectively. On this board, the USB-C connector already uses the ESP32-S3's USB interface, so these pins are not presented like ordinary header pins.

This native USB connection is one of the reasons the Super Mini can be made so small: it does not necessarily need a separate CH340, CP2102, or other USB-to-UART converter.

Which Pins Should Beginners Use?

For initial projects, I would start with GPIO1, GPIO2, GPIO4, GPIO5, GPIO6, GPIO7, GPIO8, GPIO9, GPIO10, GPIO11, GPIO12 or GPIO13.

GPIO3 is usable, but it is also one of the ESP32-S3's strapping pins. A circuit that forces an inappropriate logic level on a strapping pin during reset can change the way the microcontroller boots.

Installing ESP32-S3 Support in Arduino IDE

If you have already programmed another ESP32 board using the Arduino IDE, you may already have Espressif's Arduino core installed. Otherwise, install the ESP32 package using the Arduino IDE's Boards Manager.

1. Open the Arduino IDE.
2. Open Boards Manager.
3. Search for esp32.
4. Install the package published by Espressif Systems.
5. Restart the Arduino IDE if necessary.

The generic Super Mini normally does not have its own entry in the Arduino board list. Instead, select:

Tools > Board > ESP32 Arduino > ESP32S3 Dev Module

This gives us access to the configuration options needed for the S3.

Recommended Arduino IDE Settings

For a common ESP32-S3FH4R2 Super Mini, I recommend starting with these settings:

QSPI PSRAM is especially important. The ESP32-S3FH4R2 contains 2 MB of Quad SPI PSRAM. Selecting the wrong PSRAM type can prevent the board from booting correctly or cause the PSRAM test to fail.

Why Enable USB CDC On Boot?

On many older ESP32 boards, a separate USB-to-serial IC creates the COM port. The ESP32-S3 can instead expose a serial interface directly through its internal USB hardware.

With USB CDC On Boot = Enabled, calls such as:

Serial.println("Hello");

can appear directly in the Arduino Serial Monitor through the USB-C connection.

If your sketch uploads correctly but the Serial Monitor remains completely blank, this setting is one of the first things I would check.

First Test: Serial Output

Before testing anything more complicated, let's confirm that the microcontroller can run a sketch and communicate with the computer.

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

  delay(2000);

  Serial.println();
  Serial.println("ESP32-S3 Super Mini is running!");
}

void loop() {
  Serial.println("Hello from ESP32-S3");
  delay(1000);
}

Upload the program and open the Serial Monitor at 115200 baud.

You should see something similar to:

ESP32-S3 Super Mini is running!
Hello from ESP32-S3
Hello from ESP32-S3
Hello from ESP32-S3

If this works, we have already confirmed three things: the ESP32-S3 is running, USB programming works and USB serial output works.

Testing the ESP32-S3 Mini Flash and PSRAM

One specification I would definitely verify on a generic ESP32-S3 Super Mini is its memory. Fortunately, Arduino gives us functions that can report the flash and PSRAM sizes directly.

Upload the following program:

#include <Arduino.h>

void setup() {
  Serial.begin(115200);
  delay(2000);

  Serial.println("ESP32-S3 Hardware Test");
  Serial.println("----------------------");

  Serial.print("Chip model: ");
  Serial.println(ESP.getChipModel());

  Serial.print("CPU cores: ");
  Serial.println(ESP.getChipCores());

  Serial.print("CPU frequency: ");
  Serial.print(ESP.getCpuFreqMHz());
  Serial.println(" MHz");

  Serial.print("Flash size: ");
  Serial.print(ESP.getFlashChipSize() / 1024.0 / 1024.0, 2);
  Serial.println(" MB");

  Serial.print("PSRAM detected: ");
  Serial.println(psramFound() ? "YES" : "NO");

  Serial.print("PSRAM size: ");
  Serial.print(ESP.getPsramSize() / 1024.0 / 1024.0, 2);
  Serial.println(" MB");

  Serial.print("Free PSRAM: ");
  Serial.print(ESP.getFreePsram() / 1024);
  Serial.println(" KB");
}

void loop() {
}

Expected Result for the ESP32-S3FH4R2 Version

On a Super Mini that really contains an ESP32-S3FH4R2, the important parts of the result should look approximately like this:

ESP32-S3 Hardware Test
----------------------
Chip model: ESP32-S3
CPU cores: 2
CPU frequency: 240 MHz
Flash size: 4.00 MB
PSRAM detected: YES
PSRAM size: 2.00 MB
Free PSRAM: 2045 KB

If the program reports PSRAM size: 0 MB, this does not immediately mean your board lacks PSRAM. First verify that:

Tools > PSRAM > QSPI PSRAM

is selected.

If PSRAM still does not appear, inspect the marking on the chip. A different ESP32-S3 variant may have been fitted to your board.

Experiment: Actually Allocating Data in PSRAM

Detecting PSRAM is useful, but I also wanted a test that actually writes data to it. The following experiment allocates a 1 MB buffer using PSRAM, fills it with data, and then checks whether the allocation succeeded.

#include <Arduino.h>

const size_t BUFFER_SIZE = 1024 * 1024;

void setup() {
  Serial.begin(115200);
  delay(2000);

  if (!psramFound()) {
    Serial.println("PSRAM not found.");
    return;
  }

  Serial.print("Free PSRAM before allocation: ");
  Serial.print(ESP.getFreePsram());
  Serial.println(" bytes");

  uint8_t *buffer = (uint8_t *)ps_malloc(BUFFER_SIZE);

  if (buffer == NULL) {
    Serial.println("1 MB PSRAM allocation FAILED.");
    return;
  }

  Serial.println("1 MB PSRAM allocation successful.");

  for (size_t i = 0; i < BUFFER_SIZE; i++) {
    buffer[i] = i & 0xFF;
  }

  bool passed = true;

  for (size_t i = 0; i < BUFFER_SIZE; i++) {
    if (buffer[i] != (i & 0xFF)) {
      passed = false;
      break;
    }
  }

  Serial.println(passed ?
                 "PSRAM read/write test PASSED." :
                 "PSRAM read/write test FAILED.");

  Serial.print("Free PSRAM after allocation: ");
  Serial.print(ESP.getFreePsram());
  Serial.println(" bytes");

  free(buffer);
}

void loop() {
}

For a working 2 MB PSRAM device, the 1 MB allocation should succeed. More importantly, the final verification confirms that the data written to the buffer can also be read back correctly.

A successful test should produce something similar to:

Free PSRAM before allocation: 2095103 bytes
1 MB PSRAM allocation successful.
PSRAM read/write test PASSED.
Free PSRAM after allocation: 1046511 bytes

This experiment also demonstrates why PSRAM is useful. A one-megabyte buffer would consume far too much of the ESP32-S3's normal internal RAM, while the external/in-package PSRAM gives memory-hungry applications much more room.

Using the ESP32-S3 Super Mini RGB LED

Another nice feature of many ESP32-S3 Super Mini boards is the onboard addressable RGB LED. On the version covered by this guide, the LED is a WS2812-compatible device connected to GPIO48.

An addressable RGB LED is different from three ordinary LEDs. Instead of supplying separate red, green, and blue signals, we send a digital data stream containing the required color.

Installing the NeoPixel Library

Open the Arduino Library Manager and install the Adafruit NeoPixel library.

Then upload this example:

#include <Adafruit_NeoPixel.h>

#define RGB_PIN 48
#define NUM_PIXELS 1

Adafruit_NeoPixel pixel(
  NUM_PIXELS,
  RGB_PIN,
  NEO_GRB + NEO_KHZ800
);

void setup() {
  pixel.begin();
  pixel.clear();
  pixel.show();
}

void loop() {
  // Red
  pixel.setPixelColor(0, pixel.Color(50, 0, 0));
  pixel.show();
  delay(1000);

  // Green
  pixel.setPixelColor(0, pixel.Color(0, 50, 0));
  pixel.show();
  delay(1000);

  // Blue
  pixel.setPixelColor(0, pixel.Color(0, 0, 50));
  pixel.show();
  delay(1000);

  // Off
  pixel.clear();
  pixel.show();
  delay(1000);
}

I deliberately limited the color values to 50 instead of the maximum 255. Full-brightness WS2812 LEDs can be surprisingly bright, and there is no reason to run the LED at maximum power for a simple test.

Expected RGB Test Result

The onboard LED should cycle through:

1. Red for one second
2. Green for one second
3. Blue for one second
4. Off for one second

What if GPIO48 Does Not Work?

The "Super Mini" name is used by multiple manufacturers, and not all board revisions are identical. Some ESP32-S3 boards use another GPIO for the addressable LED.

If the code runs but the LED remains dark:

• Check the seller's pinout for your exact board.
• Inspect the board for a WS2812-style LED.
• Try the GPIO number specified by the board manufacturer.
• Do not assume that every ESP32-S3 board uses GPIO48.

Testing Wi-Fi

Since the ESP32-S3 includes Wi-Fi, a quick network scan is another useful hardware test. It verifies that the radio and antenna are operating without requiring your Wi-Fi password.

#include <WiFi.h>

void setup() {
  Serial.begin(115200);
  delay(2000);

  WiFi.mode(WIFI_STA);
  WiFi.disconnect();
  delay(100);

  Serial.println("Scanning Wi-Fi networks...");

  int networks = WiFi.scanNetworks();

  if (networks == 0) {
    Serial.println("No Wi-Fi networks found.");
  } else {
    Serial.print(networks);
    Serial.println(" networks found:");

    for (int i = 0; i < networks; i++) {
      Serial.print(i + 1);
      Serial.print(": ");
      Serial.print(WiFi.SSID(i));
      Serial.print(" (");
      Serial.print(WiFi.RSSI(i));
      Serial.println(" dBm)");
    }
  }
}

void loop() {
}

The output will depend entirely on your location. A typical result might look like:

Scanning Wi-Fi networks...
13 networks found:
1: Stacey's_Wifi_2.4 (-65 dBm)
2: Stacey's_Wifi_2.4_EXT (-71 dBm)
3: innengarten_Guest (-82 dBm)
...

If the board can reliably find nearby 2.4 GHz networks, we now know that the basic radio system and onboard antenna are working.

ESP32-S3 Super Mini BOOT and RESET Buttons

The board normally provides two small buttons: BOOT and RESET.

The RESET button resets the ESP32-S3. The BOOT button is associated with the bootstrapping circuitry and is useful when manually forcing the chip into its firmware download mode.

Most uploads should work without touching either button. However, these buttons become useful if a program crashes early during startup, disables USB functionality or otherwise makes the normal upload process unreliable.

Manually Entering Download Mode

If the Arduino IDE cannot upload to the board, try the following:

1. Press and hold BOOT.
2. Press and release RESET.
3. Release BOOT.
4. Check the Arduino IDE's Port menu again.
5. Select the newly detected port.
6. Upload the sketch.

You can also try holding BOOT while connecting the USB cable.

Troubleshooting the ESP32-S3 Super Mini

No COM Port Appears

First try another USB cable. Some USB-C cables are intended only for charging and contain no data connections.

If the cable is good, manually enter download mode using the BOOT and RESET buttons. Then check whether a new serial device appears.

Sketch Uploads but Serial Monitor is Blank

Verify:

Tools > USB CDC On Boot > Enabled

Also make sure the Serial Monitor baud rate matches the value in:

Serial.begin(115200);

After changing USB-related settings, upload the sketch again.

PSRAM Reports 0 Bytes

Check:

Tools > PSRAM > QSPI PSRAM

Then rerun the memory test.

If PSRAM is still unavailable, read the ESP32-S3 chip marking. Your board may use a different variant than the common ESP32-S3FH4R2.

Board Resets After Enabling PSRAM

Make sure you did not select OPI PSRAM for an FH4R2 board. Its integrated 2 MB PSRAM uses Quad SPI, so select QSPI PSRAM.

RGB LED Does Not Light

GPIO48 is common for the ESP32-S3 Super Mini RGB LED, but board revisions differ. Verify the pinout supplied with your particular board.

Upload Suddenly Stops Working After Running a Sketch

Because the board uses the ESP32-S3's native USB interface, the USB connection is partly under the control of the microcontroller itself. A crashing application can therefore make the normal serial port disappear.

Use the BOOT/RESET procedure to enter the ESP32-S3 ROM downloader and recover the board.

Uploads Fail at High Speed

If uploads are unreliable, lower the upload speed. A lower setting takes slightly longer but can be more reliable with some computers, USB hubs and cables.

ESP32-S3 Super Mini Test Summary

Before using a generic development board in a larger project, I like to verify its important features instead of relying entirely on the seller's specifications. For the ESP32-S3 Super Mini, the tests in this guide cover most of the board's important hardware.

Is the ESP32-S3 Super Mini Worth Using?

The ESP32-S3 Super Mini is an interesting board because it gives you most of the important ESP32-S3 features without the size of a conventional development board.

Compared with smaller single-core ESP32 variants, the S3 gives you considerably more processing power. The common ESP32-S3FH4R2 version also includes 2 MB of PSRAM, which makes it particularly attractive for projects involving displays, large buffers, web interfaces, and other memory-intensive applications.

Native USB is another advantage. Besides normal serial communication, the ESP32-S3's USB hardware makes the chip suitable for projects involving USB devices. That creates possibilities beyond the usual Wi-Fi sensor and web-server projects.

The main disadvantage is documentation. "ESP32-S3 Super Mini" is not one tightly controlled board design, so a pinout or memory specification found online may not describe every version being sold.

Fortunately, we can verify most of the important details ourselves. Check the chip marking, run the flash and PSRAM test, confirm the RGB LED GPIO and keep a copy of the pinout for the exact board you own. Once those details are known, the ESP32-S3 Super Mini becomes a very capable compact development board for embedded and IoT projects.

The post ESP32-S3 Mini Getting Started Guide: Super Mini Pinout, Arduino IDE Setup, PSRAM and RGB LED appeared first on Teach Me Microcontrollers!.

The antenna connection is part of a carefully designed radio-frequency path. The antenna, connector, coaxial cable, PCB trace, matching components, and surrounding ground plane all affect how much of the ESP32's transmitted power is actually radiated.

In this tutorial, we will look at the safest ways of adding an external antenna to an ESP32. This includes choosing a module with a factory-installed U.FL connector, changing an antenna selection jumper, modifying an existing PCB, selecting the correct antenna, and positioning it inside the finished project.

Important: The antenna arrangement differs between ESP32 boards. Before moving or removing any component, find the schematic for your exact development board and inspect the RF section under magnification.

Why Add an External Antenna to an ESP32?

Most ESP32 development boards already contain a small meandered PCB antenna. For a board sitting openly on a desk, this antenna is often sufficient. Problems usually appear after the board is installed in the final product.

An external antenna may be useful when:

• The ESP32 is installed inside a metal enclosure.
• A battery, LCD, motor, relay, or large PCB is close to the built-in antenna.
• The device must communicate through several walls.
• The ESP32 is located near the edge of the access point's coverage.
• The product needs an antenna mounted outside its enclosure.
• The orientation of the built-in PCB antenna is unsuitable for the installation.
• A directional antenna is required for a fixed point-to-point link.

An external antenna does not automatically guarantee longer range. A badly positioned external antenna connected through a poor cable can perform worse than the original PCB antenna. The entire wireless link must be considered.

A simplified link budget can be written as:

$P_R = P_T + G_T + G_R - L_{path} - L_{cable} - L_{mismatch}$

Here, P_R is the received power, P_T is the transmitted power, G_T and G_R are antenna gains, and the remaining terms represent path, cable, and impedance mismatch losses.

This equation explains why installing a higher-gain antenna may not help when a long, lossy cable or an incorrectly modified RF trace introduces additional losses.

Understand Which Type of ESP32 Board You Have

The term “ESP32 board” can refer to the ESP32 chip, a shielded ESP32 module, or a complete development board. The antenna may be part of any one of these assemblies.

ESP32 Modules with External Antenna Connectors

Espressif sells several module families in separate PCB-antenna and external-antenna versions. Examples include:

The letter U commonly indicates an external-antenna connector in Espressif module names. However, this naming convention should not be assumed for every third-party board. Always verify the full module number printed on the metal shield.

A module such as the ESP32-WROOM-32UE does not contain the familiar meandered PCB antenna. Its RF output is routed directly to the small connector on the module. This is normally the easiest and most reliable option for adding an external antenna.

What Is a U.FL Connector?

U.FL is a miniature 50 Ω coaxial connector family made by Hirose. ESP32 sellers sometimes call the same connector an IPEX connector. More precisely, Espressif's first-generation external antenna connector is compatible with Hirose U.FL, I-PEX MHF I, and Amphenol AMC cable plugs.

These connectors are very small and should be handled carefully. The cable plug must be centered directly over the board receptacle and pressed vertically downward. When correctly connected, it should produce a small tactile click.

Do not press the connector at an angle. Doing so can bend the center contact or pull the receptacle away from the PCB.

Also be careful when ordering cables. I-PEX MHF I and MHF 4 are different connector families. An MHF 4 cable is smaller and should not be forced onto a first-generation U.FL or MHF I receptacle.

U.FL-to-SMA Pigtails

A common arrangement uses a short U.FL-to-SMA coaxial pigtail. The U.FL end connects to the ESP32 module, while the SMA end is mounted through the enclosure. A larger external whip antenna then screws onto the SMA connector.

This arrangement provides two advantages:

• The fragile U.FL connector remains protected inside the enclosure.
• The external antenna can be replaced without repeatedly disconnecting the U.FL plug.

Choose the SMA end carefully. SMA and reverse-polarity SMA connectors look similar but have different center contacts. Verify that the panel connector and antenna are compatible before ordering.

Method 1: Use an ESP32 Module with a Factory U.FL Connector

The best method is to begin with a board or module designed for an external antenna. Examples include development boards populated with an ESP32-WROOM-32UE, ESP32-S3-WROOM-1U, or ESP32-C3-WROOM-02U.

Parts Required

• ESP32 development board with an external-antenna module
• Compatible U.FL or MHF I cable assembly
• 2.4 GHz, 50 Ω antenna suitable for the module
• Optional U.FL-to-SMA bulkhead pigtail
• Plastic connector tool or fine nonmetallic tweezers

Connection Procedure

1. Disconnect USB power and any external power supply.
2. Confirm the connector type using the module datasheet.
3. Inspect the U.FL receptacle for contamination or damage.
4. Align the cable plug directly over the receptacle.
5. Press downward on the metal connector body rather than on the cable.
6. Route the cable so that it does not pull sideways on the connector.
7. Add strain relief to the cable several millimeters away from the receptacle.
8. Install the antenna before applying power.

Do not attach adhesive, epoxy, or hot glue directly over the connector until the connection has been tested. Strain relief should hold the cable to the main PCB without pulling on the RF receptacle.

Method 2: Move the ESP32 Antenna Selection Jumper

Some development boards contain both a PCB antenna and a U.FL-style connector. Only one path should normally be active. A small zero-ohm resistor or solder bridge connects the ESP32's RF feed to the selected antenna.

This arrangement is particularly common on some ESP32 camera boards and compact IoT development boards.

How the Three-Pad Selector Works

A typical selector contains three pads:

• The center pad is connected to the ESP32 RF output.
• One outside pad leads to the built-in PCB antenna.
• The other outside pad leads to the U.FL connector.

A zero-ohm resistor bridges the center pad to one of the two antenna paths. To select the external antenna, the resistor is removed from the PCB-antenna path and installed between the center pad and the connector path.

The arrangement is not identical on every board. The external path may be above, below, or beside the original jumper. Never assume that rotating the resistor by 90 degrees is correct without tracing the circuit.

Tools Required

• Fine-tip temperature-controlled soldering iron
• Fine soldering tweezers
• Flux
• Solder wick
• Magnification
• ESD-safe work surface
• Multimeter for checking shorts and continuity

Modification Procedure

1. Remove all power from the board.
2. Take a clear photograph of the original jumper position.
3. Identify the radio feed, PCB antenna route, and connector route from the schematic or PCB traces.
4. Apply a small amount of flux to the zero-ohm resistor.
5. Heat both ends evenly and lift the component with tweezers.
6. Clean the pads using solder wick if necessary.
7. Place the resistor between the RF feed pad and the external-connector pad.
8. Inspect the joint under magnification.
9. Check that the PCB antenna path is no longer connected.
10. Connect the external antenna before powering the ESP32.

A solder blob can sometimes be used instead of reinstalling the zero-ohm resistor, but it must not bridge all three pads. Connecting the PCB antenna and external antenna simultaneously creates an uncontrolled RF junction that can cause severe impedance mismatch.

A multimeter can identify an accidental short or open circuit, but it cannot prove that the RF path has a 50 Ω characteristic impedance at 2.4 GHz. Proper RF performance must be evaluated through signal, throughput, or network-analyzer testing.

Method 3: Add a Coaxial Connection to a Board Without U.FL

This is the most difficult method and should normally be used only for experimentation. If a standard ESP32-WROOM module already contains the PCB antenna, the RF path is part of the module itself. The carrier board does not usually provide a convenient antenna feed that can be modified.

For this type of board, replacing the complete module or development board with an external-antenna version is usually safer than cutting into the module's PCB antenna.

When a Direct PCB Modification Is Possible

A modification may be possible when:

• The RF feed trace is visible and accessible.
• The board contains an exposed matching network.
• The existing PCB antenna can be disconnected without disturbing the matching components.
• A nearby ground point is available for the coaxial shield.
• The modification is being performed on a prototype rather than a certified production product.

Why a Loose Wire Is Not Recommended

A common shortcut is to solder a random wire to the antenna feed. Although the wire may radiate some RF energy, it does not provide a controlled 50 Ω connection. The exposed section of wire, ground geometry, nearby objects, and solder joint all become part of the antenna.

The free-space wavelength at 2.4 GHz is approximately:

$\lambda = \frac{c}{f} \approx 125\text{ mm}$

A free-space quarter wavelength is therefore approximately:

$\frac{\lambda}{4} \approx 31\text{ mm}$

This does not mean that soldering a 31 mm wire to the ESP32 will produce a properly matched antenna. Practical antennas are affected by conductor width, ground plane dimensions, dielectric material, enclosure, loading, and nearby components.

Recommended Direct-Modification Approach

When a direct modification is unavoidable, use a short length of 50 Ω micro-coaxial cable rather than an unshielded wire.

1. Locate the antenna feed and matching network.
2. Determine which side of the series component is connected to the radio.
3. Remove the jumper or cut the trace leading to the built-in antenna.
4. Solder the coaxial cable's center conductor to the radio-side RF feed.
5. Solder the coaxial shield to ground immediately beside the feed point.
6. Keep the exposed center conductor extremely short.
7. Secure the cable to the PCB so movement does not pull on the RF pad.
8. Terminate the other end at a proper U.FL, SMA, or other 50 Ω connector.

The shield connection is as important as the center conductor. A long shield lead creates inductance and can make an otherwise short connection behave poorly at 2.4 GHz.

Do not scrape or cut the antenna trace while the board is powered. Avoid excessive heat because small RF pads can separate easily from the PCB.

Designing an External Antenna Connection on a Custom ESP32 PCB

If you are creating a custom ESP32 board, the RF connection should be designed into the PCB rather than added afterward.

The RF trace between the matching network and antenna connector should have a characteristic impedance of approximately 50 Ω. The correct trace width depends on:

• PCB dielectric thickness
• Copper thickness
• Dielectric constant
• Distance to the reference ground plane
• Whether the trace is microstrip or coplanar waveguide
• Spacing between the trace and surrounding ground copper

Because these values depend on the PCB manufacturer's stack-up, copying the RF trace width from another board does not guarantee the correct impedance.

RF Layout Guidelines

• Keep the RF trace as short as possible.
• Do not create branches or stubs in the antenna path.
• Keep the trace width consistent.
• Avoid routing the RF trace through vias.
• Maintain a continuous ground reference beneath the trace.
• Use ground vias along the sides of a coplanar RF trace.
• Keep crystals, high-speed clocks, USB lines, UART lines, and switching regulators away from the antenna section.
• Place the matching network close to the ESP32 RF output or antenna as directed by the reference design.
• Keep copper and signal traces away from the connector area where required by the connector footprint.
• Include a pi or CLC matching footprint even when the initial design uses zero-ohm or unpopulated components.

The matching network gives you a way to compensate for the final PCB, connector, enclosure, and antenna during RF testing. The correct matching values normally require a vector network analyzer or equivalent RF measurement setup.

Choosing the Correct ESP32 External Antenna

The antenna must match the radio, connector, installation, and certification requirements of the exact ESP32 module.

Frequency

Common ESP32, ESP32-C3, and ESP32-S3 modules operate their Wi-Fi and Bluetooth radios in the 2.4 GHz band. A 2.4 GHz Wi-Fi or Wi-Fi/Bluetooth antenna is therefore required for these modules.

Do not select an antenna only because it physically fits the connector. An antenna intended only for GPS, cellular, LoRa, or sub-GHz operation may have very poor performance at 2.4 GHz.

For newer ESP32 variants supporting additional radio bands, use an antenna specified for every band that the design will use.

Impedance

The antenna and cable should have a nominal impedance of 50 Ω. This matches the RF system used by the ESP32 module and standard Wi-Fi antenna assemblies.

Antenna Gain

Higher gain does not mean that the antenna generates additional power. It concentrates radiation in particular directions while reducing it in others.

For example, a vertical high-gain whip may provide more horizontal coverage but create weaker areas directly above or below the antenna. A low-gain antenna may produce a more useful radiation pattern for a device whose orientation changes.

Certification must also be considered. Some Espressif external-antenna module datasheets specify the antenna used during certification and recommend that replacement antenna gain not exceed that value. The ESP32-WROOM-32UE and ESP32-S3-WROOM-1U documentation, for example, specifies a 2.4 GHz, 50 Ω antenna and lists 2.33 dBi as the certification antenna's maximum gain.

That value should not automatically be applied to every ESP32 module. Check the datasheet and certification documents for your exact part number. Using a different antenna type or higher gain may require additional EMC or regulatory testing.

External Whip Antenna

A screw-on whip antenna is useful when the antenna can be mounted outside the enclosure. It is easy to replace and can be oriented after installation.

Adhesive FPC Antenna

An adhesive flexible antenna can be installed inside a plastic enclosure. It should be mounted according to the antenna manufacturer's instructions. Some flexible antennas are designed to operate against a specific ground plane, while others require clearance from metal.

Do not fold, cut, or sharply bend the active antenna section. The coaxial cable may usually be routed around the enclosure, but the radiating element should remain in its intended shape.

PCB Antenna

A separate PCB antenna can be connected through a coaxial cable and mounted away from the ESP32 board. As with an FPC antenna, the antenna's ground-plane and clearance requirements must be followed.

Directional Antenna

A patch, panel, or Yagi-style antenna may be useful for a fixed point-to-point connection. It must be aimed correctly and may not be suitable for devices that move or need coverage in several directions.

ESP32 Antenna Placement

Antenna placement is often more important than antenna gain. Moving an ordinary antenna away from metal and electrical noise can produce a greater improvement than replacing it with a higher-gain antenna in the same poor location.

Keep the Antenna Away from Metal

Metal close to an antenna can block radiation and change its resonant frequency. Avoid placing the antenna directly against:

• Metal enclosures
• Large batteries
• Heat sinks
• LCD frames
• Metal mounting plates
• Large connectors
• Shielding cans

When using a metal enclosure, mount the antenna outside through a bulkhead connector. The coaxial cable can pass through the wall while the antenna remains in free space.

Keep the Antenna Away from Noise Sources

Switching regulators, DC motors, relays, high-speed displays, USB circuits, memory buses, and digital clocks can introduce interference. Place the antenna and its cable away from these circuits whenever possible.

Do not route the antenna cable parallel to high-current motor or relay wiring. If the paths must cross, crossing at approximately 90 degrees is generally preferable to running them together.

Respect the PCB Antenna Keepout Area

When using an ESP32 module's built-in PCB antenna, place the antenna end at the edge of the carrier PCB. Allowing the antenna to extend beyond the edge is usually the preferred arrangement.

If the antenna cannot extend past the board, there should be no copper, traces, or components under or beside the active antenna region. Espressif recommends providing at least 15 mm of clearance around the PCB antenna inside the finished enclosure.

The exact keepout geometry should come from the hardware design guide for the selected module.

Consider Polarization

A straight whip antenna normally has linear polarization. For communication with a typical access point whose antennas are vertical, starting with the ESP32 antenna vertically oriented is reasonable.

Rotating one antenna by 90 degrees relative to the other can reduce the received signal. Reflections inside buildings may reduce or change this effect, so the final orientation should still be tested experimentally.

Do Not Coil the Cable Around the Antenna

Extra coaxial cable should be routed away from the radiating element. Do not wrap it tightly around the whip or place a coil directly behind an adhesive antenna. The cable shield and nearby conductive objects can alter the antenna pattern.

Test the Finished Enclosure

An antenna that performs well on an open workbench may behave differently after the enclosure, battery, display, and wiring are installed. Always evaluate the complete assembled product.

Testing the ESP32 Antenna Modification

Test the original antenna before making the modification so that you have a baseline. Use the same ESP32 board, access point, location, power supply, orientation, and firmware for both tests.

Useful measurements include:

• Average RSSI
• Packet loss
• Connection and reconnection time
• TCP or UDP throughput
• Maximum usable distance
• Performance through walls
• Performance at different antenna orientations

RSSI is measured in dBm. Values closer to zero represent a stronger received signal. Because RSSI changes with movement, reflections, and nearby people, compare averages rather than relying on one reading.

Arduino RSSI Test Sketch

The following sketch connects to an access point and prints individual RSSI readings followed by their average:

#include <WiFi.h>

const char *ssid = "YOUR_WIFI_SSID";
const char *password = "YOUR_WIFI_PASSWORD";

const int sampleCount = 20;
const unsigned long sampleDelayMs = 500;

void setup() {
  Serial.begin(115200);
  delay(1000);

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  Serial.print("Connecting");

  unsigned long startTime = millis();

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");

    if (millis() - startTime > 30000) {
      Serial.println("\nConnection timed out.");
      return;
    }
  }

  Serial.println("\nConnected.");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
  Serial.print("BSSID: ");
  Serial.println(WiFi.BSSIDstr());
}

void loop() {
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("Wi-Fi disconnected.");
    delay(2000);
    return;
  }

  long rssiTotal = 0;

  Serial.println("Collecting RSSI samples:");

  for (int i = 0; i < sampleCount; i++) {
    int32_t rssi = WiFi.RSSI();
    rssiTotal += rssi;

    Serial.print("Sample ");
    Serial.print(i + 1);
    Serial.print(": ");
    Serial.print(rssi);
    Serial.println(" dBm");

    delay(sampleDelayMs);
  }

  float averageRssi = (float)rssiTotal / sampleCount;

  Serial.print("Average RSSI: ");
  Serial.print(averageRssi, 1);
  Serial.println(" dBm\n");

  delay(3000);
}

Record several test runs with the original antenna and several more with the external antenna. Do not hold the board or antenna during one test and place it on a table during another. Your hand can affect the antenna and invalidate the comparison.

Use More Than RSSI

An improved RSSI reading does not always mean that the entire connection is better. Interference, packet retries, antenna pattern, and access-point behavior can affect actual data transfer.

For a more useful evaluation, transfer a large file or run a local TCP throughput test while monitoring packet loss and disconnections. Repeat the test in the location where the device will actually operate.

Troubleshooting an ESP32 External Antenna

The External Antenna Performs Worse

Check the following:

• The zero-ohm jumper may still select the PCB antenna.
• Both antenna paths may accidentally be connected.
• The U.FL plug may not be fully seated.
• The antenna may be designed for the wrong frequency.
• The antenna may be too close to metal.
• The coaxial cable may be damaged or excessively long.
• The antenna may have a null in the direction of the access point.
• The connector or RF pad may have been damaged during soldering.

Wi-Fi Works Only When the Board Is Close to the Router

This often indicates an open or badly mismatched antenna path. Inspect the selector resistor and U.FL connection. Confirm that the antenna is connected to the radio side of the matching network rather than to the isolated PCB-antenna side.

The Signal Changes When the Cable Is Touched

A large change when touching the cable can indicate that the cable shield is not properly grounded, the connector is loose, or an exposed section of conductor is acting as part of the antenna.

The U.FL Connector Detached from the PCB

Do not attempt to glue it back in place and expect the RF path to work. The center signal pad and surrounding ground pads must be electrically restored. If the pads have lifted, repair normally requires microscope-assisted micro-soldering and a careful RF connection.

The Board Resets While Transmitting

This problem is more likely related to the power supply than the antenna. Wi-Fi transmission produces short current peaks. Check the 3.3 V regulator, USB cable, supply wiring, and decoupling capacitors.

Frequently Asked Questions

Can I connect an antenna directly to an ESP32 GPIO?

No. The Wi-Fi and Bluetooth antenna uses the ESP32's RF output path, not a general-purpose input/output pin. Connecting an antenna to a GPIO will not improve radio range and may expose that GPIO to unwanted RF signals or static discharge.

Can I use the PCB antenna and external antenna at the same time?

Not by simply connecting both paths together. A passive split creates an impedance mismatch and divides transmitted power. A proper diversity or dual-antenna design requires an RF switch, matching network, and support from the selected ESP32 variant and firmware.

Can I solder an SMA connector directly to the board?

Only when the board has a correctly designed 50 Ω RF footprint and sufficient mechanical support. A full-size SMA connector is too large to hang from a small antenna feed pad. A short micro-coaxial pigtail connected to a panel-mounted SMA connector is usually safer.

Will a 9 dBi antenna give three times the ESP32 range?

Not necessarily. Gain is directional, cable loss reduces the improvement, and the other end of the connection must still receive and return data. Higher gain may also exceed the antenna conditions used for the module's regulatory certification.

Does the external antenna improve both Wi-Fi and Bluetooth?

On common ESP32 modules, Wi-Fi and Bluetooth share the 2.4 GHz RF path. A correctly selected external antenna can therefore affect both. The exact internal radio arrangement should still be confirmed in the datasheet for the selected ESP32 variant.

Can I operate an external-antenna ESP32 without an antenna?

Avoid intentionally transmitting for extended periods without an antenna. An open connector produces a severe impedance mismatch, greatly reduces communication performance, and may stress the RF output stage.

Is firmware configuration required after moving the antenna jumper?

Normally, no. A passive zero-ohm antenna selector changes the physical RF path and is not controlled by software. Boards using an electronic RF switch or antenna-diversity circuit may require GPIO or ESP-IDF configuration.

Summary

The safest way of adding an external antenna to an ESP32 is to use a module designed for it, such as an ESP32-WROOM-32UE or ESP32-S3-WROOM-1U. The factory connector preserves the module's controlled RF path and avoids cutting the built-in PCB antenna.

For boards containing both a PCB antenna and a U.FL connector, locate the antenna selector and move its zero-ohm jumper to the external path. Do not leave both antenna paths connected.

Directly modifying a PCB-antenna module is possible in some cases, but it requires isolating the existing antenna and attaching a properly grounded 50 Ω micro-coaxial cable. A loose wire is not a reliable substitute for a matched antenna connection.

Finally, pay close attention to placement. Keep the antenna away from metal, high-speed circuits, batteries, displays, and noisy wiring. Test the complete device in its final enclosure using RSSI, packet loss, and actual throughput rather than assuming that a larger antenna will automatically provide better range.

The post Adding an External Antenna to ESP32: U.FL, PCB Modifications, and Placement appeared first on Teach Me Microcontrollers!.

You may notice that the measured voltage is lower than expected, the first reading is different from the following readings, or one ADC channel appears to affect another. These symptoms are often blamed on analog input leakage current. Leakage is part of the problem, but the ESP32-S3's switched-capacitor ADC input also creates a temporary load whenever a conversion starts.

In this article, we will examine how ESP32-S3 analog input leakage affects high-impedance circuits and how to design an ADC input that produces stable and repeatable readings.

How the ESP32-S3 ADC Input Works

The ESP32-S3 contains two 12-bit successive-approximation ADC units. Together, they provide 20 analog input channels:

For most projects, ADC1 is the better choice. Espressif recommends ADC1, and ADC2 analog functions cannot be used normally while Wi-Fi is using the ADC2 peripheral.

A 12-bit conversion produces values from 0 to 4095. However, the raw result is not automatically equal to an exact voltage because the internal reference voltage varies from one chip to another. The ESP32-S3 reference is designed around 1.1 V, but its actual value can vary approximately from 1.0 V to 1.2 V. For this reason, calibrated voltage functions should be used whenever possible.

What Is Analog Input Leakage Current?

An ideal ADC input would have infinite resistance and draw no current from the measured circuit. A real microcontroller pin contains protection structures, switches, multiplexers, transistors, parasitic capacitance, and internal analog circuitry. Small currents can therefore flow into or out of the pin.

When the source resistance is low, this current produces almost no visible error. When the source resistance is hundreds of kilohms or several megohms, even a tiny current can create a measurable voltage drop.

The approximate DC error caused by leakage is:

$V_{error}=I_{leak}\times R_{source}$

For example, suppose an analog source has an equivalent resistance of 200 kΩ. The resulting errors would be:

The ESP32-S3 datasheet specifies a maximum high-level and low-level digital GPIO input current of 50 nA under its stated DC test conditions. However, this value should not be treated as a guaranteed ADC input leakage specification. The datasheet does not provide a separate worst-case analog leakage value covering ADC conversions, attenuation settings, temperature, board contamination, and all operating modes.

For a high-impedance design, it is safer to consider the 50 nA figure only as a pin-level reference. The complete ADC circuit should be tested across temperature and operating conditions, or isolated from the signal source using an analog buffer.

The ADC Is a Dynamic Load

Leakage current explains steady DC error, but it does not explain every problem seen with high-impedance inputs. The ESP32-S3 uses a successive-approximation ADC, which includes an internal sampling network.

At the beginning of a conversion, an internal switch briefly connects the selected GPIO to a sampling capacitor. The input source must provide enough charge for this capacitor to approach the input voltage during the available acquisition period.

A simplified settling relationship is:

$V_{error}=V_{step}e^{-\frac{t_{acq}}{R_{source}C_{sample}}}$

Here, Rsource is the source resistance, Csample is the effective internal sampling capacitance, and tacq is the acquisition time.

As the source resistance increases, the capacitor takes longer to charge. If the ADC starts its conversion before the voltage settles, the result can be lower or higher than the actual signal. This effect may appear even when the static leakage current is extremely small.

The internal attenuation network also changes the signal path. Consequently, source loading and conversion error may vary with the selected attenuation setting.

Why the First ADC Reading Can Be Wrong

The ADC input multiplexer connects several analog channels to the same converter. When software changes from one channel to another, the sampling network can retain a small amount of charge from the previous channel.

A low-impedance source quickly replaces this charge. A high-impedance source may require more time. The first reading can therefore be influenced by:

• The voltage previously measured on another ADC channel
• Residual charge in the sampling network
• The selected attenuation setting
• The external filter capacitor
• The time between channel selection and conversion

A common software solution is to perform one dummy conversion after changing channels and discard its result. This helps, but it does not replace proper analog input design.

High-Value Resistor Divider Example

Consider a circuit that measures a supply voltage of up to 15 V. To minimize battery drain, we use a 1 MΩ upper resistor and a 220 kΩ lower resistor.

The voltage presented to the ESP32-S3 is:

$V_{ADC}=V_{IN}\frac{R_{BOTTOM}}{R_{TOP}+R_{BOTTOM}}$

At 15 V:

$V_{ADC}=15\frac{220000}{1000000+220000}=2.705\text{ V}$

This keeps the input below the ESP32-S3 datasheet's 2.9 V effective calibrated range for the highest attenuation setting.

The divider current at 15 V is:

$I_{DIV}=\frac{15}{1000000+220000}=12.3\mu\text{A}$

The ADC does not see 1.22 MΩ as its source resistance. The Thevenin resistance at the divider output is:

$R_{TH}=R_{TOP}\parallel R_{BOTTOM}$

$R_{TH}=\frac{1000000\times220000}{1000000+220000}=180.3\text{ k}\Omega$

This is still a relatively high source impedance. An assumed leakage current of 100 nA would produce approximately:

$V_{error}=100\text{ nA}\times180.3\text{ k}\Omega=18.0\text{ mV}$

At the original 15 V input, the equivalent error is multiplied by the divider ratio:

$V_{IN_error}=18.0\text{ mV}\times\frac{1220000}{220000}\approx100\text{ mV}$

This calculation only estimates static leakage error. Sampling transients, resistor tolerance, ADC error, noise, temperature, and PCB leakage can add further error.

Adding a Capacitor to the ADC Input

Espressif recommends placing a 0.1 µF capacitor between the ADC pin and ground. The capacitor performs two useful functions:

• It filters high-frequency noise before it reaches the ADC.
• It acts as a local charge reservoir for the ADC sampling capacitor.

For the 1 MΩ and 220 kΩ divider, the approximate time constant with a 0.1 µF capacitor is:

$\tau=R_{TH}C$

$\tau=180.3\text{ k}\Omega\times0.1\mu\text{F}=18.0\text{ ms}$

A capacitor is normally considered nearly settled after about five time constants:

$t_{settle}\approx5\tau=90\text{ ms}$

If the divider is permanently connected, the capacitor remains charged and this delay is not usually needed before every measurement. If the divider is switched on only when a reading is required, the firmware should wait approximately 90 to 100 ms before sampling.

The capacitor and divider also create a low-pass filter. Its approximate cutoff frequency is:

$f_c=\frac{1}{2\pi R_{TH}C}$

$f_c=\frac{1}{2\pi(180.3\text{k}\Omega)(0.1\mu\text{F})}\approx8.8\text{ Hz}$

This is suitable for battery voltage, temperature, and other slowly changing signals. It may be too slow for audio, vibration, or fast control signals.

Method 1: Reduce the Divider Resistance

The simplest way to reduce loading error is to use lower resistor values. A 100 kΩ and 22 kΩ divider has the same ratio as the 1 MΩ and 220 kΩ divider, but its Thevenin resistance is only about 18 kΩ.

The lower-value divider consumes more current, but it is less affected by leakage, PCB contamination, and ADC sampling transients.

For mains-powered equipment, the additional current may not matter. For a battery-powered sensor that sleeps most of the time, a switched divider may provide a better compromise.

Method 2: Use a Switched Voltage Divider

A switched divider keeps the resistors disconnected while the ESP32-S3 is sleeping. The firmware enables the divider shortly before taking a measurement and disables it afterward.

A high-side P-channel MOSFET or a low-leakage analog load switch can be used to connect the upper resistor to the measured supply. After enabling the circuit, wait for the divider and filter capacitor to settle.

The switch itself must also be selected carefully. MOSFET off-state leakage, gate leakage, and contamination around the ADC node may become significant when using megohm resistors.

A low-side switch should generally be avoided for this application because it can leave the ADC pin connected to the measured voltage through the upper resistor while the lower resistor is disconnected. This can make the pin float, forward-bias protection structures, or create an unexpected current path.

Method 3: Buffer the Signal with an Op-Amp

For very high-impedance sensors, the best solution is usually a voltage follower.

The sensor or resistor network connects to the op-amp input, while the op-amp output drives the ESP32-S3 ADC. The op-amp presents a very high input resistance to the sensor and a low output resistance to the ADC.

Look for the following characteristics:

• Very low input bias current
• Operation from a 3.3 V supply
• Rail-to-rail input and output
• Input common-mode range that includes the measured signal
• Output swing that covers the required ADC voltage range
• Low offset voltage and low drift
• Stability when driving a capacitive load

A small resistor, typically between 100 Ω and 1 kΩ, can be placed between the op-amp output and the ADC capacitor. This resistor isolates the amplifier from the capacitor and can improve stability.

Some sensor types have an impedance so high that they should never be connected directly to a microcontroller ADC. In such cases, an amplifier designed for extremely low input bias current is required.

Method 4: Improve PCB Layout and Cleanliness

At megohm impedance levels, the PCB becomes part of the analog circuit. Flux residue, dust, moisture, solder mask contamination, and fingerprints can create leakage paths comparable to the signal current.

Use these layout practices:

• Keep the high-impedance trace short.
• Place the filter capacitor close to the ESP32-S3 pin.
• Keep the trace away from switching regulators, clocks, USB, and antenna circuitry.
• Avoid routing digital signals parallel to the ADC trace.
• Clean flux residue from the board.
• Use a ground plane around ordinary low-level analog traces.
• For extremely high impedance, consider a driven guard around the sensitive node.

Also make sure that internal pull-up and pull-down resistors are disabled on the ADC pin. These resistors are approximately tens of kilohms and will completely disturb a high-value divider.

Choosing the ADC Attenuation

The ESP32-S3 ADC supports several attenuation settings. Higher attenuation permits a larger voltage at the pin but usually produces more conversion error near the upper end of the range.

The Arduino API continues to use the name ADC_ATTEN_DB_11, while newer ESP-IDF documentation may describe the highest attenuation as 12 dB.

For best accuracy, do not design the divider so that the maximum expected voltage is exactly at the upper ADC limit. Leave margin for supply variation, resistor tolerance, transients, and calibration error.

Arduino ESP32-S3 ADC Example

The following sketch reads a high-value 1 MΩ and 220 kΩ divider connected to GPIO4. GPIO4 is an ADC1 pin on the ESP32-S3.

The circuit should include a 0.1 µF ceramic capacitor from GPIO4 to ground.

#include <Arduino.h>

const uint8_t ADC_PIN = 4;

const float R_TOP = 1000000.0f;
const float R_BOTTOM = 220000.0f;

const uint8_t SAMPLE_COUNT = 32;

uint32_t readAdcMillivolts()
{
    uint64_t total = 0;

    // Dummy conversion to help the ADC input settle.
    (void)analogRead(ADC_PIN);
    delayMicroseconds(500);

    for (uint8_t i = 0; i < SAMPLE_COUNT; i++)
    {
        total += analogReadMilliVolts(ADC_PIN);
        delayMicroseconds(500);
    }

    return (uint32_t)(total / SAMPLE_COUNT);
}

float readInputVoltage()
{
    const uint32_t adcMillivolts = readAdcMillivolts();
    const float adcVoltage = adcMillivolts / 1000.0f;

    return adcVoltage * (R_TOP + R_BOTTOM) / R_BOTTOM;
}

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

    analogReadResolution(12);
    analogSetPinAttenuation(ADC_PIN, ADC_ATTEN_DB_11);

    delay(100);
}

void loop()
{
    const uint32_t adcMillivolts = readAdcMillivolts();
    const float inputVoltage =
        (adcMillivolts / 1000.0f) *
        (R_TOP + R_BOTTOM) / R_BOTTOM;

    Serial.printf(
        "ADC: %lu mV, Input: %.3f V\n",
        (unsigned long)adcMillivolts,
        inputVoltage
    );

    delay(1000);
}

The analogReadMilliVolts() function returns a calibrated voltage rather than an uncorrected raw ADC count. Averaging reduces random noise, while the dummy conversion helps after the input multiplexer or attenuation circuitry has changed state.

The code does not compensate for resistor tolerance, leakage, PCB contamination, or gain and offset error in the complete circuit. Final calibration should be performed using a trusted multimeter or voltage reference.

Two-Point Calibration

For better accuracy, apply two known input voltages and record the corresponding ESP32-S3 readings. The corrected voltage can then be represented as:

$V_{corrected}=mV_{measured}+b$

The gain is:

$m=\frac{V_{actual2}-V_{actual1}}{V_{measured2}-V_{measured1}}$

The offset is:

$b=V_{actual1}-mV_{measured1}$

Store the resulting gain and offset in flash or non-volatile storage. This calibration corrects consistent gain and offset errors, but it cannot fully correct unstable leakage, insufficient settling time, or temperature-dependent errors.

Sampling High-Impedance ADC Channels

Use the following sampling sequence when reading a high-impedance source:

1. Enable the divider or sensor power, when applicable.
2. Wait for the external RC network to settle.
3. Select the ADC channel and attenuation.
4. Perform one dummy conversion.
5. Take multiple calibrated readings.
6. Average or median-filter the samples.
7. Disable the measurement circuit when finished.

Do not sample faster than the source and filter network can settle. Increasing the sample rate does not improve a circuit whose source cannot recharge the ADC input between conversions.

If several ADC channels have very different voltages, consider reading each channel twice and discarding the first conversion. A buffer amplifier for each high-impedance channel provides a more reliable solution.

Wi-Fi and ADC Noise

ADC1 can be used while Wi-Fi is active, but wireless transmission causes rapidly changing current consumption. These current pulses can introduce noise into the power and ground networks.

For precision measurements:

• Use ADC1 instead of ADC2.
• Add proper supply decoupling near the ESP32-S3.
• Place the ADC capacitor close to the pin.
• Avoid taking critical readings during Wi-Fi transmission.
• Average several readings.
• Consider temporarily stopping wireless activity during calibration or precision sampling.

The ESP32-S3 datasheet's ADC characterization was performed with a 100 nF capacitor, a DC input signal, an ambient temperature of 25 °C, and Wi-Fi disabled. A real application may therefore show more noise than the published test results.

Common ESP32-S3 High-Impedance ADC Problems

ESP32-S3 High-Impedance ADC Design Checklist

• Prefer GPIO1 to GPIO10 on ADC1.
• Keep the maximum ADC voltage below the calibrated effective range.
• Add approximately 0.1 µF between the ADC pin and ground.
• Calculate the divider's Thevenin resistance.
• Estimate leakage error using the required voltage accuracy.
• Allow at least five external RC time constants after switching the circuit on.
• Discard the first reading after changing channels.
• Average multiple calibrated readings.
• Disable internal pull-up and pull-down resistors.
• Keep the ADC trace short and away from noisy signals.
• Clean the PCB when using megohm impedances.
• Use an op-amp buffer when the sensor impedance is very high.
• Calibrate the complete circuit, not only the ADC.

Conclusion

The ESP32-S3 ADC input should not be treated as an ideal infinite-resistance voltmeter. Static leakage current can create voltage error when the source impedance is high, while the ADC's internal sampling network can temporarily load the signal during each conversion.

A 0.1 µF capacitor at the ADC pin is an important starting point and is recommended by Espressif. However, the capacitor must be combined with adequate settling time, suitable divider values, ADC1 channel selection, averaging, careful PCB layout, and calibration.

For battery monitoring and other slowly changing signals, a high-value divider with a local capacitor may provide acceptable performance. For extremely high-impedance sensors or precision measurements, a low-bias-current op-amp buffer is the more reliable solution.

References

• Espressif ESP32-S3 Series Datasheet
• ESP32-S3 Hardware Design Guidelines
• Arduino-ESP32 ADC API
• ESP32-S3 ADC Calibration Driver

The post ESP32-S3 Analog Input Leakage Current: High-Impedance ADC Design appeared first on Teach Me Microcontrollers!.

In this tutorial, we will build an ESP32-S3 AA battery power supply using two AA cells and an MT3608 boost converter. We will also add an optional battery-voltage monitor and use deep sleep to make the batteries last longer.

The short answer is that an ESP32-S3 can run from AA batteries, but the batteries should not normally be connected directly to the development board. The voltage must remain stable, and the power circuit must handle the short current bursts produced when the ESP32-S3 uses Wi-Fi or Bluetooth.

This tutorial assumes an ESP32-S3 development board similar to the Espressif ESP32-S3-DevKitC-1. Other ESP32-S3 boards may have different regulators, power LEDs, USB circuits, pin labels, and power-input arrangements. Check your board’s schematic before applying power through its 3V3 pin.

Can an ESP32-S3 Run on AA Batteries?

Yes. Two AA batteries can power an ESP32-S3 when used with a suitable voltage converter. The ESP32-S3 chip normally operates from a 3.3 V supply. Its acceptable supply range is approximately 3.0 V to 3.6 V. The power source must also handle the ESP32-S3’s brief current peaks when its radio begins transmitting.

A pair of alkaline AA batteries has a nominal voltage of:

$2 \times 1.5\text{ V} = 3.0\text{ V}$

At first glance, 3.0 V may appear close enough to the ESP32-S3’s operating voltage. The problem is that battery voltage does not remain fixed. A fresh alkaline cell may measure above 1.5 V without a load. Its voltage then gradually falls as the battery discharges. The terminal voltage can also drop suddenly when the ESP32-S3 draws a high-current pulse. Directly connecting two AA cells to the 3V3 pin may therefore work initially but become unreliable as the batteries discharge. The ESP32-S3 may reset when Wi-Fi starts, fail to boot, or stop operating long before the batteries are completely empty.

To avoid this problem, we will use an MT3608 boost converter adjusted to provide a regulated 3.3 V output.

What Is the MT3608?

The MT3608 is a small step-up or boost converter. A boost converter takes a lower DC voltage and raises it to a higher regulated voltage.

Common MT3608 breakout modules include:

• An MT3608 switching-regulator IC
• An inductor
• A Schottky diode
• Input and output capacitors
• A multi-turn adjustment potentiometer
• IN+, IN−, OUT+, and OUT− connection pads

The MT3608 IC has an input-voltage range of approximately 2 V to 24 V and an adjustable output. Its switching frequency is 1.2 MHz. For this project, the module raises the changing voltage from two AA cells to a regulated 3.3 V:

$V_{\text{BATTERY}} \longrightarrow \text{MT3608} \longrightarrow 3.3\text{ V}$

The MT3608 is inexpensive and widely available, which makes it practical for a prototype or hobby project.

The MT3608 Is Boost-Only

An important limitation is that the MT3608 can only raise voltage. It cannot reduce a voltage that is higher than the desired output. For example, an MT3608 should not be used to convert a three-cell alkaline battery pack from approximately 4.5 V down to 3.3 V. That would require a buck converter or buck-boost converter instead. Two alkaline or two NiMH AA cells remain below the desired 3.3 V output during normal use, so they are suitable for this circuit.

MT3608 Current Ratings

Many online listings describe an MT3608 module as a “2 A boost converter.” This does not necessarily mean that the module can continuously supply 2 A at its output under all conditions.

The available output current depends on:

• Input voltage
• Output voltage
• Converter efficiency
• Inductor rating
• Diode rating
• PCB layout
• Cooling
• Battery condition and internal resistance

At a low battery voltage, the converter must draw more current from the batteries than it delivers at its output.

Ignoring converter losses for a moment:

$V_{\text{IN}}I_{\text{IN}} \approx V_{\text{OUT}}I_{\text{OUT}}$

After including converter efficiency:

$I_{\text{IN}} = \frac{V_{\text{OUT}}I_{\text{OUT}}}{V_{\text{IN}}\eta}$

For example, supplying 500 mA at 3.3 V from a 2.0 V battery pack at 85% efficiency would require approximately:

$I_{\text{IN}} = \frac{3.3 \times 0.5}{2.0 \times 0.85}$

$I_{\text{IN}} \approx 0.97\text{ A}$

The ESP32-S3 will not continuously draw 500 mA in a typical sensor project, but the batteries and converter must tolerate its short radio-current peaks.

AA Battery Configurations for the MT3608

Here is what happens with common AA battery arrangements:

Two AA cells are therefore the most convenient arrangement for this MT3608 circuit.

Because the MT3608 requires approximately 2 V at its input, the converter will eventually stop operating when a two-cell pack falls to about 1 V per cell.

Required Components

For the basic ESP32-S3 AA battery circuit, you will need:

• ESP32-S3 development board
• MT3608 adjustable boost-converter module
• Two-cell AA battery holder
• Two matching AA batteries
• On/off switch
• 470 µF electrolytic capacitor rated for at least 6.3 V
• 0.1 µF ceramic capacitor
• Multimeter
• Jumper wires or soldered connections

For battery-voltage measurement, you will also need:

• Two 100 kΩ resistors
• One optional 0.1 µF capacitor

Use batteries of the same type, brand, capacity, and approximate age. Do not mix alkaline batteries with rechargeable batteries in the same holder.

Adjusting the MT3608 to 3.3 V

The MT3608 is an adjustable converter. It must be configured before it is connected to the ESP32-S3.

Do not connect the MT3608 output to the ESP32-S3 until you have measured and adjusted its output voltage. An incorrectly adjusted module can output a voltage high enough to damage the board.

Follow these steps:

1. Insert the two AA batteries into the holder.
2. Connect the battery holder’s positive wire to MT3608 IN+.
3. Connect the battery holder’s negative wire to MT3608 IN−.
4. Set your multimeter to DC voltage.
5. Measure between MT3608 OUT+ and OUT−.
6. Turn the adjustment potentiometer slowly while watching the multimeter.
7. Stop when the output reads approximately 3.30 V.
8. Disconnect the batteries before wiring the ESP32-S3.

The potentiometer on many MT3608 modules is multi-turn. It may require several rotations before the output voltage visibly changes. Do not assume that every module adjusts in the same direction. Watch the multimeter while turning the potentiometer.

ESP32-S3 AA Battery Wiring Diagram

After adjusting the MT3608 to 3.3 V, connect the complete circuit as follows:

Observe the polarity of the electrolytic capacitor:

• Capacitor positive lead to MT3608 OUT+
• Capacitor negative lead to ground

The 470 µF capacitor helps supply short bursts of current when the ESP32-S3 radio begins transmitting. The 0.1 µF ceramic capacitor helps suppress higher-frequency noise. Install the capacitors close to the ESP32-S3 power pins rather than close to the battery holder. Long wires add resistance and inductance, reducing the capacitors’ ability to support fast current pulses.

Why We Connect the MT3608 to the 3V3 Pin

Most ESP32-S3 development boards include an onboard regulator that converts USB or 5 V input to 3.3 V.

One option would be to adjust the MT3608 to 5 V and connect it to the board’s 5V input. However, the power would pass through two conversion stages:

$\text{AA batteries} \longrightarrow 5\text{ V boost} \longrightarrow 3.3\text{ V regulator}$

Each conversion stage wastes some energy.

By adjusting the MT3608 to 3.3 V and connecting it directly to the 3V3 pin, we bypass the development board’s onboard regulator:

$\text{AA batteries} \longrightarrow 3.3\text{ V boost} \longrightarrow \text{ESP32-S3}$

The disadvantage is that the board no longer has another regulator between the MT3608 and the ESP32-S3. The MT3608 output must therefore be adjusted accurately and checked before every major wiring change.

Important USB Power Warning

Disconnect the AA battery supply before connecting the ESP32-S3 to USB unless the board or external circuit includes proper power-source isolation.

Connecting USB power and an external 3.3 V supply at the same time may cause current to flow backward into one of the power sources.

A simple approach during development is:

1. Switch off or disconnect the AA battery holder.
2. Connect USB and upload the sketch.
3. Disconnect USB.
4. Reconnect or switch on the battery supply.

A more advanced design can use:

• Schottky-diode isolation
• An ideal-diode controller
• A load switch
• A power multiplexer
• A jumper that selects USB or battery power

Adding an ESP32-S3 Battery Voltage Monitor

The ESP32-S3 can measure the battery voltage using one of its ADC pins. The measurement must be taken from the battery side of the MT3608. Measuring the converter output would normally show approximately 3.3 V even as the batteries discharge.

For a two-cell AA pack, use the following voltage divider:

GPIO4 is an ADC-capable pin on the ESP32-S3 and corresponds to ADC1 channel 3.

The two equal resistors divide the battery voltage by two:

$V_{\text{ADC}} = V_{\text{BATTERY}} \times \frac{100\,\text{k}\Omega}{100\,\text{k}\Omega + 100\,\text{k}\Omega}$

Therefore:

$V_{\text{BATTERY}} = V_{\text{ADC}} \times 2$

A fresh two-cell alkaline pack measuring 3.2 V produces approximately:

$V_{\text{ADC}} = \frac{3.2}{2} = 1.6\text{ V}$

An optional 0.1 µF capacitor from GPIO4 to ground can reduce noise and help stabilize the ADC reading. This is especially useful because the two 100 kΩ resistors create a relatively high-impedance source for the ADC.

The resistor divider continuously draws a small current:

$I = \frac{3.0\text{ V}}{200\,\text{k}\Omega}$

$I = 15\,\mu\text{A}$

This is small compared with the consumption of a normal ESP32-S3 development board. However, it can become significant in a highly optimized low-power design. On a custom PCB, the voltage divider can be enabled only when a measurement is required by using a MOSFET or analog switch.

ESP32-S3 AA Battery and Deep-Sleep Code

The following Arduino sketch reads the AA battery-pack voltage and then places the ESP32-S3 into deep sleep for ten minutes.

#include <Arduino.h>

#define BATTERY_ADC_PIN       4
#define SLEEP_TIME_SECONDS    600

const float R1 = 100000.0;
const float R2 = 100000.0;

float readBatteryVoltage()
{
  const int numberOfSamples = 32;
  uint32_t totalMillivolts = 0;

  for (int i = 0; i < numberOfSamples; i++)
  {
    totalMillivolts += analogReadMilliVolts(BATTERY_ADC_PIN);
    delay(5);
  }

  float adcMillivolts =
      totalMillivolts / (float)numberOfSamples;

  float adcVoltage = adcMillivolts / 1000.0;

  // Reconstruct the original battery voltage.
  float batteryVoltage =
      adcVoltage * ((R1 + R2) / R2);

  return batteryVoltage;
}

void setup()
{
  Serial.begin(115200);
  delay(1000);

  analogReadResolution(12);
  analogSetPinAttenuation(BATTERY_ADC_PIN, ADC_11db);

  float batteryVoltage = readBatteryVoltage();

  Serial.print("AA battery pack voltage: ");
  Serial.print(batteryVoltage, 2);
  Serial.println(" V");

  /*
   * Read sensors or transmit data here.
   *
   * Keep this section as short as possible.
   * Wi-Fi, Bluetooth and sensors consume much
   * more current than deep sleep.
   */

  Serial.println("Entering deep sleep...");
  Serial.flush();

  esp_sleep_enable_timer_wakeup(
      (uint64_t)SLEEP_TIME_SECONDS * 1000000ULL
  );

  esp_deep_sleep_start();
}

void loop()
{
  // The ESP32-S3 restarts setup() after waking
  // from deep sleep.
}

The Arduino-ESP32 API provides analogReadMilliVolts(), which returns a calibrated voltage value rather than a raw ADC count.

The 11 dB attenuation setting increases the input range available to the ADC. The divided battery voltage should remain well below the ESP32-S3 ADC pin’s maximum level.

How the Deep-Sleep Code Works

The ESP32-S3 executes setup() after power-up and after every deep-sleep wake-up.

The program performs the following sequence:

1. Configures the ADC.
2. Reads the AA battery-pack voltage.
3. Performs the required sensor or communication task.
4. Configures a ten-minute wake-up timer.
5. Enters deep sleep.
6. Restarts when the timer expires.

The sleep duration is configured here:

#define SLEEP_TIME_SECONDS 600

For a five-minute interval, change it to:

#define SLEEP_TIME_SECONDS 300

For a one-hour interval:

#define SLEEP_TIME_SECONDS 3600

Deep sleep powers down the ESP32-S3 CPUs and most digital peripherals while retaining selected RTC circuitry. The ESP32-S3 chip itself can reach a deep-sleep current of only a few microamps under datasheet conditions. A complete development board will normally consume more because it may also contain:

• A voltage regulator
• USB-to-UART circuitry
• USB interface circuitry
• A power indicator LED
• An addressable RGB LED
• Flash memory
• PSRAM
• Pull-up resistors
• Other support components

The MT3608 module also consumes current while operating, even when the ESP32-S3 is asleep.

Is the MT3608 Good for Deep-Sleep Projects?

The MT3608 is suitable for learning, prototyping, and inexpensive battery-powered projects. However, it is not necessarily the best converter for an ultra-low-power sensor node.

The total sleep current includes:

• ESP32-S3 development-board sleep current
• MT3608 operating current
• Any indicator LED on the MT3608 module
• Battery-monitor divider current
• Sensor standby current
• Leakage through connected peripherals

Some generic MT3608 modules include an indicator LED that remains on continuously. Even a small LED current can become significant when the ESP32-S3 spends most of its time sleeping. For a project intended to run for many months or years, consider a boost converter designed specifically for low-quiescent-current operation.

The MT3608 remains useful for this tutorial because it is:

• Inexpensive
• Widely available
• Easy to adjust
• Easy to mount on a breadboard or prototype board
• Capable of supplying an ESP32-S3 when properly selected and tested

Estimating ESP32-S3 AA Battery Runtime

Battery runtime depends more on average current than on the highest current peak.

A basic runtime estimate is:

$\text{Runtime (hours)} = \frac{\text{Battery capacity (mAh)}}{\text{Average battery current (mA)}}$

Suppose the ESP32-S3:

• Draws 120 mA while awake
• Remains awake for five seconds
• Wakes every ten minutes
• Draws 0.3 mA from the 3.3 V rail while sleeping

Its average current on the regulated 3.3 V rail is approximately:

$I_{\text{AVG}} = 120\left(\frac{5}{600}\right) + 0.3\left(\frac{595}{600}\right)$

$I_{\text{AVG}} \approx 1.30\text{ mA}$

Assuming an average battery voltage of 2.4 V and an MT3608 efficiency of 85%:

$I_{\text{BATTERY}} = \frac{3.3 \times 1.30}{2.4 \times 0.85}$

$I_{\text{BATTERY}} \approx 2.1\text{ mA}$

Using a conservative usable battery capacity of 2000 mAh:

$\text{Runtime} = \frac{2000}{2.1}$

$\text{Runtime} \approx 953\text{ hours}$

This is approximately 40 days.

However, this simplified calculation does not include the MT3608 module’s own operating current. Suppose the converter module and its indicator LED draw an additional 1 mA from the battery pack:

$I_{\text{TOTAL}} = 2.1\text{ mA} + 1.0\text{ mA}$

$I_{\text{TOTAL}} = 3.1\text{ mA}$

The estimated runtime would then become:

$\text{Runtime} = \frac{2000}{3.1}$

$\text{Runtime} \approx 645\text{ hours}$

This is approximately 27 days.

This example shows why converter idle current matters in a deep-sleep project.

Actual runtime may be lower because of:

• MT3608 quiescent and indicator-LED current
• Battery internal resistance
• Low-temperature operation
• Wi-Fi connection time
• Sensor consumption
• Development-board LEDs
• Battery age
• Reduced alkaline capacity at higher discharge currents
• The MT3608’s approximately 2 V minimum input
• Conversion losses that change with load and battery voltage

The best approach is to measure the current of the complete circuit using the actual batteries, converter module, sensors, development board, and firmware.

Alkaline or Rechargeable AA Batteries?

Both alkaline and NiMH AA batteries can be used with the MT3608.

Alkaline AA Batteries

Alkaline batteries have a nominal voltage of 1.5 V per cell. Two cells produce a nominal 3.0 V, which the MT3608 can raise to 3.3 V. Alkaline cells are widely available and have a relatively low self-discharge rate. However, their voltage continuously falls during use, and their effective capacity decreases under heavier loads. The high current pulses produced by Wi-Fi may cause a larger temporary voltage drop when alkaline batteries are old, cold, or partially discharged.

NiMH Rechargeable AA Batteries

NiMH batteries typically have a nominal voltage of 1.2 V per cell. Two cells therefore provide approximately:

$2 \times 1.2\text{ V} = 2.4\text{ V}$

The MT3608 raises this to 3.3 V. NiMH batteries generally handle repeated high-current pulses better than ordinary alkaline batteries and can be recharged many times. For a frequently used wireless sensor, NiMH cells may be more economical. Low-self-discharge NiMH batteries are especially useful when the device spends long periods asleep.

Improving ESP32-S3 AA Battery Life

Use Deep Sleep

Do not leave the ESP32-S3 running continuously if it only needs to take a measurement every few minutes. Deep sleep normally provides a much larger improvement than simply reducing the CPU frequency while the chip remains awake.

Keep Wi-Fi Sessions Short

Connecting to Wi-Fi and transmitting data consume considerably more current than sleeping.

A battery-powered application should normally:

1. Wake up.
2. Read its sensors.
3. Connect to the network.
4. Transmit its data.
5. Disconnect or shut down the radio.
6. Return to deep sleep.

Remove or Disable Power LEDs

A power LED drawing even 1 mA becomes significant when the ESP32-S3 spends most of its time in deep sleep. Inspect both the ESP32-S3 board and the MT3608 module for always-on LEDs. Some boards allow the LED resistor to be removed. Others require cutting a trace. Only modify a board after inspecting its schematic and PCB connections.

Turn Sensors Off While Sleeping

Some sensors continue drawing current even while the ESP32-S3 is asleep. A load switch, P-channel MOSFET, or regulator-enable pin can disconnect sensor power before deep sleep.

Keep the Wires Short

Long, thin wires add resistance. A high current pulse can produce a temporary voltage drop across them:

$V_{\text{DROP}} = I \times R$

Keep the battery, MT3608, capacitor, and ESP32-S3 power connections short and secure.

Use a Low-Power Converter for Long Deployments

The MT3608 is useful for prototyping, but a low-quiescent-current fixed-output converter is a better choice when maximizing runtime is more important than minimizing component cost.

Move to a Custom PCB

Development boards are excellent for prototyping, but their USB interface, LEDs, regulator, and support circuitry are not always optimized for battery operation. A custom PCB using an ESP32-S3 module and a low-power converter can achieve much lower sleep current.

Troubleshooting the ESP32-S3 MT3608 Circuit

The ESP32-S3 Resets When Wi-Fi Starts

This is usually caused by the 3.3 V rail dropping during a radio-current burst.

Check the following:

• MT3608 output voltage under load
• Battery condition
• Battery-holder contacts
• Wire length and thickness
• Output-capacitor value and placement
• Solder joints
• MT3608 module quality

Place the 470 µF capacitor close to the ESP32-S3. Measure the 3.3 V rail while the ESP32-S3 starts Wi-Fi rather than measuring it only when the board is idle.

The MT3608 Output Does Not Change

The adjustment potentiometer may require many turns before the voltage changes. Continue turning it slowly while monitoring the output with a multimeter. Do not connect the ESP32-S3 while experimenting with the adjustment.

The MT3608 Cannot Reach 3.3 V

Measure the battery voltage at IN+ and IN−. The input may have fallen below the MT3608’s operating range, or the battery voltage may collapse when a load is connected.

Also inspect:

• Battery polarity
• Loose holder contacts
• Incorrect input/output wiring
• A damaged converter module
• An excessive load on the output

The Board Works with USB but Not with Batteries

Measure the following voltages:

1. Battery-pack voltage without a load
2. Battery-pack voltage with the ESP32-S3 connected
3. MT3608 input voltage
4. MT3608 output voltage
5. ESP32-S3 3V3-pin voltage during startup

A reading of 3.3 V with no load does not guarantee that the converter can maintain 3.3 V during startup or Wi-Fi transmission.

The Battery Reading Is Too High or Too Low

Verify the actual resistor values and voltage-divider wiring. The battery-positive connection must come from the battery side of the MT3608. The ADC pin must connect to the junction of the two resistors. Average several ADC samples and compare the result with a multimeter. A small calibration factor can be added after testing:

batteryVoltage *= 1.03;

Use a correction factor based on measurements from your own board and resistor divider.

The Deep-Sleep Current Is Still High

The ESP32-S3 chip may be sleeping correctly while the rest of the circuit continues drawing current.

Check:

• ESP32-S3 power LED
• MT3608 indicator LED
• USB-to-UART circuitry
• MT3608 operating current
• Sensor standby current
• Battery voltage divider
• External pull-up resistors
• Other connected modules

Measure current at the battery holder so that the reading includes the entire circuit rather than only the ESP32-S3 board.

Conclusion

Powering an ESP32-S3 with AA batteries is possible using a properly adjusted MT3608 boost converter. Two alkaline or two NiMH AA cells provide a suitable input for the MT3608. The module raises the changing battery voltage to a regulated 3.3 V that can be applied to the ESP32-S3 board’s 3V3 pin. Before connecting the development board, always use a multimeter to adjust the MT3608 output to 3.3 V. Add a large capacitor close to the ESP32-S3 to support Wi-Fi current bursts, and avoid connecting USB and external 3.3 V power simultaneously unless the sources are properly isolated.

The MT3608 is a practical and affordable choice for prototypes. However, its operating current and any onboard indicator LED can reduce the runtime of a deep-sleep project. Applications intended to operate for many months should use a converter specifically designed for low-quiescent-current battery operation. Battery life will ultimately depend on how long the ESP32-S3 remains awake. By reading sensors quickly, keeping Wi-Fi sessions short, turning off peripherals, and entering deep sleep between measurements, an ESP32-S3 AA battery project can operate for weeks or potentially months.

The post How to Power an ESP32-S3 with AA Batteries appeared first on Teach Me Microcontrollers!.

The common IR proximity sensor module has an infrared LED, an IR receiver, a comparator IC, and a small potentiometer for adjusting the detection distance. Most modules only have three pins: VCC, GND, and OUT. Some versions also include an AO pin for analog output.

For this tutorial, we will first use the digital output pin, as it is the easiest way to detect an object using the ESP32.

ESP32 IR Proximity Sensor Wiring Diagram

The safest way to connect the IR sensor to the ESP32 is to power the sensor from the ESP32's 3.3V pin. Many IR sensor modules can run from 3.3V to 5V, but the ESP32 GPIO pins are 3.3V pins. Powering the module from 3.3V keeps the OUT signal at a safer voltage level for the ESP32.

Connect the sensor as follows:

For this example, I used GPIO 27 as the input pin. You can use other ESP32 GPIO pins, but avoid GPIO pins used for bootstrapping unless you know what you are doing. GPIO 34 to GPIO 39 are input-only pins, so they can also be used for reading sensor signals, but they cannot be used to drive LEDs or other output devices.

If your sensor has four pins, the pins are usually:

Use DO for simple object detection. Use AO only if you want to read a changing analog value.

Basic ESP32 IR Sensor Code

After wiring the sensor, upload this sketch to your ESP32:

#define IR_SENSOR_PIN 27

void setup() {
  Serial.begin(115200);
  pinMode(IR_SENSOR_PIN, INPUT);
}

void loop() {
  int sensorValue = digitalRead(IR_SENSOR_PIN);

  if (sensorValue == LOW) {
    Serial.println("Object detected");
  } else {
    Serial.println("No object");
  }

  delay(300);
}

Open the Serial Monitor and set the baud rate to 115200. Place your hand or any object in front of the IR sensor. You should see the message change from “No object” to “Object detected”.

Most IR obstacle sensors are active LOW. This means the output pin becomes LOW when the sensor detects an object. This is why the code checks:

if (sensorValue == LOW)

If your sensor behaves the opposite way, just reverse the condition.

Using an LED Indicator

The Serial Monitor is useful for testing, but sometimes it is better to see the sensor output using an LED. In this next example, we will turn on an LED connected to GPIO 26 whenever an object is detected.

Connect the LED as follows:

Here is the code:

#define IR_SENSOR_PIN 27
#define LED_PIN 26

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

  pinMode(IR_SENSOR_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  int sensorValue = digitalRead(IR_SENSOR_PIN);

  if (sensorValue == LOW) {
    Serial.println("Object detected");
    digitalWrite(LED_PIN, HIGH);
  } else {
    Serial.println("No object");
    digitalWrite(LED_PIN, LOW);
  }

  delay(300);
}

This is a simple setup, but it is already useful for testing object detection. You can replace the LED with a buzzer, relay module, or motor driver input depending on your project.

Adjusting the Detection Distance

Most IR proximity sensor modules have a small potentiometer. This potentiometer sets the reference voltage of the comparator circuit. In simpler terms, it adjusts how sensitive the sensor is.

Turn the potentiometer slowly while watching the Serial Monitor. If the sensor detects an object even when nothing is nearby, reduce the sensitivity. If it does not detect your hand or object, increase the sensitivity.

The detection distance depends on several things:

• color of the object
• reflectiveness of the surface
• angle of the object
• ambient light
• supply voltage
• sensor module quality

White or shiny objects are usually easier to detect because they reflect more infrared light. Black or matte objects may be harder to detect because they absorb more light.

Reading the Analog Output

Some IR proximity sensor modules include an AO pin. This pin gives an analog voltage that changes depending on the received IR light. If you want to read this value, connect the sensor like this:

GPIO 34 is a good choice for analog input because it is an input-only ADC pin.

Upload this code:

#define IR_ANALOG_PIN 34

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

  analogReadResolution(12); // ESP32 default: 0 to 4095
  analogSetPinAttenuation(IR_ANALOG_PIN, ADC_11db);
}

void loop() {
  int analogValue = analogRead(IR_ANALOG_PIN);

  Serial.print("IR analog value: ");
  Serial.println(analogValue);

  delay(300);
}

The ESP32 returns a value from 0 to 4095 by default when using 12-bit ADC resolution. A higher or lower value does not directly mean “distance in centimeters”. It only tells you that the received IR reflection changed.

If you need actual distance measurement, this sensor is not the best choice. Use it as a proximity or obstacle detector, not as an accurate distance sensor. For distance measurement, consider sensors such as the VL53L0X time-of-flight sensor or an ultrasonic sensor.

Simple ESP32 Web Server Example

Since we are using an ESP32, we can also display the sensor status on a web page. This is useful if you want to monitor the sensor wirelessly.

Replace the WiFi name and password with your own:

#include <WiFi.h>
#include <WebServer.h>

#define IR_SENSOR_PIN 27

const char* ssid = "YOUR_WIFI_NAME";
const char* password = "YOUR_WIFI_PASSWORD";

WebServer server(80);

String getSensorStatus() {
  int sensorValue = digitalRead(IR_SENSOR_PIN);

  if (sensorValue == LOW) {
    return "Object detected";
  } else {
    return "No object";
  }
}

void handleRoot() {
  String html = "<!DOCTYPE html><html>";
  html += "<head>";
  html += "<meta name='viewport' content='width=device-width, initial-scale=1'>";
  html += "<meta http-equiv='refresh' content='1'>";
  html += "<style>";
  html += "body{font-family:Arial;text-align:center;margin-top:50px;}";
  html += ".box{display:inline-block;padding:20px;border:1px solid #ccc;border-radius:8px;}";
  html += "</style>";
  html += "</head>";
  html += "<body>";
  html += "<div class='box'>";
  html += "<h2>ESP32 IR Proximity Sensor</h2>";
  html += "<h1>" + getSensorStatus() + "</h1>";
  html += "</div>";
  html += "</body></html>";

  server.send(200, "text/html", html);
}

void setup() {
  Serial.begin(115200);
  pinMode(IR_SENSOR_PIN, INPUT);

  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi");

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println();
  Serial.print("ESP32 IP Address: ");
  Serial.println(WiFi.localIP());

  server.on("/", handleRoot);
  server.begin();
}

void loop() {
  server.handleClient();
}

After uploading the code, open the Serial Monitor. Once the ESP32 connects to your WiFi network, it will print its IP address. Open that IP address in a browser connected to the same network.

The page refreshes every second and shows whether the sensor detects an object or not.

How the IR Proximity Sensor Works

The IR proximity sensor uses an infrared LED to transmit invisible light. When an object is in front of the sensor, some of this infrared light bounces back and reaches the IR receiver.

The module then compares the receiver signal against a reference level set by the potentiometer. This comparison is usually done by an LM393 comparator IC. If the reflected IR signal is strong enough, the comparator changes the state of the OUT pin.

This is why the output is digital. The ESP32 does not need to know the exact light intensity. It only reads whether the comparator output is HIGH or LOW.

The limitation is that the sensor depends heavily on reflection. A white surface may be detected farther away than a black surface. A shiny surface may give a stronger response than a dull one. Sunlight or strong ambient light may also affect the sensor.

Common Problems and Fixes

The sensor always says “Object detected”

Adjust the potentiometer slowly. The sensitivity may be too high. Also check if the sensor is facing a nearby surface such as the table or breadboard.

The sensor never detects anything

Check the wiring first. Make sure VCC goes to 3V3, GND goes to GND, and OUT goes to GPIO 27. Also try adjusting the potentiometer in the opposite direction.

The output is reversed

Some modules may behave differently. If your sensor prints “Object detected” when there is no object, change the condition from:

if (sensorValue == LOW)

to:

if (sensorValue == HIGH)

The ESP32 restarts or behaves strangely

Do not power the sensor from 5V and connect its OUT pin directly to the ESP32. The ESP32 uses 3.3V logic. If your module must be powered from 5V, use a voltage divider or a logic level shifter on the OUT pin.

The analog value is not stable

This is normal for simple IR modules. The reading can change because of hand movement, object color, surface angle, and ambient light. Take several readings and average them if you need a smoother value.

Final Thoughts

Connecting an IR proximity sensor with the ESP32 is straightforward if you use the digital output pin. The important thing is to remember that the sensor module and the ESP32 do not always use the same logic voltage. For beginner projects, power the IR sensor from the ESP32’s 3.3V pin and connect the OUT pin to a safe GPIO like GPIO 27.

This sensor is best used for simple object detection. It is not a precision distance sensor, but it works well for robot obstacle detection, counters, touchless triggers, and other projects where you only need to know if something is nearby.

The post How to Connect IR Proximity Sensor with ESP32 appeared first on Teach Me Microcontrollers!.

In this guide, I will walk you through the important parts: what the board is, which Arduino IDE board option to select, how to upload your first sketch, which pins are safe to use, and how to blink the ESP32-C3 Super Mini built-in LED pin.

If your board was sold as a Core ESP32-C3 board for Arduino, this guide should still help. Most of those small boards use the same ESP32-C3 chip and work with the same Arduino core.

What Is the ESP32-C3 Super Mini?

The ESP32-C3 Super Mini is a small development board based on Espressif’s ESP32-C3 microcontroller. Unlike the older and more common ESP32 boards, the ESP32-C3 does not use the dual-core Xtensa processor. Instead, it uses a single-core 32-bit RISC-V processor. For most Arduino projects, this difference is not something you need to worry about right away. Your digital outputs, analog inputs, Wi-Fi sketches, web servers, and sensor projects still work in the same familiar Arduino style.

The board gives you:

That combination makes it useful for compact IoT projects, sensor nodes, Wi-Fi buttons, BLE beacons, and small battery-powered experiments.

Why Use the ESP32-C3 Super Mini?

The biggest advantage is size. A full-size ESP32 DevKit board is easier to handle, but it takes up more space on a breadboard or inside an enclosure. The ESP32-C3 Super Mini gives you the main ESP32 features in a much smaller board.

I would use this board when:

However, I would not use it as my very first ESP32 board if I had no experience at all. The pins are closer together, the labeling can vary between sellers, and some GPIO pins have special boot behavior. It is still beginner-friendly, but you need to pay attention to the pinout.

ESP32-C3 Super Mini Specifications

Here are the typical specifications of an ESP32-C3 Super Mini board:

The flash size is usually 4 MB, but it is still worth checking your specific board. Some online listings reuse the same photos for slightly different versions.

ESP32-C3 Super Mini Board Layout

Most ESP32-C3 Super Mini boards have a USB-C connector on one end and the antenna on the other end. You will usually find two small buttons on the board:

• BOOT button
• RESET button

The BOOT button is useful when the board does not automatically enter upload mode. The RESET button simply restarts the board. You may also see a small LED near the center or side of the board. On many ESP32-C3 Super Mini boards, this LED is connected to GPIO8. This is the LED we will test later. One important layout note: keep the antenna area clear. Avoid placing metal parts, large wires, batteries, or copper areas directly under the antenna side of the board. The board may still work, but Wi-Fi range can suffer.

ESP32-C3 Super Mini Pinout

The exact ESP32-C3 Super Mini pinout can vary slightly depending on the manufacturer, but most boards expose a similar group of pins.

A common pinout looks like this:

Some boards also print SDA and SCL labels beside GPIO8 and GPIO9. That does not mean you must always use those pins for I2C. On the ESP32-C3, you can usually assign I2C to different GPIO pins in your code.

Pins You Should Be Careful With

This is the part that many beginners miss. Some ESP32-C3 pins are strapping pins. The chip checks these pins while booting. If your external circuit pulls one of these pins to the wrong level during reset, the board may fail to boot or fail to upload.

Be careful with these pins:

This does not mean you can never use these pins. You can. But for your first projects, it is better to start with less troublesome pins.

Best GPIO Pins for Beginner Projects

For simple LEDs, buttons, sensors, and digital outputs, I would start with:

For analog input, use:

For UART, many boards use:

• GPIO20 = RX
• GPIO21 = TX

For the built-in LED, try: GPIO8

If GPIO8 does not work on your board, try GPIO10. Some clone boards use a different LED pin.

Powering the ESP32-C3 Super Mini

The easiest way to power the board is through the USB-C connector.

You may also see 5V, 3V3, and GND pins on the board.

Here is what they mean:

• 5V is usually connected to the USB 5V line.
• 3V3 is the regulated 3.3V supply.
• GND is ground.

The ESP32-C3 itself is a 3.3V device. Its GPIO pins are not 5V tolerant. Do not connect a 5V signal directly to any GPIO pin. This is especially important when using modules like relays, ultrasonic sensors, or some older 5V Arduino modules. If a module outputs 5V, use a level shifter or voltage divider before connecting it to the ESP32-C3.

Installing ESP32-C3 Support in Arduino IDE

To program the ESP32-C3 Super Mini with Arduino IDE, you need to install the ESP32 board package.

Open Arduino IDE, then go to:

File > Preferences

Find Additional Boards Manager URLs and add this URL:

https://espressif.github.io/arduino-esp32/package_esp32_index.json

Then go to:

Tools > Board > Boards Manager

Search for: esp32

Then, install the package named: esp32 by Espressif Systems

After installation, restart Arduino IDE.

Which Board Should You Select?

For most ESP32-C3 Super Mini boards, select:

Tools > Board > esp32 > ESP32C3 Dev Module

This is the board option I would try first if your board is listed online as an ESP32-C3 Super Mini or Core ESP32-C3 board for Arduino.

Use these settings as a starting point:

The most important setting here is USB CDC On Boot. If this is disabled, your sketch may upload, but the Serial Monitor may not show anything through USB. If upload fails at 921600, lower the upload speed to 460800 or 115200.

First Sketch: Check If the Board Is Working

Before connecting sensors or LEDs, upload a simple serial test sketch.

void setup() {
  Serial.begin(115200);
  delay(2000);

  Serial.println();
  Serial.println("ESP32-C3 Super Mini test");

  Serial.print("Chip model: ");
  Serial.println(ESP.getChipModel());

  Serial.print("Chip revision: ");
  Serial.println(ESP.getChipRevision());

  Serial.print("CPU frequency: ");
  Serial.print(ESP.getCpuFreqMHz());
  Serial.println(" MHz");

  Serial.print("Flash size: ");
  Serial.print(ESP.getFlashChipSize() / (1024 * 1024));
  Serial.println(" MB");
}

void loop() {
  Serial.println("Board is running...");
  delay(1000);
}

Upload the sketch, then open the Serial Monitor at: 115200 baud. If you see the board information and the “Board is running...” message, your Arduino IDE setup is working. If you see nothing, press RESET once. Also check that USB CDC On Boot is enabled.

If Upload Does Not Work

Some ESP32-C3 Super Mini boards enter upload mode automatically. Others are a little stubborn.

If Arduino IDE gets stuck at “Connecting...”, try this:

1. Click Upload.
2. When you see “Connecting...”, hold the BOOT button.
3. Release BOOT once the upload starts.

If that still does not work, hold BOOT, tap RESET, then try uploading again. Also check the USB cable. A surprising number of upload problems are caused by charge-only USB-C cables.

ESP32-C3 Super Mini Built-In LED Pin

On many ESP32-C3 Super Mini boards, the built-in LED is connected to GPIO8. This LED is usually active LOW. That means the logic feels backward:

LOW = LED ON

HIGH = LED OFF

Upload this sketch to test the onboard LED:

#define LED_PIN 8

void setup() {
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_PIN, LOW);   // Turn LED ON
  delay(500);

  digitalWrite(LED_PIN, HIGH);  // Turn LED OFF
  delay(500);
}

If the onboard LED blinks, your board uses GPIO8 for the built-in LED. If nothing happens, try GPIO10:

#define LED_PIN 10

Some boards only have a power LED. If the LED turns on whenever the board is powered and never responds to your sketch, then it may not be connected to a GPIO pin.

Why the Built-In LED Pin Can Be Annoying

GPIO8 is convenient because it is often connected to the onboard LED. However, GPIO8 is also a strapping pin. For a simple blink test, this is not a big problem. But if you connect an external circuit to GPIO8, especially a circuit with a pull-up or pull-down resistor, it may affect the way the ESP32-C3 boots.

So here is the practical rule: Use GPIO8 for the onboard LED test. For external LEDs, buttons, and sensors, use another GPIO unless you have a reason to use GPIO8.

Testing Wi-Fi on the ESP32-C3 Super Mini

Once the board can upload sketches, the next useful test is Wi-Fi. The ESP32-C3 supports 2.4 GHz Wi-Fi. It does not connect to 5 GHz-only networks.

Upload this Wi-Fi scanner:

#include <WiFi.h>

void setup() {
  Serial.begin(115200);
  delay(2000);

  Serial.println();
  Serial.println("ESP32-C3 Wi-Fi scan");

  WiFi.mode(WIFI_STA);
  WiFi.disconnect();
  delay(100);

  int n = WiFi.scanNetworks();

  if (n == 0) {
    Serial.println("No networks found.");
  } else {
    Serial.print("Networks found: ");
    Serial.println(n);

    for (int i = 0; i < n; i++) {
      Serial.print(i + 1);
      Serial.print(": ");
      Serial.print(WiFi.SSID(i));
      Serial.print("  RSSI: ");
      Serial.print(WiFi.RSSI(i));
      Serial.println(" dBm");
      delay(10);
    }
  }
}

void loop() {
}

Open the Serial Monitor at 115200 baud. You should see nearby Wi-Fi networks. If the scan works, your Wi-Fi hardware is fine.

Connecting the ESP32-C3 Super Mini to Wi-Fi

Now try connecting to your router.

#include <WiFi.h>

const char* ssid = "YOUR_WIFI_NAME";
const char* password = "YOUR_WIFI_PASSWORD";

void setup() {
  Serial.begin(115200);
  delay(1000);

  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println();
  Serial.println("Wi-Fi connected!");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
}

void loop() {
}

Replace the Wi-Fi name and password with your own network credentials. If the board keeps failing to connect, check that your network is 2.4 GHz. Many routers combine 2.4 GHz and 5 GHz under one network name, which usually works, but a 5 GHz-only network will not.

Simple Web Server LED Control

Here is a small web server example that controls the built-in LED from a browser. This sketch assumes the onboard LED is on GPIO8 and active LOW.

#include <WiFi.h>
#include <WebServer.h>

const char* ssid = "YOUR_WIFI_NAME";
const char* password = "YOUR_WIFI_PASSWORD";

#define LED_PIN 8

WebServer server(80);

bool ledOn = false;

void handleRoot() {
  String html = "<!DOCTYPE html><html>";
  html += "<head>";
  html += "<meta name='viewport' content='width=device-width, initial-scale=1'>";
  html += "<style>";
  html += "body{font-family:Arial;text-align:center;margin-top:40px;}";
  html += "button{font-size:24px;padding:12px 24px;margin:10px;}";
  html += "</style>";
  html += "</head>";

  html += "<body>";
  html += "<h1>ESP32-C3 Super Mini LED</h1>";
  html += "<p>LED is ";
  html += ledOn ? "ON" : "OFF";
  html += "</p>";
  html += "<p><a href='/on'><button>ON</button></a></p>";
  html += "<p><a href='/off'><button>OFF</button></a></p>";
  html += "</body></html>";

  server.send(200, "text/html", html);
}

void handleOn() {
  ledOn = true;
  digitalWrite(LED_PIN, LOW);   // active-low LED ON
  handleRoot();
}

void handleOff() {
  ledOn = false;
  digitalWrite(LED_PIN, HIGH);  // active-low LED OFF
  handleRoot();
}

void setup() {
  Serial.begin(115200);
  delay(1000);

  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, HIGH);  // start with LED OFF

  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println();
  Serial.println("Wi-Fi connected!");
  Serial.print("Open this address in your browser: http://");
  Serial.println(WiFi.localIP());

  server.on("/", handleRoot);
  server.on("/on", handleOn);
  server.on("/off", handleOff);

  server.begin();
}

void loop() {
  server.handleClient();
}

After uploading, open the Serial Monitor and copy the IP address. Open that address in a browser connected to the same Wi-Fi network. This is a good first “real” ESP32-C3 project because it tests USB, serial output, Wi-Fi, GPIO, and a simple web page.

Using I2C on the ESP32-C3 Super Mini

Many ESP32-C3 Super Mini pinout diagrams show GPIO8 as SDA and GPIO9 as SCL. That can work, but I do not always recommend it for beginners because those pins have special boot behavior. A safer approach is to define the I2C pins yourself.

For example, you can try GPIO6 and GPIO7:

#include <Wire.h>

#define SDA_PIN 6
#define SCL_PIN 7

void setup() {
  Serial.begin(115200);
  delay(1000);

  Wire.begin(SDA_PIN, SCL_PIN);

  Serial.println("Scanning I2C bus...");

  for (byte address = 1; address < 127; address++) {
    Wire.beginTransmission(address);
    byte error = Wire.endTransmission();

    if (error == 0) {
      Serial.print("I2C device found at 0x");
      if (address < 16) Serial.print("0");
      Serial.println(address, HEX);
    }
  }

  Serial.println("Scan complete.");
}

void loop() {
}

If your OLED display or sensor is already wired to the pins labeled SDA and SCL on your board, change the pin definitions to match those labels.

For example:

#define SDA_PIN 8
#define SCL_PIN 9

Just remember that GPIO8 and GPIO9 are not the safest pins for every circuit.

Reading an Analog Sensor

The ESP32-C3 has analog input pins on GPIO0 to GPIO5. Here is a simple potentiometer test using GPIO0:

#define POT_PIN 0

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

void loop() {
  int value = analogRead(POT_PIN);

  Serial.print("ADC value: ");
  Serial.println(value);

  delay(300);
}

Wire the potentiometer like this:

Do not connect the potentiometer to 5V. The analog input pin should only receive a voltage between 0V and 3.3V.

Using UART on GPIO20 and GPIO21

Many ESP32-C3 Super Mini boards expose GPIO20 and GPIO21 as RX and TX. Typical wiring looks like this:

Here is a simple UART bridge sketch:

HardwareSerial MySerial(1);

#define RX_PIN 20
#define TX_PIN 21

void setup() {
  Serial.begin(115200);
  MySerial.begin(9600, SERIAL_8N1, RX_PIN, TX_PIN);

  Serial.println("UART test started");
}

void loop() {
  if (MySerial.available()) {
    Serial.write(MySerial.read());
  }

  if (Serial.available()) {
    MySerial.write(Serial.read());
  }
}

This is useful when testing GPS modules, serial sensors, or other microcontrollers. Again, check voltage levels. The ESP32-C3 uses 3.3V logic.

Common Problems and Fixes

The Board Does Not Show Up in Arduino IDE

Try another USB cable first. Make sure it is a data cable, not just a charging cable.

Then try:

• Another USB port
• Pressing RESET
• Holding BOOT while plugging in the board
• Restarting Arduino IDE
• Checking whether the port appears in Device Manager or your operating system’s serial device list

Most ESP32-C3 Super Mini boards use native USB, so they usually do not need a separate CH340 or CP210x driver. But clone boards can vary.

Upload Gets Stuck at “Connecting...”

Put the board into bootloader mode manually:

1. Hold BOOT.
2. Click Upload.
3. Release BOOT when upload starts.

If needed, hold BOOT, tap RESET, release RESET, then release BOOT.

Serial Monitor Is Blank

Check these settings:

• Serial Monitor baud rate is 115200.
• USB CDC On Boot is enabled.
• Correct port is selected.
• The sketch has Serial.begin(115200);.
• You added a short delay after Serial.begin().

This is one of the most common ESP32-C3 beginner issues.

The Built-In LED Does Not Blink

Try GPIO8 first, then GPIO10.

Also remember that many ESP32-C3 Super Mini boards use active-low LED wiring. So this turns the LED on:

digitalWrite(LED_PIN, LOW);

And this turns it off:

digitalWrite(LED_PIN, HIGH);

If the LED never responds, it may only be a power LED.

The Board Resets When Wi-Fi Starts

Wi-Fi needs short bursts of current. If the USB cable or port is weak, the board may reset when Wi-Fi turns on.

Try:

• A better USB cable
• A different USB port
• A powered USB hub
• Removing external loads from the 3.3V pin
• Powering external modules separately

Always connect grounds together when using an external power supply for sensors or modules.

Recommended First Projects

Once the board is working, these are good projects to try:

• Built-in LED blink
• Wi-Fi scanner
• Web server LED control
• OLED display using I2C
• BME280 weather monitor
• DHT22 temperature and humidity logger
• MQTT sensor node
• BLE beacon
• Deep sleep battery monitor
• UART GPS reader

The ESP32-C3 Super Mini is especially good for small connected projects where a full-size ESP32 board feels too large.

Frequently Asked Questions

What board should I select for ESP32-C3 Super Mini in Arduino IDE?

Select ESP32C3 Dev Module. This is the best starting option for most generic ESP32-C3 Super Mini boards.

Is the ESP32-C3 Super Mini compatible with Arduino?

Yes. Install the ESP32 board package by Espressif, then select ESP32C3 Dev Module in Arduino IDE.

What is the ESP32-C3 Super Mini built-in LED pin?

On many boards, the built-in LED is connected to GPIO8. It is usually active LOW, so writing LOW turns the LED on.

Why does my built-in LED not blink?

Your board may use a different LED pin, or the LED may only be a power indicator. Try GPIO8 first, then GPIO10.

Can I use GPIO8 and GPIO9?

Yes, but be careful. GPIO8 and GPIO9 are strapping pins. GPIO8 is often connected to the built-in LED, while GPIO9 is usually related to the BOOT button.

Can I connect 5V sensors to the ESP32-C3 Super Mini?

Only if the sensor output is 3.3V-compatible. The ESP32-C3 GPIO pins are not 5V tolerant. Use a level shifter when needed.

Does the ESP32-C3 support Bluetooth Classic?

No. The ESP32-C3 supports Bluetooth Low Energy, not Bluetooth Classic.

Can the ESP32-C3 Super Mini run MicroPython?

Yes. The board can run Arduino sketches, MicroPython, ESP-IDF projects, and PlatformIO projects. This guide focuses on Arduino IDE.

Conclusion

The ESP32-C3 Super Mini is a small but capable board for Wi-Fi and Bluetooth Low Energy projects. It is not as forgiving as a large ESP32 DevKit board because the pins are closer together and some GPIOs have boot functions, but it is still a very useful board once you understand the basics.

For a smooth start, remember these points:

• Select ESP32C3 Dev Module in Arduino IDE.
• Enable USB CDC On Boot.
• Use GPIO8 for the built-in LED on most boards.
• Remember that the built-in LED is usually active LOW.
• Be careful with GPIO2, GPIO8, and GPIO9.
• Do not connect 5V signals directly to any GPIO pin.

After you get the first blink and Wi-Fi test working, the ESP32-C3 Super Mini becomes a great board for compact IoT projects, web-controlled devices, and small wireless sensor builds.

The post ESP32-C3 Super Mini Getting Started Guide: Pinout, Arduino IDE Setup, and Built-In LED appeared first on Teach Me Microcontrollers!.