MicroPython Non-Blocking Serial Input: An In - Depth Guide

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. Serial communication is a fundamental way for microcontrollers to interact with other devices, such as computers, sensors, or actuators. In many real - world applications, we need to perform other tasks while waiting for data on the serial port. This is where non - blocking serial input comes into play. Non - blocking serial input allows the microcontroller to continue executing other code without getting stuck waiting for data to arrive on the serial port.

Table of Contents#

  1. Fundamental Concepts
  2. Usage Methods
  3. Common Practices
  4. Best Practices
  5. Code Examples
  6. Conclusion
  7. References

1. Fundamental Concepts#

Blocking vs Non - Blocking I/O#

  • Blocking I/O: When using blocking I/O for serial input, the program will pause its execution and wait indefinitely until data is available on the serial port. This can be a problem if the program needs to perform other time - sensitive tasks, such as updating a display or controlling a motor.
  • Non - Blocking I/O: Non - blocking I/O allows the program to check if data is available on the serial port. If data is available, it can be read; if not, the program can continue with other tasks. This is achieved by periodically polling the serial port to see if new data has arrived.

Serial Communication in MicroPython#

In MicroPython, serial communication is typically handled through the machine.UART class. The UART class provides methods to configure the serial port (such as baud rate, number of data bits, etc.) and read/write data.

2. Usage Methods#

Initializing the Serial Port#

To use non - blocking serial input, first, you need to initialize the serial port. Here is an example of initializing a serial port on a MicroPython - enabled microcontroller:

import machine
 
# Initialize UART on pins 0 and 1 with a baud rate of 9600
uart = machine.UART(0, 9600)

Checking for Available Data#

The any() method of the UART class can be used to check if there is any data available on the serial port. If the method returns a non - zero value, it means there is data waiting to be read.

if uart.any():
    data = uart.read()
    print('Received data:', data)

3. Common Practices#

Polling the Serial Port#

The most common way to implement non - blocking serial input is to periodically poll the serial port in the main loop of your program. This way, the program can check for new data at regular intervals while still performing other tasks.

import machine
import time
 
uart = machine.UART(0, 9600)
 
while True:
    if uart.any():
        data = uart.read()
        print('Received data:', data)
    # Do other tasks
    time.sleep(0.1)

Buffer Management#

When using non - blocking serial input, it's important to manage the serial buffer properly. If the buffer fills up, new data may be lost. You can limit the amount of data read at once or implement a more sophisticated buffer management strategy.

import machine
 
uart = machine.UART(0, 9600)
 
while True:
    if uart.any():
        # Read a maximum of 10 bytes at a time
        data = uart.read(10)
        print('Received data:', data)

4. Best Practices#

Error Handling#

When reading data from the serial port, it's important to handle potential errors. For example, if the data received is not in the expected format, the program should be able to handle it gracefully.

import machine
 
uart = machine.UART(0, 9600)
 
while True:
    if uart.any():
        try:
            data = uart.read()
            # Assume the data is a string and decode it
            decoded_data = data.decode('utf - 8')
            print('Received data:', decoded_data)
        except UnicodeDecodeError:
            print('Error decoding data')

Performance Optimization#

To optimize the performance of non - blocking serial input, you can adjust the polling interval based on the expected data rate. If the data arrives very frequently, you may need to reduce the polling interval; if it arrives rarely, you can increase the interval to save power.

5. Code Examples#

Simple Non - Blocking Serial Input#

import machine
import time
 
# Initialize UART
uart = machine.UART(0, 9600)
 
while True:
    if uart.any():
        data = uart.read()
        print('Received:', data)
    # Simulate other tasks
    time.sleep(0.2)

Non - Blocking Serial Input with Data Processing#

import machine
import time
 
uart = machine.UART(0, 9600)
 
while True:
    if uart.any():
        data = uart.read()
        try:
            num = int(data)
            result = num * 2
            print(f'Received {num}, result: {result}')
        except ValueError:
            print('Invalid data received')
    # Do other tasks
    time.sleep(0.1)

6. Conclusion#

Non - blocking serial input in MicroPython is a powerful technique that allows microcontrollers to handle serial communication while still performing other tasks. By understanding the fundamental concepts, usage methods, common practices, and best practices, you can effectively implement non - blocking serial input in your MicroPython projects. Remember to handle errors, manage the serial buffer, and optimize the performance for the best results.

7. References#

  • MicroPython official documentation: https://docs.micropython.org/
  • Microcontroller datasheets for specific hardware details related to serial communication.
2025-10