ESP32-C3 Super Mini

The ESP32-C3 Super Mini is my new go-to microcontroller board whenever space is top priority. Its tiny size allows it to fit into the smallest devices while still offering ten fully usable GPIOs.

It is compatible with all ESP32 development environments, including ESPHome. Additionally, you can directly upload open-source firmware made for the ESP32, such as WLED.

Here’s an example project using the ESP32-C3 Super Mini and an 8x8 WS2812 LED Panel to create an awesome colorful light cube—no programming required and just three short wires:

Overview

The ESP32-C3 Super Mini is an energy-efficient, widely available, and affordable microcontroller. With its computational power and 4MB flash storage, it is more than sufficient for most DIY projects. I’ve replaced Arduino and ESP8266 boards with the ESP32-C3 Super Mini in most of my new projects.

However, there are a few exceptions where other boards are better suited:

• Many GPIOs: If a project requires more than 10 GPIOs, I opt for the ESP32-S2 Mini. It is cost-effective and has a slightly larger footprint compared to the ESP32-C3 Super Mini. Its extremely flat design makes it easy to integrate into portable devices.

• Battery Power: For portable projects, I use the Lolin32 Lite. This board features a built-in battery charger and boost converter, making it ideal for single-cell Li-Ion battery operation. While other boards offer similar functionality, the Lolin32 Lite stands out for its affordability.

• Display: When a small color display is needed, I choose the Lolin TTGO T-Display. It includes a 1.14” TFT display with a 135x240 resolution, which is well-suited for simple visual output in projects.

• Compatibility: For testing or ensuring maximum compatibility, I rely on the ESP32 DevKitC V4. While larger and less visually appealing, it is the default ESP32 development board and an excellent starting point for experimenting with new components. Its compatibility minimizes unexpected microcontroller-related issues, allowing focus on integrating and exploring components. Additionally, there are robust expansion boards available, making prototyping with DuPont wires easier.

• Computations: For projects involving advanced computations, I prefer one of the latest ESP32-S3 boards, which offer enhanced processing power.

• WiFi Range: When extended WiFi range is critical, I select boards with external antennas. While the ESP32-C3 Super Mini connects reliably to strong home WiFi networks, its small size and built-in antenna limit its range.

Arduino Framework

Getting the ESP32-C3 to work fully in Arduino IDE and PlatformIO can be a challenge since there is not yet a specific board definition available for it.

While you can use most board definitions that target ESP32-C3, they often assign incorrect GPIO pins to important constants used for SPI and I2C communication.

While it is possible to work around this issue by manually specifying the correct GPIO pin numbers, this is often only feasible when using the slower software-emulated interfaces. If you intend to use the faster hardware interfaces, most libraries rely on predefined GPIO constants. If these constants are wrong, hardware SPI and I2C won’t work as expected.

In summary, while selecting any ESP32-C3 board in your development environment may get you started, you will likely run into issues eventually.

Finding the Appropriate Board Definition

Since there is not yet a dedicated board definition for the ESP32-C3, you will need to use one that is similar enough. There is a board variant called esp32c3 that correctly defines the interface pins, although it does not include a proper definition for LED_BUILTIN.

esp32c3 defines the following constants:

To use this board variant, you must select the board esp32-c3-devkitm-1 and specify the board variant esp32c3. If you choose a different board, you may not be able to target the correct board variant.

Here is the platformio.ini configuration I use:

[env:esp32-c3-devkitm-1]
platform = espressif32
board = esp32-c3-devkitm-1
board_build.mcu = esp32c3
framework = arduino
build_flags =
    -D ARDUINO_USB_MODE=1
    -D ARDUINO_USB_CDC_ON_BOOT=1

When you use the suggested platformio.ini, all pins should be correctly defined, and you are ready for hardware SPI and hardware I2C. Only the constant LED_BUILTIN is wrong.

To make LED_BUILTIN work as well, simply re-define this constant in your code:

// (re)define BUILTIN_LED as most board definitions get this pin wrong:
#define LED_BUILTIN 8

Since constants are meant to be constant, your change will trigger a (benign) compiler warning that you can ignore:

src/main.cpp:5: warning: "LED_BUILTIN" redefined
 #define LED_BUILTIN 8

In file included from D:/.platformio/packages/framework-arduinoespressif32/cores/esp32/esp32-hal-gpio.h:29,
                 from D:/.platformio/packages/framework-arduinoespressif32/cores/esp32/esp32-hal.h:83,
                 from D:/.platformio/packages/framework-arduinoespressif32/cores/esp32/Arduino.h:36,
                 from src/main.cpp:1:
D:/.platformio/packages/framework-arduinoespressif32/variants/esp32c3/pins_arduino.h:11: note: this is the location of the previous definition
 #define LED_BUILTIN LED_BUILTIN  // allow testing #ifdef LED_BUILTIN

#include <Arduino.h>

// (re)define BUILTIN_LED as most board definitions get this pin wrong:
// (remove this line if you'd like to see what the original definition is)
#define LED_BUILTIN 8


void showPins() {
  // prints currently valid pin assignments to terminal:
  Serial.println("Pin Definitions for the Board:");

  // SPI Pins
  Serial.println("\nSPI Pins:");
  Serial.printf("MISO: %d\n", MISO);
  Serial.printf("MOSI: %d\n", MOSI);
  Serial.printf("SCK: %d\n", SCK);
  Serial.printf("SS (CS): %d\n", SS);

  // I2C Pins
  Serial.println("\nI2C Pins:");
  Serial.printf("SDA: %d\n", SDA);
  Serial.printf("SCL: %d\n", SCL);

  // LED Pin
  Serial.println("\nLED Pin:");
#ifdef LED_BUILTIN
  Serial.printf("LED_BUILTIN: %d\n", LED_BUILTIN);
#else
  Serial.println("No LED_BUILTIN defined for this board.");
#endif

  // DAC Pins
  Serial.println("\nDAC Pins (if available):");
#if defined(DAC1) && defined(DAC2)
  Serial.printf("DAC1: %d\n", DAC1); // Often GPIO25
  Serial.printf("DAC2: %d\n", DAC2); // Often GPIO26
#else
  Serial.println("DAC not available on this board.");
#endif

  // UART/Serial Pins
  Serial.println("\nSerial Pins:");
#if defined(TX) && defined(RX)
  Serial.printf("TX: %d\n", TX);
  Serial.printf("RX: %d\n", RX);
#else
  Serial.println("Default UART TX and RX not defined for this board.");
#endif
}


void setup() {
  // start serial output (baud rate does not matter with USB CDC)
  Serial.begin();
  // set built-in LED on GPIO8 for output
  pinMode(LED_BUILTIN, OUTPUT);
  // wait for the serial output to be ready
  delay(1000);
  // output pin assignments
  showPins();
}

void loop() {
  // blinks built-in LED at 1Hz to check that firmware is running:
  digitalWrite(LED_BUILTIN, HIGH);
  delay(500);
  digitalWrite(LED_BUILTIN, LOW);
  delay(500);
}

Pin Definitions for the Board:

SPI Pins:
MISO: 5
MOSI: 6
SCK: 4
SS (CS): 7

I2C Pins:
SDA: 8
SCL: 9

LED Pin:
LED_BUILTIN: 8

DAC Pins (if available):
DAC not available on this board.

Serial Pins:
Default UART TX and RX not defined for this board.

Without redefining constants, simply use the GPIO number 8 instead of LED_BUILTIN in your code.

Alternatively, you can add a new board definition to Arduino Core that correctly and completely describes this board. This work has in fact already been done, and there is now a new board variant called nologo_esp32c3_super_mini. However, it seems to take forever for this new board definition to show up in the Arduino Core production build.

If you don’t want to wait, you can copy the file content and add it manually to your Arduino Core.

Key Benefits of the ESP32-C3 Super Mini

• Compact: The board is extremely small (22.5x18mm), making it ideal for space-constrained projects.
• User-Friendly: Compatible with platforms like PlatformIO and ESPHome. It eliminates the need for manual firmware upload mode or pressing “boot” buttons.
• Low Power: Highly energy-efficient with Bluetooth BLE support, making it suitable for battery-powered devices.
• Expandable: Optional battery shields add charging functionality and portable power supply options.
• Affordable: Widely available, occasionally priced under €1.50.

GPIOs

The board includes a USB-C connector and provides 10 fully usable GPIOs. Additionally, four GPIOs support analog input:

In the pin schematic, D denotes a digital-only GPIO. Always use the actual GPIO number shown in the schematic to avoid confusion with legacy labeling.

Interfaces

The ESP32-C3 supports all important communication interfaces:

• Two-Wire Serial Interface (UART)
• I2C: Ideal for connecting sensors and displays.
• SPI: Suitable for high-speed communication, such as with flash storage or displays.

Interfaces can be implemented either through software emulation or by utilizing hardware-optimized GPIOs.

• Try and use designated GPIOs: It is highly recommended to use the hardware-optimized GPIOs (see tables below) whenever possible. This significantly improves speed, reduces the workload on the microcontroller, and helps lower overall energy consumption.
• Custom GPIOs are slower: Software emulation should be used only when you must utilize alternative GPIOs or when the interfaces are required infrequently, with low speed or minimal data throughput, such as for reading simple sensor data.

Serial Interface

Note the use of build_flags in the suggested platformio.ini from earlier:

Microcontrollers like the ESP32-C3 include full native USB support. They no longer use UART components. The built-in USB controller can act as any USB device and i.e. simulate a keyboard or mouse.

When you want to use serial output - since there is no dedicated UART anymore - you need to ask the USB controller to act as a HWCDC (Hardware USB Communications Device Class). This is what the build flags do.

In this case, the USB controller simulates a COM interface, and you can continue to use code like Serial.println("Hello"); just as if you were using an older microcontroller with external UART. If you do not include the build flags, then Serial would not work, and your code would be unable to send text to a terminal.

There are a few caveats you should know:

• Serial.begin(); some sources claim that USB CDC does not require this statement anymore. That’s not true. You still need to initialize your serial connection. However, you no longer need to care about baud rates any longer. USB CDC always uses the maximum USB speed which is much higher than even the highest baud rates would allow. That’s also the reason why you no longer need a monitor_speed = ... in your platformio.ini.
• while (!Serial) {} often, a loop is used to wait for the Serial interface to be fully initialized and ready to use. This may not work anymore with USB CDC. You will have to work around this with a fixed `delay(1000);’.

SPI

I2C

The I2C interface GPIO assignments have been poorly picked by the board designers. SDA is on GPIO8. This GPIO is also wired to the built-in LED.

If you do not care about the built-in LED, then use the default hardware I2C pins for optimal performance. If however you want to keep the ability to control this LED without interfering with I2C, use software I2C by assigning other suitable GPIOs like these:

GPIO

The ESP32-C3 features 22 GPIOs of which the C3 SuperMini exposes 13 (due to its compact size).

Of these 13 GPIOs, 10 are freely usable, while the remaining 3 are strapping pins and cannot be used during boot.

All GPIOs are multifunctional and can be configured for various purposes, such as digital I/O, ADC (Analog-to-Digital Converter), UART, SPI, I2C, PWM, and more.

Ten GPIOs For You

These 10 GPIO pins can be freely used:

Three GPIOs As Backup

If you require more GPIOs, these three can be used with some restrictions. Ensure your circuitry doesn’t pull any of these up or down by hardware.

These strapping pins are only used during boot (when the firmware isn’t yet active), so you can use them freely in your software (firmware), just make sure your wiring doesn’t tamper with their state, or your board may not boot properly.

JTAG is available on GPIO4-GPIO7.

Strapping Pins

The strapping pins control the boot behavior during the boot process:

Programmable LED

GPIO8 is controlling a built-in blue LED. This LED is inverted; it is sinked, not sourced: low turns the LED on, and high turns it off.

Additionally, the board has a red power LED, which lights up when the board is connected to 5V via its internal voltage regulator. If the board is powered through the 3.3V pin (e.g., via a battery), the red LED automatically turns off, conserving energy in low-power scenarios.

Programming

The ESP32-C3 Super Mini is widely adopted and simple to use.

PlatformIO

In PlatformIO, use the board ESP32-C3-DevKitM-1 and the variant esp32c3.

[env:esp32-c3-devkitm-1]
platform = espressif32
board = esp32-c3-devkitm-1
board_build.mcu = esp32c3
framework = arduino
build_flags =
    -D ARDUINO_USB_MODE=1
    -D ARDUINO_USB_CDC_ON_BOOT=1

ESPHome

In ESPHome configurations, use the board id esp32-c3-devkitm-1 and the variant esp32c3:

esp32:
  board: esp32-c3-devkitm-1
  variant: esp32c3

You can adjust and override specs if needed:

esphome:
  name: c3-supermini-test
  friendly_name: C3 SuperMini Test
  platformio_options:
    board_build.f_flash: 40000000L
    board_build.flash_mode: dio
    board_build.flash_size: 4MB

esp32:
  board: esp32-c3-devkitm-1
  variant: esp32c3
  framework:
    type: arduino

light:
  - platform: status_led
    name: "Status LED"
    id: esp_status_led
    icon: "mdi:alarm-light"
    pin:
      number: GPIO8
      inverted: true
    restore_mode: ALWAYS_OFF

Caveat: Defective Board Designs

Although the ESP32-C3 Super Mini is widely available, subtle differences in board designs have emerged. In 2024, a revised board layout began appearing, which may negatively affect WiFi connectivity.

The image compares the original board design (left) with the revised layout (right). In the updated version, the crystal has been moved closer to the ceramic WiFi antenna. The gap between antenna and crystal should measure at least 1.0 mm. Affected boards show a gap of just 0.3 mm.

WiFi Sending Impaired

Users with the flawed board design have reported the following issues:

• While scanning for WiFi networks works, connecting to networks is either impossible or very slow.
• Connecting to WiFi sometimes requires physically touching the antenna to reduce transmission power.
• Connectivity issues worsen when female pin headers are added, particularly when wires are connected to pin 21 (near the antenna).

All reports point to interference during WiFi transmission, likely caused by the crystal’s relocation closer to the antenna. This interference appears to disrupt the signal during transmission. Touching the antenna seems to alleviate the problem: a reduction of transmission power reduces the interference.

Workaround

First of all: defective boards can still be used for many tasks that do not involve WiFi.

If you need the board to use WiFi, avoid connections to pin 21, and minimize nearby wiring. Pin 21 is closest to the antenna, and wiring in this area seems to induce interference.

A more practical approach is to simply reduce the transmission power in the first place, preventing the interference from reaching critical levels.

To reduce transmission power, include the following code snippet in your project:

WiFi.setTxPower(WIFI_POWER_8_5dBm);

In ESPHome, the WiFi Component offers the option output_power and can be set to 8.5dB.

Most home WiFi environments have great coverage and do not need the full 20dB default transmission power, especially when considering the bad antenna that won’t bring much of this RF energy into the air anyway. Lowering transmission power generally reduces energy consumption, heat, and interference. You may want to consider this even with unaffected ESP32-C3 SuperMini.

The vast majority of C3 SuperMini boards use a flawless design. Only a selected batch in 2024 was affected by this unfortunate design decision.

Here is the original article: ESP32-C3 SuperMini Flaw.

Performance

The ESP32-C3 is over twice as fast as an ESP8266, thanks to its single-core processor running at 160MHz. Additionally, it features a robust voltage regulator, which is an improvement over the under-rated regulators often found in ESP8266 boards that can brown out when powering power-hungry sensors.

However, it is outperformed by classic ESP32S boards, which feature dual-core processors running at 240MHz, offering roughly three times the computational power. This increased performance comes with higher power consumption, which may not be ideal for energy-sensitive projects.

For most DIY applications, the ESP32-C3’s performance is more than sufficient. If your project involves computationally intensive tasks or demands real-time responsiveness for multiple tasks, consider using a classic ESP32S or the newer ESP32-S3.

Here’s a quick performance comparison:

Key Notes on Performance

• ESP32-C3: While slower than the dual-core ESP32S, the C3 is energy-efficient and well-suited for most IoT projects. Its processing speed is more than sufficient for tasks like sensor data handling, simple automation, and communication.
• ESP8266: Limited memory and lower processing power make it less ideal for modern projects but still suitable for simple use cases.
• ESP32S: A dual-core powerhouse for applications requiring heavy computation, real-time responsiveness, or support for memory-intensive tasks.

Board Schematics

Slow Website?

This website is very fast, and pages should appear instantly. If this site is slow for you, then your routing may be messed up, and this issue does not only affect done.land, but potentially a few other websites and downloads as well. Here are simple steps to speed up your Internet experience and fix issues with slow websites and downloads..

Comments

Please do leave comments below. I am using utteran.ce, an open-source and ad-free light-weight commenting system.

  Show on Github    Submit Issue

^{_{(content created Aug 28, 2024 - last updated Jan 23, 2025)}}