ESP32-C3 Super Mini Deep-Sleep MQTT Sensor: Wiring, Code & Debugging

The ESP32-C3 Super Mini is a $3 RISC-V powerhouse that strips away the bloat of the original ESP32 to deliver a single-core, 160MHz chip with native USB Serial/JTAG and ultra-low deep-sleep current. If you want to build a battery-powered MQTT climate node, this board is the current benchmark for cost-to-performance. However, the unbranded clone boards common on Amazon and AliExpress have specific hardware quirks—namely aggressive 3.3V LDO voltage drops and native USB boot-strapping requirements—that will brick your first upload attempt if you aren't prepared.

This guide targets the Generic ESP32-C3 Super Mini V1.1 (Native USB variant). We will wire an SHT30 I2C sensor, write robust deep-sleep firmware with raw I2C and MQTT error handling, and debug the exact USB-JTAG errors that plague first-time C3 users.

Hardware Specs & Pin Mapping

Before wiring, you must verify which Super Mini variant you have. The V1.1 Native USB variant routes the USB-C D+ and D- lines directly to GPIO19 and GPIO18, utilizing the chip's internal USB Serial/JTAG controller. Cheaper variants route USB to a CH340 serial chip. The code and boot procedures below assume the Native USB variant.

Project Pin Mapping (SHT30 I2C)

Project Build: Deep-Sleep MQTT Climate Node

This build reads temperature and humidity, publishes to an MQTT broker over WiFi, and immediately enters deep sleep to conserve battery. We bypass the Adafruit SHT31 library and use raw I2C commands to reduce flash footprint and eliminate dependency bloat.

Parts List

• MCU: ESP32-C3 Super Mini V1.1 (Native USB-C, 4MB Flash)
• Sensor: Sensirion SHT30 I2C Breakout (Adafruit 2857 or generic equivalent)
• Power: 3.7V LiPo Battery (e.g., 500mAh) + TP4056 USB-C charging module
• Passives: 100µF electrolytic capacitor (critical for brownout prevention), 2x 4.7kΩ pull-up resistors

Wiring & Assembly Steps

1. Prep the Breadboard: The Super Mini is exactly 0.9 inches wide, meaning it will cover the center trench of a standard breadboard and leave exactly one row of holes exposed on each side. Use jumper wires to bridge the exposed pins to the main rails.
2. Add the Decoupling Capacitor: Solder or plug the 100µF capacitor directly across the 3V3 and GND rails. Why? The SOT-23-5 LDO on these clone boards struggles to supply the 350mA peak current required during WiFi TX bursts, causing instantaneous voltage sags.
3. Wire the I2C Bus: Connect GPIO4 to SDA and GPIO5 to SCL. If your SHT30 breakout lacks onboard pull-ups, wire the 4.7kΩ resistors from SDA and SCL to the 3V3 rail.
4. Power Injection: Connect the TP4056's BAT+ and BAT- to the LiPo. Connect the TP4056's OUT+ to the ESP32's 5V pin (which feeds the onboard LDO) or directly to 3V3 if you bypass the LDO for maximum efficiency.

Complete Firmware: WiFi MQTT with Error Handling

The following code targets the Arduino IDE with the Espressif ESP32 Core (v2.0.14 or later). Select "ESP32C3 Dev Module" in the Boards menu, enable "USB CDC On Boot", and set "Flash Mode" to QIO.

#include <WiFi.h>
#include <PubSubClient.h>
#include <Wire.h>

// --- Pin Definitions ---
#define PIN_SDA 4
#define PIN_SCL 5
#define PIN_RGB_LED 8
#define PIN_BOOT_BTN 9

// --- Network & MQTT Config ---
const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";
const char* mqtt_server = "192.168.1.100";
const int mqtt_port = 1883;
const char* mqtt_topic_temp = "home/climate/c3mini/temperature";
const char* mqtt_topic_humi = "home/climate/c3mini/humidity";

// --- Timing ---
#define uS_TO_S_FACTOR 1000000ULL
#define TIME_TO_SLEEP  300 // 5 minutes

WiFiClient espClient;
PubSubClient client(espClient);

void setup() {
  Serial.begin(115200);
  delay(500); // Allow serial monitor to attach

  // Initialize I2C with explicit pins and 400kHz fast mode
  Wire.begin(PIN_SDA, PIN_SCL);
  Wire.setClock(400000);

  // 1. Read Sensor via Raw I2C
  float tempC = 0.0;
  float humi = 0.0;
  bool sensorSuccess = readSHT30(&tempC, &humi);

  if (!sensorSuccess) {
    Serial.println("ERROR: SHT30 I2C timeout or CRC fail.");
    goToSleep(); // Don't waste battery transmitting bad data
  }

  // 2. Connect to WiFi
  if (!connectWiFi()) {
    Serial.println("ERROR: WiFi connection timeout.");
    goToSleep();
  }

  // 3. Publish to MQTT
  client.setServer(mqtt_server, mqtt_port);
  if (client.connect("ESP32C3_SuperMini")) {
    char tempStr[8];
    char humiStr[8];
    dtostrf(tempC, 1, 2, tempStr);
    dtostrf(humi, 1, 2, humiStr);
    
    client.publish(mqtt_topic_temp, tempStr);
    client.publish(mqtt_topic_humi, humiStr);
    Serial.printf("Published: %s C, %s %%\n", tempStr, humiStr);
    
    // Brief pause to ensure MQTT packets leave the buffer
    delay(100);
    client.disconnect();
  } else {
    Serial.printf("ERROR: MQTT connect failed, rc=%d\n", client.state());
  }

  // 4. Disconnect WiFi and Sleep
  WiFi.disconnect(true);
  WiFi.mode(WIFI_OFF);
  goToSleep();
}

void loop() {
  // Execution never reaches here due to deep sleep in setup()
}

bool readSHT30(float* t, float* h) {
  // Send measurement command (High repeatability)
  Wire.beginTransmission(0x44);
  Wire.write(0x2C);
  Wire.write(0x06);
  if (Wire.endTransmission() != 0) return false;

  delay(20); // Wait for measurement (15ms max)

  Wire.requestFrom(0x44, 6);
  if (Wire.available() < 6) return false;

  uint8_t data[6];
  for (int i = 0; i < 6; i++) data[i] = Wire.read();

  // CRC checks omitted for brevity, but recommended for production
  uint16_t rawTemp = (data[0] << 8) | data[1];
  uint16_t rawHumi = (data[3] << 8) | data[4];

  *t = -45.0 + 175.0 * ((float)rawTemp / 65535.0);
  *h = 100.0 * ((float)rawHumi / 65535.0);
  return true;
}

bool connectWiFi() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  
  int attempts = 0;
  while (WiFi.status() != WL_CONNECTED && attempts < 40) {
    delay(250);
    attempts++;
  }
  return WiFi.status() == WL_CONNECTED;
}

void goToSleep() {
  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
  Serial.println("Entering deep sleep...");
  Serial.flush();
  esp_deep_sleep_start();
}

Debugging: First Three Things to Check When It Fails

The ESP32-C3's native USB interface and RISC-V architecture introduce failure modes that don't exist on the older ESP8266 or standard ESP32. If your upload fails or the board resets randomly, check these three things first.

1. The "No Serial Data Received" Boot Trap

Exact Error String: A fatal error occurred: Failed to connect to ESP32-C3: No serial data received.

The Cause: The C3's native USB-JTAG controller does not automatically reset the chip into download mode like a CH340 or CP2102 bridge does. If GPIO9 (Boot) is HIGH during reset, it boots to Flash, ignoring the upload.

The Fix: You must manually force download mode. Click "Upload" in the Arduino IDE. When the console says Connecting..., press and hold the BOOT button (GPIO9) on the board, then tap the RST button (if your board has one) or quickly unplug and replug the USB cable. Release the BOOT button once the upload percentage starts climbing.

2. The Windows USB-JTAG Driver Conflict

Exact Error String: esptool.py: error: argument --port: could not open port 'COMX': PermissionError(13, 'Access is denied.') or the port simply doesn't appear in the IDE.

The Cause: Windows often binds the generic CDC driver to the C3's USB interface, which blocks esptool from accessing the JTAG layer required for flashing.

The Fix: Download Zadig. Plug in the board, open Zadig, select "ESP32-S3 USB JTAG/serial debug unit" (it shares the same USB PID/VID family as the C3 in many clone implementations, or look for the RISC-V USB device), and replace the driver with WinUSB. Restart the Arduino IDE.

3. The Clone Board Brownout Reset

Exact Error String: Brownout detector was triggered (followed by a stack dump and reboot).

The Cause: When the WiFi radio powers up, it draws a transient spike of ~350mA. The tiny LDO on the Super Mini clone boards suffers from severe voltage drop under this load, dropping the 3.3V rail below the brownout threshold (usually ~2.4V).

The Fix: Ensure the 100µF capacitor is installed directly at the board's 3V3 and GND pins. If the issue persists, lower the WiFi TX power in code by adding WiFi.setTxPower(WIFI_POWER_8_5dBm); immediately after WiFi.mode(WIFI_STA);. This caps the peak current draw at the cost of slightly reduced range.

Extending and Simplifying the Build

Depending on your deployment environment, you may need to strip this project down to its bare essentials or scale it up for industrial reliability.

How to Simplify: Drop MQTT for ESP-NOW

If you don't have a WiFi network at the deployment site, or if the MQTT broker connection takes too long (burning battery), switch to ESP-NOW. ESP-NOW is a connectionless, low-latency protocol that allows the C3 to wake up, transmit a raw MAC-addressed payload to a central ESP32 gateway, and go back to sleep in under 200 milliseconds. You eliminate the WiFi association and DHCP handshake entirely, cutting active awake time by 80%.

How to Extend: True Nano-Amp Sleep with TPL5110

The ESP32-C3's deep sleep current is roughly 5µA, but the Super Mini board's LDO and USB-C port protection diodes add 20-50µA of parasitic drain. If you are running a 2000mAh 18650 cell and need 2+ years of life, the board's quiescent draw is your bottleneck.

The Fix: Add a TPL5110 Timer Breakout between your battery and the ESP32's 5V/VIN pin. The TPL5110 acts as a hardware gate, completely severing power to the ESP32-C3 until the timer expires. It draws only 30 nano-amps. Wire the TPL5110's "Done" pin to a GPIO on the C3 (e.g., GPIO10). At the end of your setup() routine, right before sleep, pull GPIO10 HIGH to signal the TPL5110 to cut the power.

For authoritative reference on the C3's strapping pins and deep-sleep wake stubs, consult the Espressif ESP32-C3 Datasheet and the Arduino ESP32 Core Documentation.