Python for IoT: MicroPython

In recent years, the Internet of Things (IoT) has gained immense popularity as more and more devices are connected to the internet. This has created a need for lightweight programming languages that can run on small devices with limited resources. One such language is MicroPython, which is a subset of the popular Python programming language. In this article, we will explore the features of MicroPython and how it can be used for IoT applications.

Introduction to MicroPython

MicroPython is an open-source implementation of Python 3, specifically designed for microcontrollers and other resource-constrained environments. It brings the power and simplicity of Python to the world of IoT, making it easier than ever to develop embedded systems and prototype IoT devices.

MicroPython is highly efficient, with a small memory footprint and fast execution speeds, making it suitable for a wide range of applications, from simple LED control to complex sensor networks and communication systems.

MicroPython-Compatible Devices

Several microcontroller platforms support MicroPython, including the following popular choices:

  • ESP8266: A low-cost Wi-Fi microchip with a full TCP/IP stack and microcontroller capability.
  • ESP32: A more powerful, dual-core microcontroller with built-in Wi-Fi and Bluetooth capabilities.
  • Pyboard: The official MicroPython board, featuring a powerful STM32 microcontroller.
  • BBC micro:bit: A small, pocket-sized computer designed for education, featuring an ARM Cortex-M0 microcontroller.

Other MicroPython-compatible boards include the Adafruit Feather HUZZAH, the WiPy and the LoPy, among others. Make sure to check the documentation for each platform before starting your project to ensure compatibility and feature support.

Installing MicroPython on Your Device

Before you can start using MicroPython, you’ll need to install it on your microcontroller. The installation process varies depending on the specific device you’re using, but generally involves the following steps:

  1. Download the appropriate MicroPython firmware for your device from the official MicroPython website.
  2. Connect your device to your computer using a USB cable or another appropriate connection method.
  3. Use a firmware flashing tool to upload the MicroPython firmware to your device.

For detailed, device-specific installation instructions, consult the documentation for your chosen platform.

Basic Usage of MicroPython

Once MicroPython is installed on your device, you can start interacting with it using a serial connection. Most MicroPython-compatible devices provide a serial REPL (Read-Eval-Print Loop) interface, allowing you to enter Python commands and see the results in real time.

You can connect to the serial REPL using a terminal emulator, such as PuTTY or screen, or a more specialized tool like Mu or Thonny. Consult the documentation for your chosen device and software for detailed instructions on establishing a serial connection.

With a serial connection established, you can start exploring the MicroPython environment. Try entering some simple Python commands to get a feel for how the REPL works:

>>> print("Hello, MicroPython!")
Hello, MicroPython!
>>> 2 + 3

Working with GPIO Pins

General-purpose input/output (GPIO) pins are a fundamental part of working with microcontrollers. These pins allow you to connect your device to various sensors, actuators and other components.

MicroPython makes it easy to work with GPIO pins using the machine module. The following code demonstrates how to configure a GPIO pin as an output and toggle its state:

from machine import Pin

# Set up a GPIO pin as an output
pin = Pin(5, Pin.OUT)

# Toggle the pin's state
pin.value(not pin.value())

To use a GPIO pin as an input, simply configure it as such and read its value:

from machine import Pin

# Set up a GPIO pin as an input with a pull-up resistor
pin = Pin(4, Pin.IN, Pin.PULL_UP)

# Read the pin's value

Interfacing with Sensors and Actuators

MicroPython makes it easy to interface with a wide range of sensors and actuators, from simple buttons and LEDs to more complex devices like accelerometers, temperature sensors and motors. Many common devices have dedicated MicroPython libraries or can be easily integrated using built-in modules.

For example, to control an LED, you can use the same Pin class we used earlier:

from machine import Pin
import time

# Set up a GPIO pin as an output
led = Pin(2, Pin.OUT)

# Blink the LED in a loop
while True:
    led.value(1)  # Turn the LED on
    time.sleep(1)  # Wait for 1 second
    led.value(0)  # Turn the LED off
    time.sleep(1)  # Wait for 1 second

To read data from a DHT11 temperature and humidity sensor, you can use the dht module:

from machine import Pin
import dht
import time

# Set up the DHT11 sensor
sensor = dht.DHT11(Pin(14))

# Read the temperature and humidity in a loop
while True:
    sensor.measure()  # Trigger a measurement
    temp = sensor.temperature()  # Read the temperature (in Celsius)
    hum = sensor.humidity()  # Read the humidity (in percentage)
    print("Temperature:", temp, "C, Humidity:", hum, "%")
    time.sleep(2)  # Wait for 2 seconds before the next measurement

Communicating with External Device

MicroPython supports a variety of communication protocols, such as I2C, SPI and UART, allowing you to communicate with other microcontrollers, sensors and peripherals.

For example, to read data from an I2C device, you can use the machine module’s I2C class:

from machine import I2C, Pin

# Set up the I2C interface
i2c = I2C(scl=Pin(5), sda=Pin(4))

# Scan for I2C devices
devices = i2c.scan()
print("Found I2C devices:", devices)

# Read data from an I2C device (replace DEVICE_ADDRESS with the actual address)
register_address = 0x00
data = i2c.readfrom_mem(DEVICE_ADDRESS, register_address, 1)
print("Read data:", data)


In this article, we’ve provided an introduction to MicroPython for IoT, covering the basics of installation, usage and working with GPIO pins, sensors, actuators and communication protocols. With this foundation, you can start exploring the world of IoT using Python and MicroPython, creating embedded systems and prototypes for a wide range of applications.

The MicroPython community is continually growing and new libraries and resources are constantly being developed. To learn more about MicroPython, consult the official documentation, browse the [MicroPython forum]( and explore the many tutorials, projects and examples available online.