Mastering the MicroPython Network Library

MicroPython is a lean and efficient implementation of the Python 3 programming language that includes a small subset of the Python standard library and is optimized to run on microcontrollers and constrained systems. The MicroPython network library is a powerful tool that enables these resource - limited devices to connect to networks, communicate with other devices, and access the internet. This blog post will provide a comprehensive guide to the MicroPython network library, covering its fundamental concepts, usage methods, common practices, and best practices.

Table of Contents#

  1. Fundamental Concepts
  2. Usage Methods
    • Connecting to a Wi - Fi Network
    • Creating a TCP Server
    • Creating a TCP Client
  3. Common Practices
    • Error Handling
    • Timeout Management
  4. Best Practices
    • Resource Management
    • Code Modularity
  5. Conclusion
  6. References

Fundamental Concepts#

The MicroPython network library provides a high - level interface for network communication. It abstracts the underlying hardware details and allows developers to use familiar Python constructs for network programming.

Network Interfaces#

MicroPython supports different network interfaces such as Wi - Fi, Ethernet, and Bluetooth. Each interface is represented by a class in the network module. For example, the WLAN class is used to manage Wi - Fi connections, and the Ethernet class is used for Ethernet connections.

Socket Programming#

At the core of network communication in MicroPython is socket programming. A socket is an endpoint for sending or receiving data across a network. The socket module in MicroPython provides a standard BSD socket interface. Sockets can be used to create TCP or UDP connections.

TCP and UDP#

  • TCP (Transmission Control Protocol): It is a connection - oriented protocol that provides reliable, ordered, and error - checked delivery of a stream of bytes between applications running on hosts communicating via an IP network.
  • UDP (User Datagram Protocol): It is a connectionless protocol that provides a simple way to send and receive datagrams over a network. UDP does not guarantee delivery, order, or error - checking.

Usage Methods#

Connecting to a Wi - Fi Network#

The following code shows how to connect a MicroPython device to a Wi - Fi network:

import network
 
# Create a WLAN object
wlan = network.WLAN(network.STA_IF)
 
# Activate the network interface
wlan.active(True)
 
# Connect to the Wi - Fi network
wlan.connect('your_SSID', 'your_PASSWORD')
 
# Wait for the connection
import time
while not wlan.isconnected():
    time.sleep(1)
 
print('Connected to Wi - Fi:', wlan.ifconfig())

Creating a TCP Server#

The following code creates a simple TCP server that listens for incoming connections and echoes back any data it receives:

import socket
 
# Create a socket object
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
# Bind the socket to a specific address and port
server_address = ('', 8080)
server_socket.bind(server_address)
 
# Listen for incoming connections
server_socket.listen(1)
 
print('Waiting for a connection...')
 
while True:
    # Accept a connection
    client_socket, client_address = server_socket.accept()
    print('Connection from', client_address)
 
    # Receive data from the client
    data = client_socket.recv(1024)
    if data:
        # Echo the data back to the client
        client_socket.sendall(data)
 
    # Close the client socket
    client_socket.close()

Creating a TCP Client#

The following code creates a simple TCP client that connects to the server created above and sends some data:

import socket
 
# Create a socket object
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
# Connect to the server
server_address = ('192.168.1.100', 8080)
client_socket.connect(server_address)
 
# Send some data
message = 'Hello, server!'
client_socket.sendall(message.encode())
 
# Receive the response
data = client_socket.recv(1024)
print('Received:', data.decode())
 
# Close the socket
client_socket.close()

Common Practices#

Error Handling#

Network operations can fail due to various reasons such as network congestion, connection timeout, or incorrect server addresses. It is important to handle these errors gracefully in your code. The following code shows how to handle socket errors when creating a TCP client:

import socket
 
try:
    # Create a socket object
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
    # Connect to the server
    server_address = ('192.168.1.100', 8080)
    client_socket.connect(server_address)
 
    # Send some data
    message = 'Hello, server!'
    client_socket.sendall(message.encode())
 
    # Receive the response
    data = client_socket.recv(1024)
    print('Received:', data.decode())
 
except OSError as e:
    print('Socket error:', e)
finally:
    # Close the socket
    if 'client_socket' in locals():
        client_socket.close()

Timeout Management#

When making network requests, it is a good practice to set a timeout to avoid hanging indefinitely. The following code shows how to set a timeout when creating a TCP client:

import socket
 
# Create a socket object
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
# Set a timeout of 5 seconds
client_socket.settimeout(5)
 
try:
    # Connect to the server
    server_address = ('192.168.1.100', 8080)
    client_socket.connect(server_address)
 
    # Send some data
    message = 'Hello, server!'
    client_socket.sendall(message.encode())
 
    # Receive the response
    data = client_socket.recv(1024)
    print('Received:', data.decode())
 
except OSError as e:
    print('Socket error:', e)
finally:
    # Close the socket
    client_socket.close()

Best Practices#

Resource Management#

Network resources such as sockets should be properly managed to avoid resource leaks. Always close sockets after use, especially in case of errors. The finally block in Python can be used to ensure that sockets are closed even if an exception occurs.

Code Modularity#

Break your network code into smaller functions and classes to improve readability and maintainability. For example, you can create a function to handle the connection to a Wi - Fi network:

import network
import time
 
def connect_to_wifi(ssid, password):
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    wlan.connect(ssid, password)
    while not wlan.isconnected():
        time.sleep(1)
    return wlan
 
# Usage
wlan = connect_to_wifi('your_SSID', 'your_PASSWORD')
print('Connected to Wi - Fi:', wlan.ifconfig())

Conclusion#

The MicroPython network library provides a powerful and flexible way to enable network communication on microcontrollers and constrained systems. By understanding the fundamental concepts, usage methods, common practices, and best practices, you can develop robust and efficient network applications using MicroPython. Whether you are building a simple IoT device or a more complex network - enabled system, the MicroPython network library is a valuable tool in your toolkit.

References#

2025-10