Estardyn ESP32-C3 SuperMini

Contents

Estardyn ESP32-C3 SuperMini Development Board User Manual

Model: ESP32-C3 SuperMini | Brand: Estardyn

1. Introduction

The Estardyn ESP32-C3 SuperMini is a compact IoT development board built around the Espressif ESP32-C3 WiFi/Bluetooth dual-mode chip. It features a 32-bit RISC-V CPU with a Floating Point Unit (FPU) for powerful computing. Designed for low-power IoT applications and wireless wearable devices, this board offers excellent RF performance, supporting IEEE 802.11 b/g/n WiFi and Bluetooth 5 (LE) protocols.

Its small form factor and single-sided surface mount design make it ideal for various projects. The board provides a rich set of interfaces, including 11 digital I/O pins (usable as PWM) and 4 analog input pins (usable as ADC). It also supports four serial communication interfaces: UART, I2C, and SPI. For ease of use, it includes a reset button and a bootloader mode button.

Front and back view of the Estardyn ESP32-C3 SuperMini development board with pin headers.
Figure 1: Estardyn ESP32-C3 SuperMini Development Board (Front and Back)

2. Specifications

2.1. General Properties

Property Value
Brand Name Estardyn
Condition New
Type Module
Application Computer
Package SMD
Origin Mainland China
Quantity 1
High-concerned chemical None
is_customized Yes

2.2. Technical Parameters

  • CPU: ESP32-C3, 32-bit RISC-V single-core processor, up to 160 MHz
  • WiFi: 802.11b/g/n protocol, 2.4GHz, supports Station mode, SoftAP mode, SoftAP+Station mode, hybrid mode
  • Bluetooth: Bluetooth 5.0 (LE)
  • Power Consumption: Ultra-low deep sleep power consumption of about 43µA
  • Memory: 400KB SRAM, 384KB ROM, built-in 4MFlash
  • Chip Model: ESP32C3FN4
  • Size: Ultra-small, approximately 22.52mm x 18mm (as small as a thumb)
  • Security Features: Encryption hardware accelerators (AES-128/256, hashing, RSA, HMAC, digital signatures, secure startup)
  • Interfaces: 1xI2C, 1xSPI, 2xUART, 11xGPIO (PWM capable), 4xADC
  • Design: Single-sided components, surface mount design
  • Onboard LED: Blue light on GPIO8 pin
  • Supply Voltage: 3.3V-6V
  • Operating Temperature: -15°C to +85°C
Dimensions of the ESP32-C3 SuperMini board.
Figure 2: Board Dimensions (15.24mm x 22.52mm)
Pinout diagram of the ESP32-C3 SuperMini development board.
Figure 3: ESP32-C3 SuperMini Pinout

3. Setup

3.1. Software Setup (Arduino IDE)

  1. Download Arduino IDE: Download and install the latest version of the Arduino IDE compatible with your operating system from the official Arduino website.
  2. Start Arduino Application: Launch the Arduino IDE.
  3. Add ESP32 Board Package:
    • Navigate to File > Preferences.
    • In the Preferences window, locate the field labeled "Additional Boards Manager URLs".
    • Add the following URL to this field: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
    • Click OK to save the preferences.
    Screenshot of Arduino IDE preferences showing where to add the Additional Boards Manager URL.
    Figure 4: Adding Boards Manager URL in Arduino IDE Preferences
  4. Install ESP32 Boards:
    • Navigate to Tools > Board > Boards Manager...
    • In the Boards Manager window, search for "esp32".
    • Select the latest version of the "esp32 by Espressif Systems" package and click "Install".
    Screenshot of Arduino IDE Boards Manager, showing how to search and install 'esp32' boards.
    Figure 5: Installing ESP32 Boards via Boards Manager
  5. Select ESP32-C3 Dev Module:
    • Navigate to Tools > Board > ESP32 Arduino.
    • From the list, select "ESP32C3 Dev Module". You may need to scroll down to find it.
    Screenshot of Arduino IDE board selection menu, highlighting 'ESP32C3 Dev Module'.
    Figure 6: Selecting ESP32C3 Dev Module
  6. Select Serial Port:
    • Navigate to Tools > Port.
    • Select the serial port name corresponding to your connected ESP32C3 SuperMini (e.g., COM3 or higher on Windows, /dev/ttyUSB0 on Linux/macOS). COM1 and COM2 are typically reserved for hardware serial ports.

3.2. Hardware Connections

3.2.1. USB Serial Port

The ESP32-C3 SuperMini features a USB Type-C port for power and data communication. By default, the USB serial port is enabled, allowing direct connection to your PC for programming and serial monitoring.

3.2.2. UART Serial Port

If you intend to use the dedicated UART pins (GPIO20 and GPIO21) for serial communication, you will need an external USB serial adapter. Connect pin 20 (TX) and pin 21 (RX) to your adapter. Additionally, ensure that the "USB CDC On Boot" option in the Arduino IDE is set to "Disabled" to prevent conflicts with the external UART.

Wiring diagram for connecting the ESP32-C3 SuperMini to a USB serial adapter for UART communication, showing pin 20 (TX) and pin 21 (RX).
Figure 7: UART Serial Port Connection

3.2.3. External Power Supply

The board supports an external power supply in the range of 3.3V to 6V. Connect the positive (+) terminal of your external power supply to the 5V pin and the negative (-) terminal to the GND pin. Note that when using an external power supply, you cannot simultaneously use the USB port for power. Only one power source (USB or external) should be connected at a time.

⚠️ WARNING: When soldering or connecting, be extremely careful not to short-circuit the positive and negative electrodes, as this can damage the board or power source.

Diagram showing external power supply connection points (5V, GND) and a warning about short-circuiting.
Figure 8: External Power Supply Connection

3.2.4. External WiFi Antenna

For applications requiring enhanced signal strength, an external WiFi antenna can be connected. Refer to the diagram below for the correct connection points for the wire core and shielding layer.

⚠️ IMPORTANT: Some USB cables are power-only and do not transmit data. Ensure you use a data-capable USB Type-C cable for programming and serial communication. If unsure, consider purchasing a dedicated data cable.

Diagram showing connection points for an external WiFi antenna (wire core and shielding layer) and a warning about USB cables.
Figure 9: External WiFi Antenna Connection

4. Operating Instructions

4.1. Digital Pin Usage: Flashing an LED

This example demonstrates how to make the onboard LED (connected to GPIO8) flash at a 1-second interval.

  1. Copy the following code into your Arduino IDE:
  2. int led = 8; // define led according to pin diagram
    
    void setup() {
      pinMode(led, OUTPUT); // initialize digital pin led as an output
    }
    
    void loop() {
      digitalWrite(led, HIGH); // turn the LED on
      delay(1000); // wait for a second
      digitalWrite(led, LOW); // turn the LED off
      delay(1000); // wait for a second
    }
  3. Upload the code to your ESP32-C3 SuperMini board.

After uploading, the onboard LED will begin flashing with a 1-second delay between each flash.

Arduino code snippet for flashing an onboard LED.
Figure 10: Flashing LED Code

4.2. Digital Pin Usage: Dimming an LED with Potentiometer

This example shows how to gradually dim an LED and how to control an LED's flashing interval using a potentiometer.

4.2.1. Gradual Dimming

  1. Copy the following code into your Arduino IDE:
  2. int ledPin = 8; // LED connected to digital pin 8
    
    void setup() {
      pinMode(ledPin, OUTPUT);
    }
    
    void loop() {
      // fade in from min to max in increments of 5 points:
      for (int fadeValue = 0; fadeValue <= 255; fadeValue += 5) {
        analogWrite(ledPin, fadeValue); // sets the value (range from 0 to 255)
        delay(30); // wait for 30 milliseconds to see the dimming effect
      }
    
      // fade out from max to min in increments of 5 points:
      for (int fadeValue = 255; fadeValue >= 0; fadeValue -= 5) {
        analogWrite(ledPin, fadeValue);
        delay(30);
      }
    }
  3. Upload the code to your ESP32-C3 SuperMini board.

The onboard LED will gradually dim and brighten.

Arduino code snippet for gradually dimming an onboard LED.
Figure 11: Gradual LED Dimming Code

4.2.2. Potentiometer Control

Connect a potentiometer to analog pin A5. The potentiometer will control the flashing interval of the LED.

  1. Connect the potentiometer to pin A5 as shown in the diagram (if available, otherwise refer to general wiring for potentiometers).
  2. Copy the following code into your Arduino IDE:
  3. const int sensorPin = A5;
    const int ledPin = 8;
    
    void setup() {
      pinMode(sensorPin, INPUT); // declare the sensorPin as an INPUT
      pinMode(ledPin, OUTPUT); // declare the ledPin as an OUTPUT
    }
    
    void loop() {
      // read the value from the sensor:
      int sensorValue = analogRead(sensorPin);
      // turn the LedPin on
      digitalWrite(ledPin, HIGH);
      // stop the program for <sensorValue> milliseconds:
      delay(sensorValue);
      // turn the LedPin off:
      digitalWrite(ledPin, LOW);
      // stop the program for <sensorValue> milliseconds:
      delay(sensorValue);
    }
  4. Upload the code to your ESP32-C3 SuperMini board.

Turning the potentiometer knob will now adjust the flashing interval of the LED.

Arduino code snippet for controlling LED brightness with a potentiometer, and an image showing the board connected to a potentiometer.
Figure 12: Potentiometer Controlled LED Flashing

4.3. WiFi Usage

The ESP32-C3 SuperMini can operate in Station (STA) mode to connect to existing WiFi networks or scan for available networks.

4.3.1. Scanning WiFi Networks

This example configures the board in Station mode to scan for available WiFi networks.

  1. Copy the following code into your Arduino IDE:
  2. #include <WiFi.h>
    
    void setup() {
      Serial.begin(115200);
      // Set WiFi to station mode and disconnect from an AP if it was previously connected
      WiFi.mode(WiFi_STA);
      WiFi.disconnect();
      delay(100);
      Serial.println("Setup done");
    }
    
    void loop() {
      Serial.println("scan start");
      // WiFi.scanNetworks will return the number of networks found
      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) {
          // Print SSID and RSSI for each network found
          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("");
      // Wait a bit before scanning again
      delay(5000);
    }
  3. Upload the code to your board.
  4. Open the Serial Monitor in the Arduino IDE (set baud rate to 115200).

The Serial Monitor will display a list of available WiFi networks and their signal strengths.

Instructions and Arduino code for scanning WiFi networks in Station Mode.
Figure 13: WiFi Network Scan Code
Screenshot of Arduino Serial Monitor displaying WiFi network scan results.
Figure 14: Serial Monitor Output for WiFi Scan

4.3.2. Connecting to a WiFi Network

This example demonstrates how to connect your ESP32-C3 SuperMini to a specific WiFi network.

  1. Copy the following code into your Arduino IDE:
  2. #include <WiFi.h>
    
    const char* ssid = "your-ssid"; // Your WiFi network name
    const char* password = "your-password"; // Your WiFi password
    
    void setup() {
      Serial.begin(115200);
      delay(10);
    
      // We start by connecting to a WiFi network
      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.println("IP address: ");
      Serial.println(WiFi.localIP());
    }
    
    void loop() {
      // Your main code here
    }
  3. Modify `ssid` and `password`: Replace "your-ssid" and "your-password" with your actual WiFi network credentials.
  4. Upload the code to your board.
  5. Open the Serial Monitor (set baud rate to 115200).

The Serial Monitor will show the connection progress and, upon successful connection, the assigned IP address.

Instructions and Arduino code for connecting to a WiFi network.
Figure 15: WiFi Connection Code
Screenshot of Arduino Serial Monitor displaying successful WiFi connection with IP address.
Figure 16: Serial Monitor Output for WiFi Connection

4.4. IIC (OLED Display)

This section guides you through connecting and displaying text on a 0.96-inch OLED display using the IIC interface.

  1. Hardware Connection: Connect the OLED display to the ESP32C3 SuperMini as follows:
  2. ESP32C3SuperMini 0.96" OLED
    5V VCC
    GND GND
    SCL SCL
    SDA SDA
    Wiring diagram and code for connecting a 0.96 OLED display to the ESP32C3SuperMini via IIC.
    Figure 17: OLED Display IIC Connection
  3. Install U8g2 Library:
    • Open the Arduino IDE and navigate to Sketch > Include Library > Manage Libraries...
    • Search for "u8g2" and install the library.
  4. Upload Code: Upload the following code to display a text string on the OLED display:
  5. #include <Arduino.h>
    #include <U8g2lib.h>
    
    #ifdef U8X8_HAVE_HW_SPI
    #include <SPI.h>
    #endif
    #ifdef U8X8_HAVE_HW_I2C
    #include <Wire.h>
    #endif
    
    U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
    
    void setup() {
      u8g2.begin();
      u8g2.setFlipMode(1); // set number from 1 to 3, the screen word will rotary 180
    }
    
    void loop() {
      u8g2.clearBuffer(); // clear the internal memory
      u8g2.setFont(u8g2_font_ncenB08_tr); // choose a suitable font
      u8g2.drawStr(0,15,"Hello World!"); // write something to the internal memory
      u8g2.drawStr(0,40,"Hello World!");
      u8g2.sendBuffer(); // transfer internal memory to the display
      delay(1000);
    }

4.5. SPI Interface

For displays using the ST7735S driver chip, the SPI interface is commonly used. Here's how to set it up using Adafruit libraries.

  1. Install Adafruit Libraries:
    • Download the Adafruit-ST7735-Library from https://github.com/adafruit/Adafruit-ST7735-Library.
    • Install it manually by placing the unzipped folder into your Arduino libraries directory, or use the Arduino Library Manager to search for and install "Adafruit ST7735" and "Adafruit GFX Library".
  2. Upload Code: Use the following simple code as a starting point for driving an ST7735S display:
  3. #include <Adafruit_GFX.h>
    #include <Adafruit_ST7735.h>
    
    #define TFT_SCLK 2 //SCL
    #define TFT_MOSI 3 //SDA
    #define TFT_RST 10 //RES
    #define TFT_DC 6 //DC
    #define TFT_CS 7 //CS
    //____TFT_BL 不接
    
    Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_MOSI, TFT_SCLK, TFT_RST);
    
    void setup() {
      tft.initR(INITR_BLACKTAB);
      tft.fillScreen(ST7735_RED);
      tft.setTextColor(ST7735_YELLOW);
      tft.setTextSize(2);
      tft.setCursor(10,30);
      tft.print("Hello ST7735!");
    }
    
    void loop() {
      // Your main code here
    }
Arduino code snippet for using an ST7735S SPI display driver.
Figure 18: SPI Display Code Example

4.6. ESP32 C3 SuperMini Pin Usage

The ESP32C3 SuperMini offers a variety of interfaces, including 11 digital I/O pins (PWM capable) and 4 analog input pins (ADC capable). It also supports UART, I2C, SPI, and I2S. The default pin mapping for the ESP32C3 Dev Module in Arduino IDE can be referenced for your projects. Below is a code snippet illustrating common pin assignments:

static const uint8_t TX = 21;
static const uint8_t RX = 20;

static const uint8_t SDA = 8;
static const uint8_t SCL = 9;

static const uint8_t SS = 7;
static const uint8_t MOSI = 6;
static const uint8_t MISO = 5;
static const uint8_t SCK = 4;

static const uint8_t A0 = 0;
static const uint8_t A1 = 1;
static const uint8_t A2 = 2;
static const uint8_t A3 = 3;
static const uint8_t A4 = 4;
static const uint8_t A5 = 5;
Pin mapping for the ESP32-C3 SuperMini, showing digital and analog pin assignments.
Figure 19: ESP32-C3 SuperMini Pin Map

5. Maintenance

The Estardyn ESP32-C3 SuperMini development board is designed for durability and requires minimal maintenance. Keep the board clean and free from dust and moisture. Avoid exposing it to extreme temperatures or static electricity. When not in use, store it in an anti-static bag or container.

Regularly check connections for any loose wires or components, especially after prolonged use or modifications. Do not attempt to repair the board if you are not experienced with electronics, as this may cause further damage.

6. Troubleshooting

Q1: COM port cannot be recognized on Arduino

If your ESP32-C3 SuperMini's COM port is not appearing or being recognized in the Arduino IDE, try the following methods:

  • Method 1: Press and hold the BOOT button while powering on the board.
  • Method 2: Press and hold down the BOOT button. While holding BOOT, press the RESET button. Release the RESET button, then release the BOOT button. This sequence should put the ESP32-C3 into download mode.

Note: Each time you need to re-enter download mode for uploading, you might need to repeat these steps. Sometimes, port instability can occur; you may hear a sound indicating port connection/disconnection.

Q2: The program will not run after uploading

After a successful program upload, you must press the RESET button on the ESP32-C3 SuperMini board to execute the newly uploaded program.

Q3: The ESP32C3SuperMini Arduino serial port cannot be printed

If you are not seeing output on the Arduino Serial Monitor, ensure that the "USB CDC On Boot" option in the Arduino IDE's toolbar (under Tools > USB CDC On Boot) is set to "Enabled".

7. User Tips

  • Always double-check your wiring before powering on the board to prevent accidental short circuits.
  • When experimenting with new sensors or modules, start with simple code examples to verify basic functionality before integrating into complex projects.
  • Utilize the Arduino Serial Monitor extensively for debugging your code and understanding the board's behavior.
  • Keep your Arduino IDE and ESP32 board packages updated to benefit from the latest features and bug fixes.
  • For advanced projects, explore the Espressif documentation for the ESP32-C3 chip to leverage its full capabilities.

8. Warranty and Support

For technical support, additional resources, or warranty inquiries, please contact the Estardyn Flagship Store directly through the platform where the product was purchased. Ensure you have your purchase details and product model number readily available.

Ask a question about this manual

Ask about setup, troubleshooting, compatibility, parts, safety, or missing instructions. Manuals+ will review the question and use this page’s manual context to help answer it.

After a successful submission, we securely hash the supplied account or form email before sending it to Microsoft Advertising for conversion attribution. Privacy details.