Getting Started with ESP32-C3 SuperMini and MicroPython

I’ve worked with hardware before, so the electronics themselves were never the problem. What consistently slowed me down was the software side. C, C++, and the Arduino ecosystem always felt like too much friction: verbose syntax, constant recompiling, and error messages that broke me. I wanted to spend my time building things, not fighting toolchains.

Python, on the other hand, has always been my go-to language. I use it for almost everything: backend services, automation, data processing, and quick experiments. It’s expressive, readable, and lets me move fast. At some point the question became unavoidable: if Python works so well for everything else I do, why wouldn’t I use it on the ESP32 too?

So I started playing with **[MicroPython](https:/…

So I started playing with MicroPython. It allows me to bring the same mindset and workflow I already have with Python into the world of microcontrollers. I can experiment quickly, interact with the board in real time through an REPL, and write code that actually looks like the Python I use every day: just running on a tiny, Wi-Fi–enabled device. For me, the combination of ESP32 and MicroPython removed the last real barrier between software and hardware.

Toward the end of last year, I started using ESP32 boards with MicroPython more seriously. What began as small experiments quickly turned into something genuinely useful: a personal home-assistant-style setup. I placed several ESP32 boards around the house, each connected to a DHT11 temperature sensor, and had them periodically send temperature data to a backend I built myself. On the server side, I used QuestDB as a time-series database and Django to build dashboards that visualized temperature trends across rooms and over time.

It isn’t’t a commercial product or a polished system, but it works. More importantly, it showed me just how powerful and approachable hardware development can be when Python is part of the stack.

In this article, I want to share that experience with you. I’ll introduce you to the ESP32-C3 SuperMini, explain why I think it’s a fantastic board for learning, and show you how to get started programming it using MicroPython. If you’ve ever been curious about hardware, IoT, or simply want to see your Python code interact with the real world, this is exactly where I’d suggest starting.

Meet the ESP32-C3 SuperMini

The ESP32-C3 SuperMini is a tiny development board that manages to pack a surprising amount of power into a very small footprint. It’s only a few centimetres across, but it gives you everything you need to build connected projects: Wi-Fi, GPIO pins, and a USB-C connection. All on a single board.

This combination of size, simplicity, and capability is exactly what makes it such a great board for learning and experimenting.

Key features

ESP32-C3 chip: At the heart of the board is the ESP32-C3, a single-core RISC-V processor running at up to 160 MHz. That’s more than enough power for typical IoT tasks like reading sensors, controlling outputs, and communicating over Wi-Fi.

Built-in USB-to-serial: The board includes an onboard USB interface, which means you can program it and communicate with it directly over USB-C. There’s no need for external programmers or adapters, just plug it into your computer and you’re ready to go.

GPIO pins: Along the edges of the board you’ll find several general-purpose input/output (GPIO) pins. These are what you’ll use to connect LEDs, buttons, sensors, and other external components.

Built-in LED: Most ESP32-C3 SuperMini boards include an onboard LED (commonly connected to GPIO 8). This is perfect for quick tests and your first MicroPython “Hello, world” moment.

Pinout basics

The ESP32-C3 SuperMini exposes its GPIO and power pins along both sides of the board. While the exact layout can vary slightly depending on the manufacturer, you’ll usually find:

Digital GPIO pins (GPIO0, GPIO1, GPIO2, etc.)
Analog-capable pins (GPIO0 to GPIO5), which can be used to read analogue values
Power pins (3.3V and GND)
Pins that can be used for common protocols like UART, I²C, or SPI

For most beginner projects, you don’t need to worry about the advanced functions at all. You’ll mainly use a few GPIO pins and the power rails. One of the nice things about MicroPython is that you can simply refer to pins by their number, no complex configuration required.

Powering the board

At this stage, you don’t need to worry about understanding all the power pins in detail. The ESP32-C3 SuperMini can be powered directly through its USB-C port. Simply plug it into your computer or any standard 5V USB power adapter, and it will start up immediately.

The board is also quite power-efficient, which makes it a good candidate for battery-powered projects later on.

In addition to USB power, the board exposes a 3.3V pin. You can use this pin to power low-power sensors and accessories, such as temperature sensors or small modules, directly from the ESP32.

Note: here you see the ESP32-C3 Super Mini without the pin headers soldered onto the board. The pin headers allows to connect the ESP32 with sensors and other devices, either with direct cables (plug and play) or on a breadboard. For the simple examples later on, you can use the board without the pin headers, but for connecting other devices like sensors, you will need them. If you are not comfortable soldering, you can get already soldered kits.

What You Need to Get Started

One of the things I really like about the ESP32-C3 SuperMini is how little you need to get going. There’s no big shopping list and no complex setup, you can be up and running very quickly.

Hardware

ESP32-C3 SuperMini board: You can find these easily from places like AliExpress or Amazon. They’re inexpensive, so I usually keep a few around for experiments.

USB-C cable: Make sure it’s a proper data cable, not just a charging-only cable. This is what you’ll use to power the board and talk to it from your computer.

That’s it. For the first projects, the board is completely self-contained, no extra components required.

Software

Python 3: Since MicroPython is based on Python, having Python 3 installed on your computer is helpful. If you already use Python, you’re good to go.

Thonny IDE: This is what I’ll be using throughout the article. Thonny is a beginner-friendly Python IDE with excellent built-in support for MicroPython. It takes care of flashing firmware and gives you an interactive REPL out of the box, which makes life much easier.

esptool: This is the tool used under the hood to flash firmware onto ESP32 boards. You usually don’t need to install it manually, as Thonny handles this for you.

Everything here is free and open source, and the setup is painless.

Installing MicroPython on the ESP32-C3

Before you can start coding, the first step is to flash MicroPython firmware onto your ESP32-C3 SuperMini.

Don’t worry, this is a one-time setup and only takes a few minutes, especially if you use Thonny.

Step 1: Firmware

MicroPython firmware for the ESP32-C3 is available from the official MicroPython website: https://micropython.org/download/esp32c3/.

Look for the latest stable release (usually something like ESP32_GENERIC_C3-20251209-v1.27.0.bin).

Pro tip: You don’t actually need to download the file yourself, Thonny can handle both downloading and flashing the firmware for you, which makes the process much simpler. Still, it’s good to know where the firmware comes from and how to get it in case you ever need it.

Step 2: Install Thonny

Go to https://thonny.org/ and download Thonny for your system (Windows, macOS, or Linux), install it and launch it:

Thonny is great for beginners because it combines a Python IDE with built-in MicroPython support.

Step 3: Connect Your ESP32-C3

Plug your ESP32-C3 SuperMini into your computer via USB-C and wait a few seconds for your computer to recognize it.

Thonny should recognize it and you can select it in the bottom right corner (in this case mine is connected to port COM13 on Windows):

Step 4: Flash MicroPython Using Thonny

Flashing the firmware in Thonny is surprisingly easy, go to Tools → Options → Interpreter and select MicroPython (ESP32) as the interpreter:

Click Install or update MicroPython, select your board (ESP32-C3), variant and version. Also make sure the port is correct:

Then click on install and you should see a similar message as Thonny installs the MicroPython firmware onto the ESP32-C3 SuperMini board:

After a few seconds, the firmware will be installed and you should see the ‘Done!’ message:

Tip: If your board doesn’t show up, try putting it into bootloader mode by holding the BOOT button while plugging it in.

Thonny should now recognize the Micro Python firmware on the board and present the REPL shell:

If it doesn’t recognize, then press the ‘Stop’ button to reset the connection to the board.

Step 5: Verify the Installation

You can verify the installation by typing the following in the REPL shell:

print("Hello, ESP32!")

If your message prints back in the shell, congratulations, MicroPython is installed and working:

Your First MicroPython Program

Now that MicroPython is installed, it’s time to write your first piece of code. In Thonny, you have two ways to work: you can type commands directly into the REPL for quick experiments, or write a script in the editor and save it to the board.

If you want to tighten up your fundamentals before going deeper into MicroPython, I’ve put together a free PDF guide on Python variable scope. It’s a topic that comes up more often than you’d expect, even in embedded projects.

Using the REPL

The REPL (Read–Eval–Print Loop) lets you execute Python code line by line and see the result immediately. It’s perfect for testing things out and getting a feel for how the board behaves.

Try typing the following into Thonny’s shell:

>>> import machine
>>> led = machine.Pin(8, machine.Pin.OUT, value=1)
>>> led.off()

If your board has an onboard LED, it should turn on right away, notice the blue LED:

You can then type:

>>> led.on()

to turn it back off.

That might feel a bit counterintuitive at first, calling off() to turn the LED on and on() to turn it off. What’s happening here is that on() and off() simply control whether the pin outputs a 1 or a 0.

On the ESP32-C3 SuperMini, the onboard LED is wired as active-low, meaning it turns on when the pin is set to 0. Once you know this, it makes sense, and it’s a good reminder that hardware behaviour sometimes depends on how things are wired.

Saving a script

Once your code grows beyond a few lines, it makes sense to save it as a script on the board instead of typing everything into the REPL.

Here’s how I usually do it in Thonny:

Write your code in Thonny’s editor
Click File → Save As…
Choose MicroPython device and save the file as main.py

Any file named main.py is automatically executed when the board boots, which makes it ideal for standalone projects. You can also run the script manually at any time by clicking the Play button in Thonny.

Blinking the Built-in LED with MicroPython

Blinking an LED is the "Hello World" of embedded programming. It’s simple, visual, and teaches you the fundamentals of GPIO control.

Let’s now dig in a bit deeper in understanding the GPIO pins and the MicroPython code to interact with them.

Understanding GPIO Pins

GPIO stands for General-Purpose Input/Output.

These pins can be configured as either inputs (to read sensors or buttons) or outputs (to control LEDs, motors, etc.).

In MicroPython, controlling GPIO pins is straightforward using the machine module.

Here’s a complete program to blink the built-in LED (typically on GPIO8 for ESP32-C3 SuperMini):

from machine import Pin
import time

# Configure GPIO8 as an output pin
led = Pin(8, Pin.OUT, value=1)

# Blink the LED 10 times
for i in range(10):
led.off()      # Turn LED on (set pin LOW)
time.sleep(0.5)  # Wait 0.5 seconds
led.on()     # Turn LED off (set pin HIGH)
time.sleep(0.5)  # Wait 0.5 seconds

print("Blinking complete!")

Let’s break down what each part does:

from machine import Pin: Imports the Pin class, which is used to control GPIO pins
import time: Imports the time module for delays
led = Pin(8, Pin.OUT, value=1): Creates a Pin object on GPIO8 configured as an output. This tells the microcontroller: "I want to control pin 8 and send signals out (not read signals in)". It also starts it with value 1.
led.on(): Sets the pin to HIGH (3.3V), which turns off the LED
led.off(): Sets the pin to LOW (0V), which turns on the LED
time.sleep(0.5): Pauses program execution for 0.5 seconds, creating the blinking effect

Running the Code

Copy the code into Thonny’s editor
Click the green "Run" button (or press F5)
Watch your LED blink!

Note: Make sure that your board is selected with the bottom right interpreter selector.

Here is the LED blinking in action:

Conclusion

If you’ve made it this far, you’ve already taken your first real steps into the world of IoT development with ESP32 and MicroPython, and that’s a big win.

In this article, you’ve seen:

Why ESP32 + MicroPython is such a powerful and approachable combination
How to set up the ESP32-C3 SuperMini and flash it with MicroPython
How to control real hardware by blinking an LED with just a few lines of Python

What I really like about this setup is the balance it strikes. The ESP32-C3 SuperMini is small, powerful, and affordable, and MicroPython lets you work with it using clean, familiar Python instead of low-level embedded code. From here, you can read sensors, connect to Wi-Fi, run web servers, and start building real IoT projects without unnecessary complexity.

In the next article, we’ll take this a step further by connecting a temperature sensor and exposing the readings through a simple web page, turning the ESP32 into a tiny, self-contained web-enabled device.

Follow me on Twitter: https://twitter.com/DevAsService

Follow me on Instagram: https://www.instagram.com/devasservice/

Follow me on TikTok: https://www.tiktok.com/@devasservice

Follow me on YouTube: https://www.youtube.com/@DevAsService