1. Product Introduction

The ESP32-C3 SuperMini is an IoT mini development board based on the Espressif ESP32-C3 WiFi and Bluetooth Low Energy chip. The ESP32-C3 uses a 32-bit RISC-V single-core processor running up to 160 MHz and provides enough computing power for many connected embedded applications.

The board supports IEEE 802.11 b/g/n WiFi in the 2.4 GHz band and Bluetooth 5 Low Energy. It is designed for low-power IoT systems, wireless sensor nodes, wearable electronics and small automation projects.

Thanks to its small size and single-sided surface-mount design, the ESP32-C3 SuperMini is easy to place inside compact enclosures. It also includes a USB Type-C connector, BOOT button, RESET button, onboard LED and multiple GPIO pins for sensors and modules.

2. Product Parameters and Main Features

3. ESP32-C3 SuperMini Pinout and Interfaces

The ESP32-C3 SuperMini provides digital GPIO pins, ADC inputs, SPI, I2C and UART. The commonly used default mapping is shown below:

4. External Power Supply

The ESP32-C3 SuperMini can be powered through the USB Type-C connector. Some board versions also allow external power input through the 5V and GND pins. Connect the positive terminal of the external supply to 5V and the negative terminal to GND.

For battery-powered projects, use a stable 5 V power module or a safe 3.3 V regulated supply depending on the pin you use. Never feed more than the allowed voltage into the 3V3 pin.

5. Hardware Setup

To start programming the ESP32-C3 SuperMini, prepare the following components:

• 1 × ESP32-C3 SuperMini development board
• 1 × Computer with Windows, Linux or macOS
• 1 × USB Type-C data cable
• Optional: 0.96 inch I2C OLED display
• Optional: potentiometer for ADC testing
• Optional: USB-to-serial adapter for UART testing

6. Software Setup: Install ESP32-C3 in Arduino IDE

The easiest way to program the ESP32-C3 SuperMini is to use the Arduino IDE with the Espressif ESP32 board package.

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

7. First Test: Flashing the Onboard LED

The first test is to blink the onboard LED. On many ESP32-C3 SuperMini boards, the blue onboard LED is connected to GPIO8.

const int led = 8;   // On-board blue LED on GPIO8

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

void loop() {
  digitalWrite(led, HIGH);  // LED ON
  delay(1000);
  digitalWrite(led, LOW);   // LED OFF
  delay(1000);
}

Upload the sketch. After uploading, the onboard LED should turn ON and OFF every second.

8. ESP32-C3 SuperMini WiFi Functions

The ESP32-C3 supports 2.4 GHz WiFi and can work in Station mode, Access Point mode and mixed modes. This makes it useful for IoT nodes, web servers, dashboards, sensor monitoring and local control systems.

8.1 Scan Available WiFi Networks

The following code scans nearby WiFi networks and prints the SSID, RSSI signal level and encryption indicator in the Serial Monitor.

#include <WiFi.h>

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

  // Configure ESP32-C3 as WiFi station and disconnect from previous AP
  WiFi.mode(WIFI_STA);
  WiFi.disconnect();
  delay(100);

  Serial.println("Setup done");
}

void loop() {
  Serial.println("Scan start");

  int n = WiFi.scanNetworks();
  Serial.println("Scan done");

  if (n == 0) {
    Serial.println("No networks found");
  } else {
    Serial.print(n);
    Serial.println(" networks found");

    for (int i = 0; i < n; ++i) {
      Serial.print(i + 1);
      Serial.print(": ");
      Serial.print(WiFi.SSID(i));
      Serial.print(" (");
      Serial.print(WiFi.RSSI(i));
      Serial.print(")");
      Serial.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN) ? " " : " *");
      delay(10);
    }
  }

  Serial.println("");
  delay(5000);
}

8.2 Connect to a WiFi Network

Replace YOUR_WIFI_NAME and YOUR_WIFI_PASSWORD with your own WiFi credentials. After successful connection, the board prints its local IP address.

#include <WiFi.h>

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

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

  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("WiFi connected");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
}

void loop() {
}

8.3 Create a WiFi Hotspot / Access Point

The ESP32-C3 SuperMini can also create its own WiFi network. This is useful for configuration portals, local dashboards and offline IoT systems.

#include <WiFi.h>

const char* ap_ssid = "ESP_AP";
const char* ap_password = "123456789";  // Minimum 8 characters

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

  WiFi.softAP(ap_ssid, ap_password);

  Serial.print("Host Name: ");
  Serial.println(WiFi.softAPgetHostname());
  Serial.print("Host IP: ");
  Serial.println(WiFi.softAPIP());
  Serial.print("Host SSID: ");
  Serial.println(WiFi.SSID());
  Serial.print("Host MAC Address: ");
  Serial.println(WiFi.softAPmacAddress());
}

void loop() {
  Serial.print("Number of connected stations: ");
  Serial.println(WiFi.softAPgetStationNum());
  delay(1000);
}

9. Bluetooth Low Energy Functions

The ESP32-C3 supports Bluetooth Low Energy, which is useful for low-power communication with smartphones, sensors and nearby devices.

9.1 Scan Bluetooth Devices

This example scans nearby BLE devices and prints the results in the Serial Monitor.

#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEScan.h>
#include <BLEAdvertisedDevice.h>

int scanTime = 5; // seconds
BLEScan* pBLEScan;

class MyAdvertisedDeviceCallbacks : public BLEAdvertisedDeviceCallbacks {
  void onResult(BLEAdvertisedDevice advertisedDevice) {
    Serial.printf("Advertised Device: %s\n", advertisedDevice.toString().c_str());
  }
};

void setup() {
  Serial.begin(115200);
  Serial.println("Scanning...");

  BLEDevice::init("");
  pBLEScan = BLEDevice::getScan();
  pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
  pBLEScan->setActiveScan(true);
  pBLEScan->setInterval(100);
  pBLEScan->setWindow(99);
}

void loop() {
  BLEScanResults foundDevices = pBLEScan->start(scanTime, false);
  Serial.print("Devices found: ");
  Serial.println(foundDevices.getCount());
  Serial.println("Scan done!");
  pBLEScan->clearResults();
  delay(2000);
}

9.2 Use ESP32-C3 SuperMini as a Bluetooth Server

In this example, the ESP32-C3 SuperMini acts as a BLE server named MyESP32. A smartphone can connect to it using an application such as LightBlue and send a text string to the board.

#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>

#define SERVICE_UUID        "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"

class MyCallbacks : public BLECharacteristicCallbacks {
  void onWrite(BLECharacteristic *pCharacteristic) {
    std::string value = pCharacteristic->getValue();

    if (value.length() > 0) {
      Serial.println("**********");
      Serial.print("New value: ");
      for (int i = 0; i < value.length(); i++) {
        Serial.print(value[i]);
      }
      Serial.println();
      Serial.println("**********");
    }
  }
};

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

  BLEDevice::init("MyESP32");
  BLEServer *pServer = BLEDevice::createServer();
  BLEService *pService = pServer->createService(SERVICE_UUID);

  BLECharacteristic *pCharacteristic = pService->createCharacteristic(
    CHARACTERISTIC_UUID,
    BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_WRITE
  );

  pCharacteristic->setCallbacks(new MyCallbacks());
  pCharacteristic->setValue("Hello World");
  pService->start();

  BLEAdvertising *pAdvertising = pServer->getAdvertising();
  pAdvertising->start();

  Serial.println("BLE server started. Search for MyESP32.");
}

void loop() {
  delay(2000);
}

9.3 Test with LightBlue App

1. Upload the BLE server code to the ESP32-C3 SuperMini.
2. Open the Serial Monitor at 115200 baud.
3. Install and open the LightBlue app on your smartphone.
4. Enable Bluetooth and search for the device named MyESP32.
5. Connect to the device and open the writable characteristic.
6. Select UTF-8 string format.
7. Write the word Hello.
8. The ESP32-C3 will print the received value in the Serial Monitor.

10. ChatGPT / AI Application Idea with ESP32-C3 SuperMini

The ESP32-C3 SuperMini can be used as part of an AI-connected IoT project. For example, you can build a small web page served by the board, let the user submit a question, send the request to a backend server, and display the answer returned by an AI service.

Suggested Architecture

1. Connect the ESP32-C3 SuperMini to WiFi.
2. Create a small embedded web page or send data through HTTP/MQTT.
3. Forward the question to your secure backend server.
4. The backend sends the request to the AI API.
5. The response is sent back to the ESP32-C3 and displayed on Serial Monitor or OLED.

11. Digital Pins, PWM and Analog Input

The ESP32-C3 SuperMini includes digital pins that can be used for LEDs, relays, sensors and other modules. Some GPIO pins can also generate PWM signals, and several pins support analog input through the ADC.

11.1 Digital Pin Example

This is the same onboard LED blinking example using GPIO8:

const int led = 8;   // On-board blue LED on GPIO8

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

void loop() {
  digitalWrite(led, HIGH);  // LED ON
  delay(1000);
  digitalWrite(led, LOW);   // LED OFF
  delay(1000);
}

11.2 Digital PWM Example

This example gradually dims the onboard LED using PWM.

const int ledPin = 8;

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

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

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

11.3 Analog Pin Example

Connect a potentiometer output to an ADC pin such as A5. This code reads the analog value and changes the LED flashing speed depending on the potentiometer position.

const int sensorPin = A5;
const int ledPin = 8;

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

void loop() {
  int sensorValue = analogRead(sensorPin);

  digitalWrite(ledPin, HIGH);
  delay(sensorValue);

  digitalWrite(ledPin, LOW);
  delay(sensorValue);
}

12. Serial Port and USB CDC

By default, the ESP32-C3 SuperMini communicates with your computer through USB serial. This is why you can open the Arduino IDE Serial Monitor and see messages printed with Serial.println().

The board also exposes hardware UART pins. A common mapping is GPIO20 as RX and GPIO21 as TX. When using a USB-to-serial adapter, connect adapter TX to ESP32 RX, adapter RX to ESP32 TX and GND to GND. Use only a 3.3 V logic serial adapter.

13. I2C OLED Display Connection

The ESP32-C3 SuperMini can easily control a 0.96 inch OLED display using the I2C interface. A common wiring is:

Install the U8g2 library from Sketch → Include Library → Manage Libraries, then upload this test code:

#include <Arduino.h>
#include <U8g2lib.h>
#include <Wire.h>

// ESP32-C3 SuperMini default I2C: SDA = GPIO8, SCL = GPIO9
U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE);

void setup() {
  Wire.begin(8, 9);
  u8g2.begin();
}

void loop() {
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_ncenB08_tr);
  u8g2.drawStr(0, 20, "ESP32-C3 SuperMini");
  u8g2.drawStr(0, 40, "OLED I2C Test");
  u8g2.sendBuffer();
  delay(1000);
}

14. FAQ and Troubleshooting