Getting Started with the ESP32-C3 Super Mini

The ESP32-C3 Super Mini is a compact development board based on the Espressif ESP32-C3 chip, part of the ESP32 family. Its main advantages over other ESP32 boards are its small size and low power consumption in deep sleep mode. In this guide, we’ll introduce the ESP32-C3 Super Mini, explore its features and pinout, show you how to program it using the Arduino IDE, and run a few examples to test the board.

Table of Contents

In this guide, we’ll cover the following topics:

• Introducing the ESP32-C3 Super Mini
• ESP32-C3 Super Mini Technical Specifications
• ESP32-C3 Super Mini Peripheral Interface
• ESP32-C3 Super Mini Pinout
• Programming the ESP32 C3 Super Mini with Arduino IDE
• Testing Wi-Fi on the ESP32-C3 Super Mini (Web Server)
• Sleep Modes with the ESP32-C3 Super Mini
  • ESP32-C3 Super Mini – Deep Sleep with Timer Wake-Up
• Power Consumption in Deep Sleep Mode

Introducing the ESP32-C3 Super Mini

The ESP32-C3 Super Mini is a compact development board featuring the ESP32-C3 chip with built-in Wi-Fi and Bluetooth. Unlike other ESP32 board models, this one is a single-core chip. It has a very small footprint and is optimized for low power consumption, drawing only around 43µA in deep sleep mode, according to the datasheet. The board has 16 pins, with 11 programmable GPIOs that support ADC, PWM, UART, I2C, and SPI.

It includes both RST (reset) and BOOT buttons. The BOOT button is used to put the board into bootloader mode for uploading code, while the RST button resets the board—useful for restarting and running newly uploaded code.

The board also features a USB-C interface, which can be used for powering the board, uploading code, or serial communication. Alternatively, you can power the board using an external 5V source through the 5V and GND pins—but note that the USB-C port shouldn’t be used at the same time as an external power source.

Like many other ESP32 board models, it comes with an onboard LED. But, in this case, it’s connected to GPIO 8 (instead of GPIO 2 in most boards).

ESP32-C3 Super Mini Technical Specifications

Here’s a summary of the ESP32-C3 technical specifications:

• Processor: 32-bit RISC-V CPU running up to 160 MHz
• IEEE 802.11b /g/n WiFi and Bluetooth 5 (LE) protocols
• 400KB SRAM, 384KB ROM and built-in 4M flash
• Compact SMD antenna
• 11 GPIOs that support the following interfaces:
  • 4 ADC pins
  • PWM
  • UART
  • I2C
  • SPI
• Onboard LED on GPIO 8
• Reset and Boot buttons
• Ultra low power consumption: as low as 43uA in deep sleep mode
• Small form factor

You can also take a look at the following table:

Microcontroller (processor)	Espressif ESP32-C3 (32-RISC-V single-core, up to 160 MHz)
Flash Memory	4 MB (onboard SPI flash)
SRAM	400 KB
ROM	384 KB
Wi-Fi	802.11 b/g/n, 2.4 GHz, up to 150 Mbps
Bluetooth	Bluetooth 5.0 LE
GPIO Pins	11 accessible GPIOs
Analog Inputs (ADC)	2 × 12-bit SAR ADCs, up to 6 channels
PWM Channels	6 channels
SPI	3 × SPI interfaces (SPI0, SPI1 reserved)
I2C	1 × I2C interface
UART	2 × UART interfaces
I2S	1 × I2S interface
USB Interface	USB-C, supports USB CDC
Power Supply	5V via USB-C or 3.3V–6V via VIN (5V) pin; onboard 3.3V regulator (up to 500 mA)
Operating Voltage	3.3V (logic level for GPIOs)
Deep Sleep Mode	43uA
Buttons	1 × Reset button, 1 × Boot button (GPIO9)
LED	1 × onboard LED (on GPIO8, active low)
Programming	Arduino IDE, ESP-IDF, MicroPython, PlatformIO/pioarduino

Where to Buy ESP32-C3 Super Mini?

The ESP32-C3 Super Mini board is widely available on many different stores. Check the following link to compare its price on different stores:

• Buy ESP32-C3 Super Mini

ESP32-C3 Super Mini Peripheral Interface

The ESP32-C3 Super Mini comes with 16 pins, 11 of which are programmable GPIOs that you can use to control peripherals and read sensors. It supports the following peripheral interfaces:

• Digital I/O
• PWM
• ADC
• PWM
• UART
• I2C
• SPI

ESP32-C3 Super Mini Pinout

The following picture shows the pinout for the ESP32-C3 Super Mini board. Please note that the pinout can change slightly depending on the manufacturer. So, double-check the pinout with the pin mapping on the silkscreen of your board.

The following table describes the pin mapping and its functions.

Pin	Function
3V3	3.3V output/input (outputs 3.3V from the onboard regulator, or it is a input for external 3.3V power supply)
5V	5V input/output (connects to the USB-C 5V or external 5V supply)
GND	GND pin
GPIO 0	General-purpose I/O, ADC1, PWM
GPIO 1	General-purpose I/O, ADC1, PWM
GPIO 2	General-purpose I/O ADC1, Strapping Pin (Boot Mode) (avoid for general use)
GPIO 3	General-purpose I/O, PWM
GPIO 4	General-purpose I/O, PWM, default SPI SCK pin
GPIO 5	General-purpose I/O, PWM, default MISO SCK pin
GPIO 6	General-purpose I/O, PWM, default SPI MOSI pin
GPIO 7	General-purpose I/O, PWM, default SPI SS pin
GPIO 8	Connected to the onboard LED (active low); Strapping Pin (avoid for general use); Default I2C SDA pin
GPIO 9	Connected to BOOT Button (LOW to enter bootloader), Strapping Pin (avoid for general use) Default I2C SCL pin
GPIO 10	General-purpose I/O, PWM
GPIO 20	General-purpose I/O, PWM, default UART RX Pin
GPIO 21	General-purpose I/O, PWM, default UART TX Pin

Stapping Pins

• GPIO 2: a strapping to enter bootloader mode – avoid for general use.
• GPIO 8: connected to the onboard blue LED (inverted logic/active LOW); it’s also a strapping pin;
• GPIO 9: connected to the BOOT button – avoid for general use;

You can still use the strapping pins in your projects, however, you need to take into account the fluctuation of the state of these GPIOs when the ESP32 resets or enters into bootloader mode.

Power Pins

When it comes to power pins, you have one 5V, one 3V3, and a GND pin.

The 3V3 pin provides 3.3V from the onboard regulator or accepts 3.3V from an external power source. Similarly, the 5V pin, can be used for input to power the board, or it outputs 5V from the USB power supply.

PWM

All general-purpose GPIOs can output PWM signals.

Analog (ADC) Pins

GPIOs 0, 1, 2, 3, 4, and 5 support analog reading:

• GPIO 0: ADC1_CH0
• GPIO 1: ADC1_CH1
• GPIO 2: ADC1_CH2
• GPIO 3: ADC1_CH3
• GPIO 4: ADC1_CH4
• GPIO 5: ADC1_CH5

UART, I2C, and PWM

Due to the ESP32 multiplexing feature, the UART, SPI, and I2C interfaces can be assigned to nearly any GPIO.

However, when using Arduino IDE, and assuming you’re selecting the ESP32 C3 board in the Boards menu, it will assume the following pins as defaults:

• UART: defaults to GPIO 20 (RX) and GPIO21 (TX)
• SPI: defaults to GPIO6 (MISO), GPIO7 (MOSI), GPIO10 (SCK), and GPIO 5 (SS)
• I2C: defaults to GPIO 8 (SDA) and GPIO 9 (SCL)

Board Datasheet

For more information about the board, you can check its datasheet in the link below:

• ESP32-C3 Super Mini Datasheet

Programming the ESP32 C3 Super Mini with Arduino IDE

You can program the ESP32-C3 Super Mini using Arduino IDE like any other ESP32 module. To do that, follow the next steps.

1) Installing Arduino IDE

First, install Arduino IDE and the ESP32 boards.

Go to the Arduino website and download the version for your operating system.

• Windows: run the downloaded file and follow the instructions in the installation guide (for Windows, we recommend the first option).
• Mac OS X: copy the downloaded file into your application folder.
• Linux: extract the downloaded file, and open the arduino-ide file that will launch the IDE.

If you have doubts, you can go to the Arduino Installation Guide.

Do you need an ESP32-C3 Super Mini board? You can buy it here.

Recommended reading: ESP32 Development Boards Review and Comparison

2) Install the ESP32 Boards in Arduino IDE

To install the ESP32 boards in your Arduino IDE, follow these instructions.

Open the Boards Manager. You can go to Tools > Board > Boards Manager… or you can simply click the Boards Manager icon in the left-side corner.

Search for ESP32 and press the install button for esp32 by Espressif Systems version 3.X.

That’s it. It should be installed after a few seconds.

3) Putting the ESP32 C3 Super Mini in Bootloader Mode

Connect the ESP32-C3 Super Mini to your computer in Bootloader Mode (ready for uploading code via USB). You may need to do this the first time you’re connecting your board to your computer.

In my case, I only needed to do this procedure once, but I read some people reporting that they needed to do this every time they wanted to upload a new code.

Follow these steps:

1. Hold down the BOOT button.
2. Press and release the RESET button (while still holding BOOT).
3. Then release the BOOT button.

4) Uploading Code to the ESP32-C3 Super Mini

Copy the following code to your Arduino IDE. This code simply blinks the onboard LED (connected to GPIO 8) and prints in the Serial Monitor the current state of the GPIO.

/*********
  Rui Santos & Sara Santos - Random Nerd Tutorials
  Complete project details at https://RandomNerdTutorials.com/getting-started-esp32-c3-super-mini/
*********/

// ESP32 C3 Super Mini on-board LED (works with inverted logic)
const int ledPin = 8; 

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

void loop() {
  Serial.begin(115200);
  digitalWrite(ledPin, HIGH); 
  Serial.println("LED OFF");
  delay(1000);                     
  digitalWrite(ledPin, LOW); 
  Serial.println("LED ON");  
  delay(5000);                     
}

View raw code

Now, select the board and COM Port. Click on the drop-down menu at the top and select the ESP32C3 Dev Module. Then, select the corresponding COM port.

Then, enable the following option in the Tools menu > USB CDC on Boot.

Finally, click the upload button to upload the code.

Press the board RST button so that it starts running the newly uploaded code.

The onboard LED will blink every second.

At the same time, you can open the Serial Monitor at a baud rate of 115200. It will print the current LED state on the window.

Testing Wi-Fi on the ESP32-C3 Super Mini (Web Server)

To test the Wi-Fi of the ESP32-C3 Super Mini, we’ve prepared a web server that controls the onboard LED.

1) Copy the following code to your Arduino IDE.

/*********
  Rui Santos & Sara Santos - Random Nerd Tutorials
  Complete project details at https://RandomNerdTutorials.com/getting-started-esp32-c3-super-mini/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*********/

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

// Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

// Assign output variable to GPIO pin
const int output = 8;
String outputState = "OFF";

// Create a web server object
WebServer server(80);

// Function to handle turning GPIO on
void handleGPIOOn() {
  outputState = "ON";
  digitalWrite(output, LOW);
  handleRoot();
}

// Function to handle turning GPIO off
void handleGPIOOff() {
  outputState = "OFF";
  digitalWrite(output, HIGH);
  handleRoot();
}

// Function to handle the root URL and show the current state
void handleRoot() {
  String html = "<!DOCTYPE html><html><head><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">";
  html += "<link rel=\"icon\" href=\"data:,\">";
  html += "<style>";
  html += "html { font-family: Helvetica; text-align: center; background: #f5f7fa; margin: 0; padding: 20px; }";
  html += "body { max-width: 600px; margin: 0 auto; background: white; padding: 20px; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }";
  html += "h1 { color: #333; font-size: 28px; margin-bottom: 20px; }";
  html += "p { color: #555; font-size: 18px; margin: 10px 0; }";
  html += ".button { background: #4CAF50; border: none; color: white; padding: 12px 24px; text-decoration: none; font-size: 20px; border-radius: 8px; cursor: pointer; transition: background 0.2s ease; display: inline-block; width: 120px; box-sizing: border-box; }";
  html += ".button:hover { background: #45a049; }";
  html += ".button2 { background: #555555; }";
  html += ".button2:hover { background: #666666; }";
  html += "</style></head>";
  html += "<body><h1>ESP32 Web Server</h1>";

  // Display GPIO controls
  html += "<p>GPIO - State " + outputState + "</p>";
  if (outputState == "ON") {
    html += "<p><a href=\"/off\"><button class=\"button button2\">OFF</button></a></p>";
  } else {
    html += "<p><a href=\"/on\"><button class=\"button\">ON</button></a></p>";
  }

  html += "</body></html>";
  server.send(200, "text/html", html);
}

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

  // Initialize the output variable as output
  pinMode(output, OUTPUT);
  // Set the onboard LED to LOW (inverted logic)
  digitalWrite(output, HIGH);

  // Connect to Wi-Fi network
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected.");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());

  // Set up the web server to handle different routes
  server.on("/", handleRoot);
  server.on("/on", handleGPIOOn);
  server.on("/off", handleGPIOOff);

  // Start the web server
  server.begin();
  Serial.println("HTTP server started");
}

void loop() {
  // Handle incoming client requests
  server.handleClient();
}

View raw code

2) Insert your Wi-Fi network credentials in the following lines.

const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

3) Upload the code to your board.

4) Open the Serial Monitor at a baud rate of 11500.

5) Press the board RST button.

6) Its IP address will be printed in the Serial Monitor.

7) Open a web browser on your local network and paste the IP address. You should get access to the web server. Click the button to control the onboard LED.

Sleep Modes with the ESP32-C3 Super Mini

One of the biggest advantages of the ESP32-C3 Super Mini, besides its small form factor, is its lower consumption in sleep mode.

It supports deep sleep and light sleep modes. More info on the sleep functions can be found in the documentation here.

We have several tutorials explaining how to use deep sleep and light sleep with the ESP32 (however, keep in mind that some external wake-up function are different for the ESP32-C3 Super Mini).

• ESP32 Light Sleep Mode and Wake-Up Sources (Arduino IDE)
• ESP32 Deep Sleep with Arduino IDE and Wake Up Sources*

* in case of external wake-up with the ESP32-C3 Super Mini, you need to use the esp_deep_sleep_enable_gpio_wakeup() function instead.

ESP32-C3 Super Mini – Deep Sleep with Timer Wake-Up

The following example is a simplified code that puts the ESP32 in deep sleep mode for one minute. After each minute, it wakes up and blinks the LED connected to GPIO 4.

/*********
  Rui Santos & Sara Santos - Random Nerd Tutorials
  Complete project details at https://RandomNerdTutorials.com/getting-started-esp32-c3-super-mini/
*********/

#define uS_TO_S_FACTOR 1000000ULL   // Microseconds to seconds
#define TIME_TO_SLEEP 60            // Deep sleep duration in seconds
#define LED_PIN 4                   // LED connected to GPIO4

void setup() {
  delay(100);
  pinMode(LED_PIN, OUTPUT);

  // Blink LED
  digitalWrite(LED_PIN, HIGH);
  delay(500);
  digitalWrite(LED_PIN, LOW);

  // Set deep sleep timer
  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);

  // Enter deep sleep
  esp_deep_sleep_start();
}

void loop() {}

View raw code

To put the ESP32 in deep sleep mode and wake it up with a timer, call the esp_sleep_enable_timer_wakeup() function and pass the number of microseconds to sleep as argument.

esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);

After setting up the wake-up source, you can put the ESP32 in deep sleep mode using esp_deep_sleep_start().

esp_deep_sleep_start();

To test this code, make sure to connect an LED to GPIO 4.

Note: I couldn’t use the Serial Monitor with the ESP32-C3 Super Mini in deep sleep mode because it wouldn’t connect to the Serial Monitor automatically after waking up.

Important: after uploading a deep sleep code to the board, to program it again, you need to do the button sequence to put it in bootloader mode.

1. Hold down the BOOT button.
2. Press and release the RESET button (while still holding BOOT).
3. Then release the BOOT button.

Power Consumption

Using the previous example on the ESP32-C3 Super Mini, I measured a deep sleep power consumption of approximately 600 µA. This is higher than the datasheet’s specified 40 uA. This is likely due to unoptimized configurations, such as floating GPIOs; or you need to use ESP-IDF to use more efficient functions.

Still, compared to a regular ESP32, which consumes about 10mA in deep sleep, the ESP32-C3’s measured 600 µA is still more efficient and a great improvement without any modifications in the code.

Wrapping Up

We hope you’ve found this ESP32-C3 Super Mini getting-started guide useful. Once you’ve gotten familiar with the board and its pinout, you can use our other ESP32 projects with this particular board—just make sure to rearrange the pin assignment if needed.

If you want to learn more about the ESP32, make sure to check out our resources:

• Learn ESP32 with Arduino IDE eBook
• Build Web Servers with ESP32 and ESP8266 eBook
• More ESP32 Tutorials and Projects…