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 Microcontroller Tutorials.

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 Microcontroller Tutorials.

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 Microcontroller Tutorials.

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 Microcontroller Tutorials.

In this tutorial, you will learn how to set up an SSH server on ESP32 using the Arduino IDE. We will use the LibSSH-ESP32 library, generate the required SSH host key, connect the ESP32 to Wi-Fi, and log in from a terminal.

This project is useful if you want a safer remote command interface than plain Telnet. However, you should still treat it as a local-network tool, not as something to expose directly to the public internet.

What Is an SSH Server?

SSH means Secure Shell. It is a protocol used to open an encrypted command-line session between two devices.

In a normal SSH setup, a computer connects to a server like this:

ssh username@server_ip_address

For this project, the ESP32 becomes the SSH server. Your laptop, desktop PC, or phone becomes the SSH client.

Once connected, you can type commands into the SSH terminal. The ESP32 receives those commands and can respond with text, sensor readings, status messages, or control actions.

Why Use SSH on ESP32?

Most ESP32 projects use one of these interfaces:

• Serial Monitor through USB
• Web server page
• REST API
• MQTT
• Bluetooth serial
• Telnet-style TCP server

An SSH server is different because it provides an encrypted terminal session. That makes it useful for projects where you want remote diagnostics or command access without sending plain text over the network.

For example, an SSH server on ESP32 can be used for:

• Remote debugging
• Reading sensor values from a terminal
• Restarting parts of a program
• Viewing device status
• Controlling GPIO pins
• Sending simple maintenance commands
• Building a secure command console for an IoT device

However, SSH also uses more memory and processing power than a simple TCP server. For small projects, a web server or serial command interface may still be easier.

Parts Required

For this tutorial, you need:

• ESP32 development board
• USB cable
• Arduino IDE
• Wi-Fi network
• Computer with an SSH client

Most Linux and macOS systems already include the ssh command. On Windows 10 and Windows 11, OpenSSH is usually available from PowerShell or Command Prompt.

You can check by opening a terminal and typing:

ssh

If you see SSH usage information, your computer already has an SSH client.

Installing the ESP32 Board Package

Before using the ESP32, install the ESP32 board package in the Arduino IDE.

Open Arduino IDE, then go to:

File > Preferences

Add this URL to the Additional Boards Manager URLs field:

https://espressif.github.io/arduino-esp32/package_esp32_index.json

Then go to:

Tools > Board > Boards Manager

Search for:

esp32

Install the package by Espressif Systems.

After installation, select your ESP32 board from:

Tools > Board > esp32

For most ESP32-WROOM development boards, select:

ESP32 Dev Module

Installing the LibSSH-ESP32 Library

Next, install the SSH library.

In Arduino IDE, go to:

Sketch > Include Library > Manage Libraries

Search for:

LibSSH-ESP32

Install the library.

This library is a port of libssh for ESP32. It includes examples for SSH server, SSH client, SCP, key generation, and OTA-style file transfer.

How the ESP32 SSH Server Works

The ESP32 SSH server needs three main parts:

1. Wi-Fi connection
2. SSH host key
3. SSH server task

The Wi-Fi connection allows the ESP32 to join your local network.

The SSH host key identifies the ESP32 to the SSH client. This is different from the username and password. The host key lets your computer recognize the ESP32 if you connect again later.

The SSH server task listens for incoming SSH connections, handles authentication, and opens a terminal channel.

Generate the SSH Host Key

Before starting the SSH server, the ESP32 needs a host key. The LibSSH-ESP32 library includes a key generation example.

Open:

File > Examples > LibSSH-ESP32 > keygen2

Upload the sketch to your ESP32.

Open the Serial Monitor and set the baud rate to:

115200

The sketch will mount SPIFFS and generate an SSH key. If the Serial Monitor asks whether to format SPIFFS, type:

y

Then press Enter.

Formatting SPIFFS erases files stored in the ESP32 flash file system, so do this only on a test board or when you do not need the existing SPIFFS files.

The key generation sketch usually creates a key file inside the ESP32 file system. The SSH server example will use this file as the host key.

Upload the SSH Server Example

After generating the key, open the SSH server example:

File > Examples > LibSSH-ESP32 > samplesshd-kbdint

Find the Wi-Fi credentials near the top of the sketch:

const char *configSTASSID = "YourWiFiSSID";
const char *configSTAPSK = "YourWiFiPSK";

Change them to match your Wi-Fi network:

const char *configSTASSID = "YourNetworkName";
const char *configSTAPSK = "YourNetworkPassword";

Upload the sketch to your ESP32.

Open the Serial Monitor at 115200 baud. After the ESP32 connects to Wi-Fi, it should print its IP address.

For example:

% WiFi connected
% IPv4 Address: 192.168.1.45
Started sample libssh sshd on port 22

Write down the IP address because you will use it to connect through SSH.

Logging In to the ESP32 with SSH

Open a terminal on your computer.

Use this command:

ssh libssh@192.168.1.45

Replace

192.168.1.45

When asked for a password, enter:

libssh

The default example username and password are:

Username: libssh
Password: libssh

If this is your first time connecting to the ESP32, your computer may show a message like this:

The authenticity of host '192.168.1.45' can't be established.
Are you sure you want to continue connecting?

Type:

yes

Then press Enter.

You should now have an SSH session connected to the ESP32.

Testing the SSH Connection

The sample SSH server behaves like a simple echo terminal. When you type text, the ESP32 sends the text back through the encrypted SSH channel.

Try typing:

hello esp32

The ESP32 should echo the text back.

This proves that:

• The ESP32 joined your Wi-Fi network
• The SSH server started correctly
• Your computer connected to the ESP32 through SSH
• Authentication worked
• The SSH channel is working

Turning the Example into a Command Server

The default SSH server example is only a starting point. For a practical project, you can modify the part of the code that reads incoming characters from the SSH channel.

A simple command interface can support commands like:

status
led on
led off
restart

For example, the ESP32 can check the received text and respond with a message.

Conceptually, the command handler can work like this:

String handleCommand(String cmd) {
  cmd.trim();

  if (cmd == "status") {
    return "ESP32 is running\r\n";
  }

  if (cmd == "led on") {
    digitalWrite(2, HIGH);
    return "LED turned ON\r\n";
  }

  if (cmd == "led off") {
    digitalWrite(2, LOW);
    return "LED turned OFF\r\n";
  }

  if (cmd == "help") {
    return "Commands: status, led on, led off, help\r\n";
  }

  return "Unknown command. Type help.\r\n";
}

Then, when a complete line arrives from the SSH channel, pass it to

handleCommand()

This approach turns the ESP32 SSH server into a secure remote console.

Example Command Ideas

Here are some useful commands you can add to your ESP32 SSH server:

For an IoT project, the status command is one of the most useful commands to add first.

Example response:

Uptime: 923 seconds
Free heap: 183420 bytes
WiFi RSSI: -54 dBm
IP: 192.168.1.45

Adding a Status Command

You can use standard Arduino and ESP32 functions to get basic system information.

For example:

String getStatus() {
  String msg;

  msg += "ESP32 Status\r\n";
  msg += "Uptime: ";
  msg += String(millis() / 1000);
  msg += " seconds\r\n";

  msg += "Free heap: ";
  msg += String(ESP.getFreeHeap());
  msg += " bytes\r\n";

  msg += "WiFi RSSI: ";
  msg += String(WiFi.RSSI());
  msg += " dBm\r\n";

  msg += "IP address: ";
  msg += WiFi.localIP().toString();
  msg += "\r\n";

  return msg;
}

Then your command handler can call this function:

if (cmd == "status") {
  return getStatus();
}

Now, when you connect through SSH and type:

status

The ESP32 can return live system information.

Changing the Default Username and Password

Do not keep the default login credentials in your final project.

Look for the username and password definitions in the SSH server example. They usually look similar to this:

#define SSHD_USER "libssh"
#define SSHD_PASSWORD "libssh"

Change them to something else:

#define SSHD_USER "esp32admin"
#define SSHD_PASSWORD "ChangeThisPassword123"

Use a long password, especially if the ESP32 will run on a shared network.

Again, do not expose this ESP32 SSH server directly to the internet. If you need remote access outside your home or lab network, use a VPN such as WireGuard or Tailscale instead.

Troubleshooting

The ESP32 Does Not Connect to Wi-Fi

Check the SSID and password in the sketch.

Also make sure your ESP32 is connecting to a 2.4 GHz Wi-Fi network. Most ESP32 boards do not connect to 5 GHz Wi-Fi.

The SSH Command Times Out

If the SSH client times out, check these items:

• The ESP32 IP address is correct
• Your computer and ESP32 are on the same network
• The ESP32 Serial Monitor says the SSH server started
• Your router does not block client-to-client communication
• The ESP32 did not restart due to a power issue

You can also try pinging the ESP32:

ping 192.168.1.45

Replace the IP address with your ESP32 address.

The SSH Client Shows a Host Key Warning

If you regenerate the ESP32 host key, your computer may warn you that the host key changed.

This can happen during development. Remove the old host entry from your computer’s known_hosts file, then connect again.

On many systems, you can use:

ssh-keygen -R 192.168.1.45

Then connect again:

ssh libssh@192.168.1.45

The ESP32 Restarts or Crashes

SSH needs more memory than a basic web server or TCP server. If the ESP32 crashes, try these fixes:

• Use a stable USB power source
• Close other memory-heavy tasks
• Avoid large buffers
• Test with a basic ESP32 board first
• Use an ESP32 module with PSRAM if your project is large
• Avoid running camera, Bluetooth, web server, and SSH all at once unless you have enough memory

Port 22 Does Not Work

Port 22 is the standard SSH port. However, some networks may block it.

For local testing, you can change the SSH server port in the sketch if the example allows it.

For example, you might use:

2222

Then connect with:

ssh -p 2222 libssh@192.168.1.45

Security Notes

SSH is encrypted, but your ESP32 project is still only as secure as your implementation.

Follow these rules:

• Change the default username and password
• Do not expose the ESP32 SSH server to the internet
• Use a strong Wi-Fi password
• Limit commands to only what your project needs
• Do not add dangerous commands without confirmation
• Avoid printing secrets in the SSH terminal
• Disable the SSH server when not needed
• Prefer key-based login for serious projects

For hobby and lab projects, an ESP32 SSH server is best used on a trusted local network.

Arduino IDE vs ESP-IDF

This tutorial focuses on Arduino IDE because it is easier for beginners and fits most ESP32 hobby projects.

However, if you are already using ESP-IDF, there are ESP-IDF components that provide a more integrated SSH console experience. Some components can expose ESP-IDF console commands over SSH, which makes them useful for professional firmware debugging.

Use Arduino IDE if you want a fast starting point.

Use ESP-IDF if you want deeper control, command registration, and a more production-style console.

Project Ideas Using an ESP32 SSH Server

Once the SSH server is working, you can build projects such as:

• Remote GPIO control terminal
• Secure sensor monitor
• Wi-Fi relay controller
• ESP32 diagnostics shell
• Remote reboot tool
• Secure serial-to-SSH bridge
• Lab instrument command console
• Local IoT maintenance port

For example, a greenhouse controller can use an SSH command such as:

status

Then return:

Temperature: 29.4 C
Humidity: 71 %
Soil moisture: 48 %
Pump: OFF
Fan: ON

This gives you a simple maintenance interface without building a full web dashboard.

Conclusion

Running an SSH server on ESP32 gives your microcontroller a secure remote terminal over Wi-Fi. With the LibSSH-ESP32 library, you can start from the included SSH server example, connect to the ESP32 from a computer, and then build your own command interface.

For most beginner projects, a web server is still easier. However, if you want terminal-style control, encrypted communication, and remote diagnostics, an ESP32 SSH server is a powerful option.

Start with the sample SSH server, change the default credentials, add a few safe commands, and test everything on your local network before using it in a real project.

Frequently Asked Questions

Can ESP32 run an SSH server?

Yes. The ESP32 can run an SSH server using libraries such as LibSSH-ESP32. However, SSH uses more memory and processing power than simple serial, Telnet, or web server examples.

Is SSH better than Telnet on ESP32?

SSH is more secure because it encrypts the connection. Telnet sends data in plain text. If you only need a quick private lab test, Telnet is simpler. If you want encrypted terminal access, use SSH.

Can I SSH into ESP32 from Windows?

Yes. Open PowerShell or Command Prompt and use the ssh command:

ssh username@esp32_ip_address

Windows 10 and Windows 11 usually include OpenSSH by default.

Can I expose my ESP32 SSH server to the internet?

You should not expose it directly to the public internet. Use it on a local network. For remote access, use a VPN instead.

What is the default username and password for the LibSSH-ESP32 example?

The sample server may use libssh as the username and libssh as the password. Change these credentials before using the project beyond basic testing.

Does ESP32-S3 also support an SSH server?

Yes, LibSSH-ESP32 lists support for ESP32 variants including ESP32-S3. However, always check the current library notes and test your specific board because memory availability and board support can vary.

The post How to Run an SSH Server on ESP32 appeared first on Microcontroller Tutorials.

If you are coming from an Arduino UNO, ESP8266, or classic ESP32 board, the ESP32-S3 can look familiar at first. It still uses GPIO pins, 3.3V logic, serial communication, PWM, I2C, SPI, and ADC inputs. But there are also important differences. Some ESP32-S3 boards have native USB. Some have PSRAM. Some have two USB ports. Some use different onboard LED pins. Some pins are connected internally to flash or PSRAM and should not be used for normal I/O.

This guide explains the ESP32-S3 in a practical and beginner-friendly manner. We will examine the ESP32-S3, its comparison to the older ESP32, how to install it in the Arduino IDE, which pins are safe to use, how USB communication works, and how to upload your first sketch.

What is the ESP32-S3?

The ESP32-S3 is a Wi-Fi and Bluetooth Low Energy microcontroller from Espressif. It is part of the ESP32 family, but it is not just a direct replacement for the original ESP32. It is a newer chip designed for connected embedded projects, USB devices, low-power IoT products, display projects, camera projects, and edge AI applications.

Common ESP32-S3 features include:

The exact features depend on the specific ESP32-S3 module or development board. For example, an ESP32-S3-WROOM board may expose different pins from a compact XIAO ESP32-S3 or ESP32-S3 Zero-style board. Always check the pinout of your exact board before wiring external components.

ESP32-S3 vs ESP32: What is Different?

The ESP32-S3 and the original ESP32 are both powerful Wi-Fi microcontrollers, but they are not identical.

The biggest practical difference for beginners is USB. Many classic ESP32 development boards use a USB-to-serial converter chip. On many ESP32-S3 boards, the USB port can connect directly to the microcontroller. This allows USB CDC serial, USB flashing, USB HID, USB MIDI, and other USB device projects.

However, this also creates confusion. In the Arduino IDE, you may need to enable the correct USB options before the Serial Monitor works properly.

Common ESP32-S3 Development Boards

There are many ESP32-S3 boards, and their pinouts are not always the same. Some common examples include:

When following a tutorial, make sure the selected board in the Arduino IDE matches your actual hardware as closely as possible.

ESP32-S3 Board Names: What Do N8R8 and N16R8 Mean?

You may see ESP32-S3 boards labeled as N8R8, N16R8, N8, N16, or similar names. These labels usually describe the memory configuration.

For example:

This matters because the Arduino IDE has board options for flash size, partition scheme, and PSRAM. If you select the wrong PSRAM setting, some sketches may fail or behave unpredictably, especially camera, display, or AI projects.

ESP32-S3 Pinout Basics

Click on the pins below to view information:

The ESP32-S3 has many GPIO pins, but not every pin is equally safe for beginner projects. Some pins are used for boot configuration. Some may be connected to flash or PSRAM. Some may not be exposed on your board. Some may already be used by onboard LEDs, buttons, displays, cameras, or USB circuits.

A safe beginner approach is:

• Use clearly labeled GPIO pins from your board’s pinout.
• Avoid flash/PSRAM-related pins.
• Be careful with strapping pins.
• Do not connect 5V signals directly to ESP32-S3 GPIO pins.
• Check whether your board already uses a pin for an LED, button, camera, display, or microSD card.

ESP32-S3 Pins to Be Careful With

The exact safe pins depend on your board, but these are common ESP32-S3 pin cautions:

This is one reason ESP32-S3 tutorials can be confusing. A sketch that works on one ESP32-S3 board may not work on another if the LED pin, USB wiring, or PSRAM pins are different.

Recommended ESP32-S3 Pins for Beginner Projects

For simple digital input/output, PWM, sensors, and modules, start with pins that are exposed on your board and not reserved by onboard hardware.

Commonly usable pins on many ESP32-S3 development boards include:

Do not assume that all ESP32-S3 boards have the same built-in LED pin. Some boards use a normal single-color LED. Some use an addressable RGB LED. Some do not have a user LED at all.

ESP32-S3 Logic Level and Power

The ESP32-S3 is a 3.3V microcontroller. This means its GPIO pins are designed for 3.3V logic, not 5V logic.

Important power rules:

For sensors, always check whether the module supports 3.3V logic. Many I2C sensor modules work at 3.3V, but some 5V modules need level shifting.

Installing ESP32-S3 in the Arduino IDE

The easiest way to start using the ESP32-S3 is through the Arduino IDE.

Step 1: Install the Arduino IDE

Download and install the latest Arduino IDE from the official Arduino website.

Step 2: Add the ESP32 Board Package

Open Arduino IDE, then go to:

File > Preferences

In Additional Boards Manager URLs, add the ESP32 board package URL from Espressif.

Then go to:

Tools > Board > Boards Manager

Search for:

esp32

Install the package by Espressif Systems.

Step 3: Select an ESP32-S3 Board

Go to:

Tools > Board > ESP32 Arduino

Then select the board that best matches your hardware. Common options include:

ESP32S3 Dev Module
ESP32-S3-DevKitC-1
XIAO_ESP32S3

The exact board list depends on your installed ESP32 Arduino core version.

If your specific board is not listed, ESP32S3 Dev Module often works for generic ESP32-S3 boards, but you may need to manually configure flash size, PSRAM, USB mode, and upload options.

Important Arduino IDE Settings for ESP32-S3

ESP32-S3 boards have more board settings than an Arduino UNO. The most important ones are:

For many ESP32-S3 boards, if your sketch uploads but the Serial Monitor shows nothing, check USB CDC On Boot. In many cases, it must be enabled for Serial.print() to appear over the native USB port.

First ESP32-S3 Blink Sketch

The Blink sketch is usually the first test for any microcontroller board. However, ESP32-S3 boards do not all use the same onboard LED pin.

Try this sketch first:

#ifndef LED_BUILTIN
#define LED_BUILTIN 48
#endif

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

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

Upload the sketch. If the onboard LED does not blink, your board may use a different LED pin.

Try replacing the LED pin with one of these common ESP32-S3 onboard LED pins:

#define LED_BUILTIN 48

or:

#define LED_BUILTIN 38

or:

#define LED_BUILTIN 15

If your board has an addressable RGB LED, a simple digitalWrite() blink sketch may not work. Addressable LEDs usually need a library such as Adafruit NeoPixel or FastLED.

ESP32-S3 Serial Monitor Test

After Blink, test the Serial Monitor.

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

  Serial.println("ESP32-S3 Serial test");
}

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

Open the Serial Monitor and set the baud rate to:

115200

If nothing appears, check these:

1. Is the correct port selected?
2. Is USB CDC On Boot enabled?
3. Are you using the correct USB port on the board?
4. Did you press reset after opening Serial Monitor?
5. Is the board selected correctly?
6. Are you using a charge-only USB cable?

Many ESP32-S3 upload and serial problems are caused by USB settings or USB cables.

ESP32-S3 Native USB Explained

One of the best reasons to use the ESP32-S3 is native USB support. Depending on your board and firmware, the ESP32-S3 can act as a USB device.

This opens up projects such as:

• USB keyboard
• USB mouse
• USB MIDI device
• USB serial device
• USB firmware flashing
• USB HID controller
• USB-based debugging
• USB host projects on supported boards

Some ESP32-S3 development boards have two USB ports:

On boards with two USB ports, make sure you know which port you are using. One port may be better for simple Arduino uploads, while the other may be used for native USB examples.

Reading a Button with ESP32-S3

Here is a simple button example using the internal pull-up resistor.

Connect one side of the button to the selected GPIO pin and the other side to GND.

const int buttonPin = 4;

void setup() {
  Serial.begin(115200);
  pinMode(buttonPin, INPUT_PULLUP);
}

void loop() {
  int buttonState = digitalRead(buttonPin);

  if (buttonState == LOW) {
    Serial.println("Button pressed");
  } else {
    Serial.println("Button released");
  }

  delay(200);
}

Because the internal pull-up is enabled, the pin reads HIGH when the button is not pressed and LOW when the button is pressed.

Fading an LED with PWM on ESP32-S3

The ESP32-S3 can generate PWM signals on many output-capable GPIO pins. Here is a simple LED fade example.

Connect an LED with a current-limiting resistor to a safe GPIO pin.

const int ledPin = 5;

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

void loop() {
  for (int brightness = 0; brightness <= 255; brightness++) {
    analogWrite(ledPin, brightness);
    delay(5);
  }

  for (int brightness = 255; brightness >= 0; brightness--) {
    analogWrite(ledPin, brightness);
    delay(5);
  }
}

If your ESP32 Arduino core does not support analogWrite() for your selected board/core version, use the LEDC PWM functions instead.

Reading an Analog Sensor

The ESP32-S3 has analog input pins, but you must use pins that are ADC-capable on your specific board.

Here is a simple analog read example:

const int analogPin = 1;

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

void loop() {
  int value = analogRead(analogPin);

  Serial.print("ADC value: ");
  Serial.println(value);

  delay(500);
}

For a potentiometer:

• One outer pin goes to 3.3V
• The other outer pin goes to GND
• The middle pin goes to an ADC-capable GPIO

Do not connect the potentiometer to 5V if its wiper goes into an ESP32-S3 GPIO pin.

Using I2C with ESP32-S3

Unlike the Arduino UNO, the ESP32-S3 can usually assign I2C to different GPIO pins. That means SDA and SCL are often flexible.

Example I2C scanner:

#include <Wire.h>

#define SDA_PIN 8
#define SCL_PIN 9

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

  Wire.begin(SDA_PIN, SCL_PIN);

  Serial.println("ESP32-S3 I2C Scanner");
}

void loop() {
  byte error, address;
  int devices = 0;

  for (address = 1; address < 127; address++) {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();

    if (error == 0) {
      Serial.print("I2C device found at 0x");
      if (address < 16) {
        Serial.print("0");
      }
      Serial.println(address, HEX);
      devices++;
    }
  }

  if (devices == 0) {
    Serial.println("No I2C devices found");
  }

  delay(5000);
}

If the scanner finds no devices, check the wiring, I2C address, power, and pull-up resistors.

Common ESP32-S3 Upload Problems

Problem: Arduino IDE Cannot Find the Board

Try these fixes:

• Use a data-capable USB cable.
• Try another USB port.
• Install the ESP32 board package.
• Hold BOOT while clicking Upload.
• Press RESET after upload starts.
• Try the other USB port if your board has two ports.

Problem: Upload Starts But Fails

Possible causes:

• Wrong board selected
• Wrong upload mode
• Bad USB cable
• BOOT button not pressed when needed
• Driver issue for USB-to-serial converter
• Wrong port selected
• External circuit pulling a boot pin to the wrong level

Disconnect external wiring while troubleshooting upload problems. A sensor or module connected to a strapping pin can prevent the ESP32-S3 from booting or entering upload mode.

Problem: Serial Monitor Shows Nothing

Try these:

• Enable USB CDC On Boot
• Select the correct port
• Set Serial Monitor to 115200 baud
• Press RESET after opening Serial Monitor
• Use the correct USB connector
• Make sure the sketch uses Serial.begin(115200);

Problem: Built-in LED Does Not Blink

Possible causes:

• Wrong LED pin
• Board uses addressable RGB LED
• Board has no onboard user LED
• LED is active-low
• Selected board definition uses a different LED_BUILTIN

Check your board’s schematic or product page.

Problem: PSRAM Sketch Fails

If your board has PSRAM, enable PSRAM in the Arduino IDE. If your board does not have PSRAM, do not enable it.

Camera, display, graphics, and AI examples often require PSRAM.

ESP32-S3 Project Ideas

Once you have the ESP32-S3 working, here are some good project ideas:

ESP32-S3 Beginner Tips

1. Do not assume all ESP32-S3 boards have the same pinout.
   Always check your exact board.
2. Use 3.3V logic.
   ESP32-S3 GPIO pins are not 5V tolerant.
3. Avoid flash and PSRAM pins.
   Some GPIO pins are used internally and should not be used for external circuits.
4. Be careful with boot pins.
   External pull-ups, pull-downs, LEDs, or modules can affect boot mode.
5. Check USB CDC settings.
   Many Serial Monitor issues are caused by USB configuration.
6. Know your board’s memory.
   Flash and PSRAM settings matter for larger projects.
7. Start simple.
   Test Blink, Serial, button input, PWM, and I2C before building a complex project.

Frequently Asked Questions

Is ESP32-S3 better than ESP32?

For many new projects, yes. The ESP32-S3 has native USB support, modern BLE support, and features useful for AI and signal processing. However, the original ESP32 still has Bluetooth Classic support, which the ESP32-S3 does not have. If your project needs Bluetooth Classic audio or serial Bluetooth, check compatibility first.

Does ESP32-S3 support Bluetooth Classic?

No. The ESP32-S3 supports Bluetooth Low Energy, but not Bluetooth Classic. This is important if you are using old ESP32 Bluetooth Serial examples.

Can I program ESP32-S3 with Arduino IDE?

Yes. Install the ESP32 board package by Espressif in the Arduino IDE, select an ESP32-S3 board, choose the correct port, and upload your sketch.

Why is my ESP32-S3 Serial Monitor blank?

The most common causes are wrong port selection, USB CDC disabled, wrong USB connector, missing Serial.begin(), or a charge-only USB cable.

What is the ESP32-S3 built-in LED pin?

It depends on the board. Some ESP32-S3 boards use GPIO48, others use GPIO38 or GPIO15, and some use an addressable RGB LED or no user LED at all.

Can ESP32-S3 use 5V sensors?

The ESP32-S3 itself uses 3.3V logic. Some sensor modules can be powered by 5V but still output 3.3V signals, while others output 5V signals. Do not connect a 5V signal directly to an ESP32-S3 GPIO pin.

Which ESP32-S3 board should beginners buy?

A general ESP32-S3 DevKit-style board is a good starting point because it exposes many pins and is easier to use on a breadboard. If you want camera or TinyML projects, choose a board with PSRAM and camera support.

Conclusion

The ESP32-S3 is a powerful upgrade for many ESP32 projects, especially if you want native USB, BLE, more memory options, camera support, display projects, or TinyML experiments. It is still beginner-friendly, but it has more board-specific details than an Arduino UNO or even a classic ESP32.

The most important things to remember are:

• Select the correct ESP32-S3 board in the Arduino IDE.
• Use the correct USB CDC and upload settings.
• Check the actual pinout of your board.
• Avoid pins used by flash, PSRAM, USB, or boot configuration.
• Use 3.3V logic only.
• Do not assume the onboard LED pin is the same on every ESP32-S3 board.

Once you understand these details, the ESP32-S3 becomes one of the most flexible microcontroller boards for Wi-Fi, BLE, USB, sensor, display, and embedded AI projects.

The post ESP32-S3 Getting Started Guide: Pinout, Arduino IDE, USB, and First Project appeared first on Microcontroller Tutorials.

One of the most useful libraries for this is the ESP32 Async Web Server library. Unlike a basic web server that handles one request at a time in a more blocking way, an asynchronous web server can respond to browser requests more efficiently while your ESP32 continues running the rest of your program.

In this tutorial, you will learn how to use an ESP32 Async Web Server event handler. We will start with simple route handlers, then control an LED from a web page, handle missing pages with onNotFound(), and finally use Server-Sent Events to push live data from the ESP32 to the browser.

What Is an ESP32 Async Web Server Event Handler?

In an ESP32 Async Web Server sketch, an event handler is a callback function that runs when something happens.

For example:

• A browser requests the homepage
• A user clicks a button on the webpage
• The browser requests a URL like /led/on
• A page is not found
• The ESP32 sends live sensor data to the browser

In the ESPAsyncWebServer library, the most common event handlers are route handlers. A route handler tells the ESP32 what to do when a specific URL is requested.

For example:

server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
  request->send(200, "text/plain", "Hello from ESP32!");
});

This handler runs when a browser visits the root URL /.

Required Libraries

For this tutorial, you need:

• ESP32 board package installed in Arduino IDE
• ESPAsyncWebServer library
• AsyncTCP library

In Arduino IDE, install the required libraries using the Library Manager or by adding the libraries manually from their repositories.

You will also need an ESP32 development board such as an ESP32 DevKit, ESP32-WROOM board, or similar.

Circuit Diagram

For the example project, connect one LED to the ESP32.

Most ESP32 development boards also have a built-in LED, but the pin can vary depending on the board. GPIO 2 is commonly used in examples, but check your specific board if the LED does not turn on.

Use a 220 ohm to 330 ohm resistor in series with the LED.

Basic ESP32 Async Web Server Example

Let us start with a very simple Async Web Server sketch.

Replace YOUR_WIFI_SSID and YOUR_WIFI_PASSWORD with your Wi-Fi credentials.

#include <WiFi.h>
#include <AsyncTCP.h>
#include <ESPAsyncWebServer.h>

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

AsyncWebServer server(80);

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

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

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

  Serial.println();
  Serial.print("Connected! IP address: ");
  Serial.println(WiFi.localIP());

  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
    request->send(200, "text/plain", "Hello from ESP32 Async Web Server!");
  });

  server.begin();
}

void loop() {
}

Upload the sketch to your ESP32 and open the Serial Monitor. After the ESP32 connects to Wi-Fi, it will print its IP address.

Open that IP address in your browser. You should see:

Hello from ESP32 Async Web Server!

Notice that the loop() is empty. With ESPAsyncWebServer, you do not need to call server.handleClient() inside the loop.

Handling Web Page Requests

The most common use of an event handler is responding to a page request.

This line creates a handler for the homepage:

server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
  request->send(200, "text/plain", "Hello from ESP32!");
});

Here is what each part means:

You can add more routes like this:

server.on("/status", HTTP_GET, [](AsyncWebServerRequest *request) {
  request->send(200, "text/plain", "ESP32 is running");
});

server.on("/about", HTTP_GET, [](AsyncWebServerRequest *request) {
  request->send(200, "text/plain", "ESP32 Async Web Server Tutorial");
});

When the browser visits /status, the ESP32 responds with ESP32 is running.

ESP32 Async Web Server LED Control Example

Now let us make a web page with two buttons: one to turn the LED on and another to turn it off.

#include <WiFi.h>
#include <AsyncTCP.h>
#include <ESPAsyncWebServer.h>

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

const int ledPin = 2;
bool ledState = false;

AsyncWebServer server(80);

const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE html>
<html>
<head>
  <title>ESP32 Async Web Server</title>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <style>
    body {
      font-family: Arial;
      text-align: center;
      margin-top: 50px;
    }

    button {
      font-size: 20px;
      padding: 12px 24px;
      margin: 10px;
      cursor: pointer;
    }

    .on {
      background-color: #4CAF50;
      color: white;
    }

    .off {
      background-color: #f44336;
      color: white;
    }
  </style>
</head>
<body>
  <h1>ESP32 Async Web Server</h1>
  <p>LED State: <span id="ledState">Unknown</span></p>

  <button class="on" onclick="controlLED('on')">Turn ON</button>
  <button class="off" onclick="controlLED('off')">Turn OFF</button>

  <script>
    function controlLED(state) {
      fetch('/led/' + state)
        .then(response => response.text())
        .then(data => {
          document.getElementById('ledState').innerText = data;
        });
    }
  </script>
</body>
</html>
)rawliteral";

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

  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);

  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("/", HTTP_GET, [](AsyncWebServerRequest *request) {
    request->send_P(200, "text/html", index_html);
  });

  server.on("/led/on", HTTP_GET, [](AsyncWebServerRequest *request) {
    ledState = true;
    digitalWrite(ledPin, HIGH);
    request->send(200, "text/plain", "ON");
  });

  server.on("/led/off", HTTP_GET, [](AsyncWebServerRequest *request) {
    ledState = false;
    digitalWrite(ledPin, LOW);
    request->send(200, "text/plain", "OFF");
  });

  server.begin();
}

void loop() {
}

In this example, the web page does not reload when you click the buttons. The browser uses fetch() to send a request to the ESP32.

When you click the ON button, the browser requests:

/led/on

The ESP32 runs this event handler:

server.on("/led/on", HTTP_GET, [](AsyncWebServerRequest *request) {
  ledState = true;
  digitalWrite(ledPin, HIGH);
  request->send(200, "text/plain", "ON");
});

When you click the OFF button, the browser requests:

/led/off

The ESP32 then turns the LED off and sends a response back to the browser.

Handling URL Parameters

You can also send values through the URL. For example:

/set?led=on

Here is an example handler:

server.on("/set", HTTP_GET, [](AsyncWebServerRequest *request) {
  if (request->hasParam("led")) {
    String value = request->getParam("led")->value();

    if (value == "on") {
      digitalWrite(ledPin, HIGH);
      request->send(200, "text/plain", "LED turned ON");
    } 
    else if (value == "off") {
      digitalWrite(ledPin, LOW);
      request->send(200, "text/plain", "LED turned OFF");
    } 
    else {
      request->send(400, "text/plain", "Invalid LED value");
    }
  } 
  else {
    request->send(400, "text/plain", "Missing led parameter");
  }
});

Now you can control the LED using these URLs:

http://ESP32-IP-ADDRESS/set?led=on
http://ESP32-IP-ADDRESS/set?led=off

This is useful when you want to pass values such as PWM brightness, servo angle, relay state, or sensor settings.

Using onNotFound()

The onNotFound() handler runs when the browser requests a URL that does not exist.

Add this before server.begin():

server.onNotFound([](AsyncWebServerRequest *request) {
  request->send(404, "text/plain", "Page not found");
});

Now if the browser visits a wrong URL, such as:

/random-page

The ESP32 responds with:

Page not found

This is useful for debugging because you can immediately see when the browser is requesting a route that your sketch does not handle.

You can also print the missing URL to the Serial Monitor:

server.onNotFound([](AsyncWebServerRequest *request) {
  Serial.print("Not found: ");
  Serial.println(request->url());
  request->send(404, "text/plain", "Page not found");
});

Using Server-Sent Events with ESP32

Route handlers are useful when the browser asks the ESP32 for something. But what if the ESP32 needs to send live updates to the browser automatically?

For that, you can use Server-Sent Events, also called SSE.

Server-Sent Events allow the ESP32 to push data to the browser. This is useful for:

• Live temperature readings
• Sensor dashboards
• GPIO status updates
• ADC values
• Distance sensor readings
• System status messages

In ESPAsyncWebServer, this is done using AsyncEventSource.

ESP32 Async Web Server EventSource Example

The following example sends a counter value from the ESP32 to the browser every second.

#include <WiFi.h>
#include <AsyncTCP.h>
#include <ESPAsyncWebServer.h>

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

AsyncWebServer server(80);
AsyncEventSource events("/events");

unsigned long lastEventTime = 0;
int counter = 0;

const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE html>
<html>
<head>
  <title>ESP32 Server-Sent Events</title>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <style>
    body {
      font-family: Arial;
      text-align: center;
      margin-top: 50px;
    }

    #counter {
      font-size: 48px;
      font-weight: bold;
      color: #0066cc;
    }
  </style>
</head>
<body>
  <h1>ESP32 Async Web Server Events</h1>
  <p>Live Counter:</p>
  <div id="counter">0</div>

  <script>
    const source = new EventSource('/events');

    source.addEventListener('counter', function(event) {
      document.getElementById('counter').innerText = event.data;
    });

    source.onerror = function(error) {
      console.log('EventSource error:', error);
    };
  </script>
</body>
</html>
)rawliteral";

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

  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("/", HTTP_GET, [](AsyncWebServerRequest *request) {
    request->send_P(200, "text/html", index_html);
  });

  events.onConnect([](AsyncEventSourceClient *client) {
    Serial.println("Client connected to events");

    if (client->lastId()) {
      Serial.printf("Client reconnected. Last message ID: %u\n", client->lastId());
    }

    client->send("Connected to ESP32 events", NULL, millis(), 1000);
  });

  server.addHandler(&events);

  server.begin();
}

void loop() {
  if (millis() - lastEventTime > 1000) {
    lastEventTime = millis();
    counter++;

    String counterString = String(counter);
    events.send(counterString.c_str(), "counter", millis());
  }
}

In the browser, this line creates a connection to the ESP32 event source:

const source = new EventSource('/events');

This JavaScript event handler listens for events named counter:

source.addEventListener('counter', function(event) {
  document.getElementById('counter').innerText = event.data;
});

On the ESP32 side, this line sends the event:

events.send(counterString.c_str(), "counter", millis());

The second argument, "counter", is the event name. The browser listens for the same event name using addEventListener().

Complete LED and Event Handler Example

Here is a more complete example that combines LED control and live status updates.

#include <WiFi.h>
#include <AsyncTCP.h>
#include <ESPAsyncWebServer.h>

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

const int ledPin = 2;
bool ledState = false;

AsyncWebServer server(80);
AsyncEventSource events("/events");

unsigned long lastStatusTime = 0;

const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE html>
<html>
<head>
  <title>ESP32 LED Event Handler</title>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <style>
    body {
      font-family: Arial;
      text-align: center;
      margin-top: 40px;
    }

    button {
      font-size: 20px;
      padding: 12px 24px;
      margin: 10px;
    }

    #status {
      font-size: 28px;
      font-weight: bold;
    }
  </style>
</head>
<body>
  <h1>ESP32 Async Web Server Event Handler</h1>

  <p>LED Status:</p>
  <div id="status">Waiting...</div>

  <button onclick="setLED('on')">Turn ON</button>
  <button onclick="setLED('off')">Turn OFF</button>

  <script>
    function setLED(state) {
      fetch('/led/' + state);
    }

    const source = new EventSource('/events');

    source.addEventListener('led', function(event) {
      document.getElementById('status').innerText = event.data;
    });
  </script>
</body>
</html>
)rawliteral";

void sendLedStatus() {
  if (ledState) {
    events.send("ON", "led", millis());
  } else {
    events.send("OFF", "led", millis());
  }
}

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

  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);

  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("/", HTTP_GET, [](AsyncWebServerRequest *request) {
    request->send_P(200, "text/html", index_html);
  });

  server.on("/led/on", HTTP_GET, [](AsyncWebServerRequest *request) {
    ledState = true;
    digitalWrite(ledPin, HIGH);
    sendLedStatus();
    request->send(200, "text/plain", "LED ON");
  });

  server.on("/led/off", HTTP_GET, [](AsyncWebServerRequest *request) {
    ledState = false;
    digitalWrite(ledPin, LOW);
    sendLedStatus();
    request->send(200, "text/plain", "LED OFF");
  });

  events.onConnect([](AsyncEventSourceClient *client) {
    Serial.println("Event client connected");
    client->send(ledState ? "ON" : "OFF", "led", millis(), 1000);
  });

  server.addHandler(&events);

  server.onNotFound([](AsyncWebServerRequest *request) {
    request->send(404, "text/plain", "Page not found");
  });

  server.begin();
}

void loop() {
  if (millis() - lastStatusTime > 5000) {
    lastStatusTime = millis();
    sendLedStatus();
  }
}

In this version, clicking a button sends a request to the ESP32. The ESP32 changes the LED state, then sends an event back to the browser. The browser updates the displayed LED status without reloading the page.

ESP32 Async Web Server vs Regular WebServer

The regular ESP32 WebServer library usually requires code like this inside the loop:

server.handleClient();

With ESPAsyncWebServer, you normally do not need that. The server handles requests asynchronously using callbacks.

For simple projects, the regular WebServer library is easier to understand. But for more responsive pages, real-time updates, dashboards, and projects with multiple clients, ESPAsyncWebServer is often a better choice.

Use the regular WebServer library if:

• You are building a very simple project
• You want fewer dependencies
• You are still learning basic web server concepts

Use ESPAsyncWebServer if:

• You want responsive web controls
• You want Server-Sent Events
• You want WebSocket support
• You want to serve pages without blocking your main code
• You are building an ESP32 dashboard or control panel

Common Errors and Fixes

ESPAsyncWebServer.h: No such file or directory

This means the ESPAsyncWebServer library is not installed correctly.

Make sure you installed:

#include <ESPAsyncWebServer.h>

You also need the AsyncTCP library for ESP32:

#include <AsyncTCP.h>

AsyncTCP.h: No such file or directory

Install the AsyncTCP library. ESPAsyncWebServer depends on it when used with ESP32.

The Web Page Does Not Open

Check the Serial Monitor and make sure the ESP32 is connected to Wi-Fi. The ESP32 and your computer or phone must usually be connected to the same network.

Also make sure you are entering the correct IP address printed by the ESP32.

The LED Does Not Turn On

Check your LED polarity. The longer leg is usually the anode and should go through a resistor to the GPIO pin. The shorter leg is usually the cathode and should go to GND.

Also check if your board really uses GPIO 2 for the LED. Some ESP32 boards use a different built-in LED pin.

Buttons Work But Page Does Not Update

If the LED changes but the text on the page does not update, check the browser console. There may be a JavaScript error.

Also make sure the event name in the ESP32 code matches the JavaScript listener.

For example, this ESP32 event:

events.send("ON", "led", millis());

must match this JavaScript event listener:

source.addEventListener('led', function(event) {
  document.getElementById('status').innerText = event.data;
});

Do Not Use Long delay() Calls

Although the web server itself is asynchronous, you should still avoid long blocking code in your sketch. Long delay() calls, slow loops, or blocking sensor reads can make your project feel less responsive.

Use millis() timing instead when possible.

Final Thoughts

The ESP32 Async Web Server library is a powerful way to build web-controlled ESP32 projects. With event handlers, you can respond to browser requests, control GPIO pins, read URL parameters, handle missing pages, and push live updates to the browser using Server-Sent Events.

For beginner projects, start with simple route handlers like /led/on and /led/off. Once that works, add a web page with buttons. After that, try Server-Sent Events to display live sensor readings without refreshing the page.

This makes ESP32 Async Web Server useful for home automation, IoT dashboards, sensor monitors, relay controls, robotics projects, and browser-based embedded interfaces.

The post ESP32 Async Web Server Event Handler Tutorial appeared first on Microcontroller Tutorials.

Fortunately, some ESP32 chips support automatic baud rate detection. In this Arduino ESP32 autobaud example, we’ll use the Arduino-ESP32 Serial API to detect the baud rate of incoming UART data automatically.

This is useful when working with unknown serial devices, AT command modules, GPS modules, GSM modules, Bluetooth serial modules, or any UART device where the baud rate is not immediately known.

What Is Autobaud?

Autobaud is a feature that allows a UART peripheral to detect the baud rate of incoming serial data.

Instead of writing:

Serial.begin(9600);

or:

Serial.begin(115200);

you can start the serial port with a baud rate of 0 on supported ESP32 chips:

Serial.begin(0);

This tells the ESP32 to wait for incoming UART data and try to determine the correct baud rate automatically.

Important: ESP32 Autobaud Is Not Supported on All ESP32 Chips

According to the Arduino-ESP32 Serial API, baud rate detection is supported only on:

• ESP32
• ESP32-S2

It does not work on all newer ESP32 variants such as ESP32-C3, ESP32-S3, ESP32-C6, and other SoCs.

This is important because many boards are called “ESP32” even if they use a different chip. For example:

So before using this feature, check the actual chip on your board.

Basic Arduino ESP32 Autobaud Example

Here is the simplest Arduino ESP32 autobaud example:

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

  Serial.print("Detected baud rate: ");
  Serial.println(Serial.baudRate());

  if (Serial.baudRate() == 0) {
    Serial.end();
    Serial.begin(115200);
    delay(1000);

    Serial.println("Baud rate detection failed.");
    Serial.println("Serial reset to 115200.");
  }
}

void loop() {
}

In this example, Serial.begin(0) starts baud rate detection.

The ESP32 waits for incoming serial data. If it detects the baud rate successfully, Serial.baudRate() returns the detected baud rate.

If detection fails, Serial.baudRate() returns 0. The sketch then restarts Serial at 115200 baud so you can still see a message in the Arduino Serial Monitor.

How to Test ESP32 Autobaud

To test this sketch, upload it to an ESP32 or ESP32-S2 board.

Then open the Arduino IDE Serial Monitor and choose a baud rate such as:

• 9600
• 19200
• 38400
• 57600
• 115200

Type a few characters and send them.

The ESP32 should detect the baud rate and print the detected value.

The detected value may not always be exactly the same number. For example, 115200 may appear as 115201. This small difference is normal.

Autobaud on Serial1 or Serial2

In many real projects, you probably do not want to use Serial for autobaud because Serial is usually connected to the USB port and used for debugging.

Instead, you can use Serial1 or Serial2 for the external UART device.

Here is an example using Serial2 on GPIO16 and GPIO17:

#define RXD2 16
#define TXD2 17

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

  Serial.println("Arduino ESP32 Autobaud Example on Serial2");
  Serial.println("Waiting for incoming UART data...");

  Serial2.begin(0, SERIAL_8N1, RXD2, TXD2, false, 20000);

  uint32_t detectedBaud = Serial2.baudRate();

  if (detectedBaud == 0) {
    Serial.println("Baud rate detection failed.");
    Serial.println("Make sure the external device is sending data.");
  } else {
    Serial.print("Detected baud rate: ");
    Serial.println(detectedBaud);
  }
}

void loop() {
  while (Serial2.available()) {
    Serial.write(Serial2.read());
  }
}

This sketch uses:

Serial2.begin(0, SERIAL_8N1, RXD2, TXD2, false, 20000);

The first parameter is 0, which enables baud rate detection.

The last parameter, 20000, is the timeout in milliseconds. That means the ESP32 waits up to 20 seconds for incoming data.

ESP32 Serial2 Wiring

For the example above, connect the external UART device like this:

Make sure both devices share a common ground.

Also remember that the ESP32 uses 3.3V logic. If the external device uses 5V UART signals, use a logic level shifter or voltage divider before connecting to the ESP32 RX pin.

Example: ESP32 Autobaud Serial Bridge

After detecting the baud rate, you can use the ESP32 as a simple USB-to-UART bridge.

#define RXD2 16
#define TXD2 17

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

  Serial.println();
  Serial.println("ESP32 Autobaud Serial Bridge");
  Serial.println("Waiting for external UART data...");

  Serial2.begin(0, SERIAL_8N1, RXD2, TXD2, false, 20000);

  uint32_t baud = Serial2.baudRate();

  if (baud == 0) {
    Serial.println("Autobaud failed. Restarting Serial2 at 9600.");
    Serial2.end();
    Serial2.begin(9600, SERIAL_8N1, RXD2, TXD2);
  } else {
    Serial.print("Detected baud rate: ");
    Serial.println(baud);
  }

  Serial.println("Bridge ready.");
}

void loop() {
  while (Serial.available()) {
    Serial2.write(Serial.read());
  }

  while (Serial2.available()) {
    Serial.write(Serial2.read());
  }
}

This is useful for testing UART modules. Once the ESP32 detects the baud rate, anything you type in the Serial Monitor is forwarded to the external device. Any response from the external device is printed back to the Serial Monitor.

Using ESP32 Autobaud with AT Command Modules

Autobaud is useful for AT command modules because some modules may be configured to different baud rates.

Examples include:

• GSM modules
• Bluetooth serial modules
• Wi-Fi modem modules
• LoRa UART modules
• GPS modules with command interfaces

After detecting the baud rate, you can send an AT command:

Serial2.println("AT");

Then read the response:

if (Serial2.available()) {
  String response = Serial2.readString();
  Serial.println(response);
}

If the module replies with:

OK

then your wiring and baud rate are likely correct.

Why Autobaud Detection May Fail

Autobaud detection needs incoming UART data. If the external device is silent during the timeout period, the ESP32 will not be able to detect the baud rate.

Detection may fail if:

• The connected device is not sending data
• RX and TX are wired incorrectly
• GND is not connected
• The UART signal level is wrong
• The selected ESP32 chip does not support autobaud
• The baud rate is outside the supported detection range
• The signal is noisy or inverted

For testing, use a device that repeatedly sends text data.

Fallback Method for ESP32-C3, ESP32-S3, and Other Chips

If your ESP32 chip does not support Serial.begin(0) autobaud detection, you can still make a software-style workaround by scanning common baud rates.

This is not true hardware autobaud, but it can work if the device sends readable text.

#define RXD2 16
#define TXD2 17

const long baudRates[] = {
  9600,
  19200,
  38400,
  57600,
  115200,
  230400
};

const int baudCount = sizeof(baudRates) / sizeof(baudRates[0]);

bool looksReadable(String data) {
  int readable = 0;

  for (int i = 0; i < data.length(); i++) {
    char c = data[i];

    if ((c >= 32 && c <= 126) || c == '\r' || c == '\n') {
      readable++;
    }
  }

  return data.length() > 0 && readable > data.length() * 0.8;
}

long scanBaudRate() {
  for (int i = 0; i < baudCount; i++) {
    long baud = baudRates[i];

    Serial.print("Testing ");
    Serial.println(baud);

    Serial2.end();
    delay(100);
    Serial2.begin(baud, SERIAL_8N1, RXD2, TXD2);
    delay(300);

    String sample = "";
    unsigned long start = millis();

    while (millis() - start < 1000) {
      while (Serial2.available()) {
        sample += (char)Serial2.read();
      }
    }

    if (looksReadable(sample)) {
      return baud;
    }
  }

  return -1;
}

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

  Serial.println("Software baud scan fallback example");

  long baud = scanBaudRate();

  if (baud > 0) {
    Serial.print("Likely baud rate: ");
    Serial.println(baud);

    Serial2.end();
    Serial2.begin(baud, SERIAL_8N1, RXD2, TXD2);
  } else {
    Serial.println("Could not detect baud rate.");
  }
}

void loop() {
  while (Serial2.available()) {
    Serial.write(Serial2.read());
  }
}

Use this fallback method only when the hardware autobaud feature is not available.

Hardware Autobaud vs Baud Rate Scanning

If you already know the baud rate, use a fixed baud rate. Autobaud is mainly useful when the baud rate is unknown.

Final Thoughts

This Arduino ESP32 autobaud example shows how to detect the UART baud rate automatically using the Arduino-ESP32 Serial API.

On supported chips, such as ESP32 and ESP32-S2, you can call:

Serial.begin(0);

or:

Serial2.begin(0, SERIAL_8N1, RXD2, TXD2);

Then read the detected baud rate using:

Serial.baudRate();

For unsupported ESP32 variants, such as ESP32-C3 or ESP32-S3, use a manual baud-rate scanning method instead.

Autobaud is not needed for every project, but it is very useful when debugging unknown UART devices or building flexible ESP32 serial tools.

The post Arduino ESP32 Autobaud Example: Detect UART Baud Rate Automatically appeared first on Microcontroller Tutorials.

Many developers discover that once BLE scanning starts, their Wi-Fi web server becomes unreliable. Pages load intermittently, HTTP requests time out, or BLE scans suddenly stop when Wi-Fi traffic increases.

In this article, we’ll walk through why this happens and how using FreeRTOS (RTOS) on the ESP32 cleanly solves the concurrency problem.

The Core Problem

On ESP32, BLE and Wi-Fi share critical hardware resources:

• The same radio
• The same CPU
• The same event loop when using blocking APIs

A naïve implementation often looks like this:

void loop() {
  bleScan();        // blocks
  handleHttp();     // blocks
}

This design appears to work at first, but quickly degrades under real usage.

Typical Symptoms

• BLE scanning pauses while HTTP requests are active
• The web server becomes unreachable during scans
• Random socket resets
• BLE callbacks fire late or not at all

These issues are not bugs in BLE or Wi-Fi—they are architectural problems.

Why Delays and Timers Don’t Fix It

A common attempt is to add delay() calls:

bleScan();
delay(100);

Unfortunately:

• delay() blocks the current task
• BLE callbacks still execute in the same context
• Wi-Fi servicing becomes opportunistic

This approach does not guarantee fairness between BLE and Wi-Fi.

The problem is not timing — it’s task isolation.

The ESP32 Advantage: Built-in FreeRTOS

Unlike simpler microcontrollers, the ESP32 runs FreeRTOS natively, offering:

• Preemptive multitasking
• Two CPU cores
• Task prioritization
• Core pinning

Instead of fighting the scheduler, we can design with it.

High-Level Design

The solution is to split responsibilities into independent RTOS tasks, each with a single purpose.

Each subsystem runs independently, coordinated only through minimal shared state.

Task Responsibilities

BLE Task (Core 0)

The BLE task is responsible for:

• Running short, non-blocking BLE scans
• Parsing advertisement payloads
• Updating shared state when new data arrives

Example:

void bleTask(void* param) {
  for (;;) {
    startBleScan();
    updateSharedState();
    vTaskDelay(pdMS_TO_TICKS(100));
  }
}

Key characteristics:

• No networking code
• No JSON formatting
• Frequent yielding to the scheduler

HTTP Task (Core 1)

The HTTP task handles all networking:

void httpTask(void* param) {
  server.begin();

  for (;;) {
    WiFiClient client = server.available();
    if (client) {
      handleRequest(client);
      client.stop();
    }
    vTaskDelay(pdMS_TO_TICKS(10));
  }
}

This task remains responsive regardless of BLE activity.

Shared State: Keep It Simple

Shared data between tasks is intentionally minimal:

char lastData[32];
int lastSignalStrength;
volatile bool hasData;
volatile bool hasNewData;
unsigned long lastSeenMillis;

Why this works safely:

• Single-writer pattern
• No dynamic allocation
• No STL containers
• Short critical sections
• volatile ensures cross-core visibility

This approach avoids the need for mutexes while maintaining robustness.

Handling Data Expiration (TTL)

To prevent stale data from being served indefinitely, we added a time-to-live (TTL) mechanism:

if (hasData && millis() - lastSeenMillis > DATA_TTL_MS) {
  hasData = false;
  hasNewData = false;
}

This mirrors real-world scanning behavior:

• Data appears
• Data ages out
• Clients stop receiving old results

Why This Architecture Works

1. True Concurrency

BLE scanning and Wi-Fi networking never block each other.

2. Predictable Scheduling

FreeRTOS ensures both tasks get CPU time when needed.

3. Improved Stability

No more random disconnects or missed scans.

4. Easy Scalability

Additional tasks (MQTT, OTA, logging) can be added cleanly.

Results

After moving to an RTOS-based design:

• BLE scanning runs continuously
• The web server is always reachable
• No socket resets under load
• No missed BLE advertisements
• System behavior is deterministic and production-ready

Key Takeaways

• BLE + Wi-Fi issues on ESP32 are architectural, not library bugs
• Blocking code in loop() does not scale
• FreeRTOS is not optional for serious ESP32 applications
• Separate concerns into dedicated tasks
• Keep shared state small and explicit

Final Thoughts

If you’re building an ESP32 application that combines BLE scanning and Wi-Fi networking, embracing FreeRTOS is the turning point between a fragile prototype and a reliable system.

Once tasks are isolated and scheduled correctly, the ESP32 becomes an extremely capable concurrent platform.

The post Solving BLE and Wi-Fi Concurrency on ESP32 Using FreeRTOS appeared first on Microcontroller Tutorials.

This setup is:

• Free
• Reliable
• No Firebase
• No OAuth
• No paid APIs

If you just want a clean Google Sheet logging your ESP32 sensor data, this is one of the simplest and most stable methods available today.

How This Works

Here’s the flow I’m using:

1. ESP32 reads sensor data
2. ESP32 connects to Wi-Fi
3. Every 1 hour, ESP32 sends an HTTP POST request
4. Google Apps Script receives the data
5. The data is appended to Google Sheets

That’s it.

What I’m Using

Hardware

• ESP32 (any variant works)
• Any sensor (DHT22, DS18B20, analog sensor, etc.)

Software & Accounts

• Arduino IDE
• Google account
• Internet connection

Step 1: Create the Google Sheet

1. Go to Google Sheets
2. Click Blank
3. Rename the file (I use something like ESP32 Sensor Log)
4. Add these headers in Row 1:  Timestamp | Temperature | Humidity | Device_ID

You can add more columns later if you want more sensors.

Step 2: Create the Google Apps Script

1. Inside your Google Sheet, click
   Extensions → Apps Script
2. Delete everything inside the editor
3. Paste this code:

   function doPost(e) {
     try {
       const sheet = SpreadsheetApp.getActiveSpreadsheet().getActiveSheet();
       const data = JSON.parse(e.postData.contents);
   
       sheet.appendRow([
         new Date(),
         data.temperature,
         data.humidity,
         data.device_id
       ]);
   
       return ContentService
         .createTextOutput("OK")
         .setMimeType(ContentService.MimeType.TEXT);
   
     } catch (err) {
       return ContentService
         .createTextOutput("ERROR: " + err)
         .setMimeType(ContentService.MimeType.TEXT);
     }
   }
   

4. Click Save
5. Name the project (I usually call it ESP32 Sensor Log )

Step 3: Deploy the Script as a Web App

1. Click Deploy → New deployment
2. Select Web app
3. Set the options:
   • Execute as: Me
   • Who has access: Anyone
4. Click Deploy
5. Authorize permissions
6. Copy the Web App URL

I’ll use this URL in the ESP32 code.

Step 4: ESP32 Arduino Code (Hourly Upload)

Libraries I’m Using

These are already included with ESP32 Arduino core:

• WiFi.h
• HTTPClient.h

Example ESP32 Code

#include <WiFi.h>
#include <HTTPClient.h>

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

const char* serverUrl =
  "https://script.google.com/macros/s/YOUR_SCRIPT_ID/exec";

unsigned long lastSend = 0;
const unsigned long interval = 3600000; // 1 hour

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

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

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

  Serial.println("\nWiFi connected");
}

void loop() {
  if (millis() - lastSend >= interval) {
    lastSend = millis();
    sendData();
  }
}

void sendData() {
  if (WiFi.status() == WL_CONNECTED) {
    HTTPClient http;
    http.begin(serverUrl);
    http.addHeader("Content-Type", "application/json");

    float temperature = 25.4; // replace with sensor read
    float humidity    = 60.2; // replace with sensor read

    String json =
      "{"
      "\"temperature\":" + String(temperature) + ","
      "\"humidity\":" + String(humidity) + ","
      "\"device_id\":\"ESP32_01\""
      "}";

    int responseCode = http.POST(json);
    Serial.println("HTTP Response: " + String(responseCode));

    http.end();
  }
}

esp_sleep_enable_timer_wakeup(3600ULL * 1000000ULL);
esp_deep_sleep_start();

The post How to Send ESP32 Sensor Data to Google Sheets (2026)  appeared first on Microcontroller Tutorials.