MicroPython: The Mini Power of Embedded Systems!

▼ Click the card below to follow me

▲ Click the card above to follow me

—— Another “universe” for Python enthusiasts

Today, we won’t talk about elephants dancing or the myriad of web development topics; instead, let’s dive straight into a niche but super cool topic—MicroPython. This is like a “mini clone” of Python, specifically designed to run on embedded devices, such as the Raspberry Pi Pico, ESP32, or even some tiny gadgets that look like they only have a remote control. Don’t underestimate these little guys; they can really do a lot, like creating IoT projects, DIY smart lights, or automatic cat feeders, and they can do it in no time. Just think about it, a “lazy” language like Python can easily jump into embedded systems; who says hardware development must be done in C?

What exactly is MicroPython?

Let’s strip this thing down to its basics. MicroPython is Python “slimmed down” to the extreme, fitting into small boards with only a few hundred KB of memory. You know, embedded devices have memory constraints similar to our wallets—there’s never enough. It retains most of Python’s syntax and core functionalities, including variables, loops, functions, and modules. For example, if you want to write a “light on” program, you don’t have to deal with those maddening C pointers; just one line of Python, and the light flashes. Here’s a piece of code to turn on a light (pretend you have an ESP8266 development board):

import machine
import time
led = machine.Pin(2, machine.Pin.OUT)
while True:
    led.value(1)  # Light on
    time.sleep(0.5)
    led.value(0)  # Light off
    time.sleep(0.5)

This creates a “breathing light” effect. It’s quite similar to writing Python on a PC, just with fewer frills.

Tip: Many beginners tend to misuse print(), but MicroPython’s serial output can sometimes have delays or may not connect at all. Don’t blame the board for “hanging”; it’s likely that your connections aren’t secure.

Common Data Types and the “Mini” Standard Library

The data types in MicroPython are similar to standard Python, including strings, lists, and dictionaries, with most common operations available. However, the standard library is “slimmed down”; core modules like os, sys, socket, and time are still there, but forget about pandas or matplotlib. After all, the storage space on these boards is smaller than your fridge.

Here’s a simple example to play with dictionaries and lists:

sensors = ['Temperature', 'Humidity', 'Light Intensity']
data = {'Temperature': 25, 'Humidity': 60, 'Light Intensity': 120}
for name in sensors:
    print(name, data[name])

This code is almost identical to what you’d write on a PC, and it runs smoothly.

Tip: Some functions, like open() for writing files, depend on whether your board supports a file system. Some development boards don’t have this feature, and trying to use it will result in an error. If you really want to store data, check the official documentation for your board.

The Magical Module for “Playing with Hardware”: machine

One of the key components of MicroPython is the machine module. It acts as your “magic wand” for controlling hardware. You can use it to control GPIO pins, operate I2C and SPI buses, and even play with PWM (like adjusting a motor to spin like a fan).

Turning on a light or reading a button is just the tip of the iceberg. Here’s another piece of code to control an LED with a button:

import machine
import time
led = machine.Pin(2, machine.Pin.OUT)
button = machine.Pin(0, machine.Pin.IN)
while True:
    if button.value() == 1:
        led.value(1)
    else:
        led.value(0)
    time.sleep(0.01)

Pressing the button turns the light on, and releasing it turns it off. Isn’t it more exciting than playing with circuit boards as a kid?

Tip: Some boards have specific voltage and input/output modes for their pins, so don’t just connect any pin to a light; burning out the chip won’t get you a refund. It’s best to check the pinout diagram of your board before writing code.

Timers, PWM, and Mastering “Fancy Signals”

When playing with embedded systems, signal control is an art. Terms like Timer and PWM (Pulse Width Modulation) sound impressive, but they’re not hard to use. For example, using PWM to make an LED “fade in and out” can create some ambient lighting, earning you the title of “DIY Prince” in no time.

import machine
import time
led = machine.PWM(machine.Pin(2))
led.freq(1000)  # Set PWM frequency
for duty in range(0, 1024, 10):
    led.duty(duty)
    time.sleep(0.01)
for duty in range(1023, -1, -10):
    led.duty(duty)
    time.sleep(0.01)

This code gradually brightens and dims the LED, providing a satisfying experience.

Tip: The duty range and freq settings for PWM may vary between boards, so it’s best to check the documentation before coding. Don’t go all out and find that the board isn’t responding.

Exception Handling and the “Debugging Tool” REPL in MicroPython

Don’t think that embedded systems lack exception handling. MicroPython supports try...except, and if an error occurs, it will report it, providing an experience almost identical to that on a PC. Even more interesting is that MicroPython has something called REPL, which allows you to connect via serial or WiFi and input Python code like chatting, seeing results in real-time. Debugging hardware becomes a hands-on “hot-swappable” experience. Here’s an example:

try:
    import machine
    pin = machine.Pin(99, machine.Pin.OUT)  # Pretend pin 99 exists
except Exception as e:
    print("Error occurred:", e)

If you mistype the pin number, it will directly catch the exception and output the error, preventing the board from mysteriously blacking out.

Tip: In the REPL interface, pressing Ctrl+C can interrupt the current program, and Ctrl+D can soft reboot. If you mess things up, you can always “revive” the board; don’t worry about bricking it.

Conclusion

MicroPython is like Python’s “mini warrior,” capable of soaring on embedded boards. Key syntax, data types, modules, and exception handling are all present, making coding smooth and hardware debugging convenient. The only downside is its “thin wallet”; the standard library is reduced, and storage space is limited. When writing code, pay attention to the characteristics of your board and avoid directly copying PC methods. If you want to play with smart homes, IoT, or simply want to experience the thrill of “lighting up the world with Python,” MicroPython is definitely a great choice. Take some time to tinker with a development board; even if it’s just to make a light blink, it will be more satisfying than scrolling through short videos.

Like and share

Let money and love flow to you