Mastering Serial and USB Communication in Python with PySerial and PyUSB

In embedded development and hardware programming, serial communication and USB communication are two common methods. For Python developers, although PySerial and PyUSB are popular libraries in the Python ecosystem, understanding their working principles and application methods is very helpful for cross-platform programming and hardware device interaction. This article aims at beginners, detailing the basic usage, core features, advanced functionalities, and practical cases of PySerial and PyUSB. Whether you are a novice in hardware development or a developer looking to gain deeper insights into serial and USB communication, this article will help you master these tools better.

Introduction to PySerial and Basic Usage

PySerial is a Python library for serial communication that supports various operating systems, such as Windows, Linux, and MacOS. With PySerial, developers can easily communicate with serial devices, such as Arduino, sensors, and other embedded devices.

1. Installing PySerial

Before using PySerial, we need to install it:

pip install pyserial

2. Basic Serial Communication

Here is a basic example of serial communication. We open the serial port using PySerial, send data, and receive the returned data.

import serial

# Open serial port (parameters: port name, baud rate, timeout settings)
ser = serial.Serial('COM1', 9600, timeout=1)

# Send data to serial port
ser.write(b'Hello Arduino')

# Receive data from serial port
response = ser.readline()
print("Received:", response.decode())

# Close serial port
ser.close()

In this example, we opened the specified serial port (like COM1) using serial.Serial(), set the baud rate and timeout parameters. We send data using ser.write() and read data from the serial port using ser.readline().

3. Setting Serial Parameters

PySerial supports configuring various serial parameters, such as baud rate, data bits, stop bits, and parity bits. These parameters are crucial when communicating with external devices.

ser = serial.Serial(
    port='COM1',
    baudrate=9600,
    bytesize=8,       # Data bits
    parity=serial.PARITY_NONE,  # Parity bits
    stopbits=serial.STOPBITS_ONE,  # Stop bits
    timeout=1
)

4. Advanced Features of PySerial: Event-Driven and Timeout Settings

In practical applications, more complex controls for serial communication may be required, such as event-driven or timeout control. PySerial supports checking if there is data to read from the serial port using the inWaiting() method, and you can set read timeouts using timeout.

if ser.in_waiting > 0:
    data = ser.read(ser.in_waiting)
    print("Data received:", data)

Introduction to PyUSB and Basic Usage

PyUSB is a Python library for interacting with USB devices. It supports multiple platforms, such as Windows, Linux, and MacOS, and has a simple and easy-to-use API. With PyUSB, we can communicate at a low level with USB devices, such as reading USB device information and sending commands.

1. Installing PyUSB

Installing PyUSB is also very simple:

pip install pyusb

2. Listing Connected USB Devices

PyUSB provides convenient methods to list all connected USB devices in the system. The following code will list the relevant information of all USB devices currently connected to the system:

import usb.core
import usb.util

# Find all USB devices
dev = usb.core.find(find_all=True)

for cfg in dev:
    print(f"Device: {cfg}")

3. Communicating with USB Devices

Once a device is recognized, we can exchange data with it using PyUSB. Here is a simple example that shows how to read data from an endpoint of a USB device:

dev = usb.core.find(idVendor=0x1234, idProduct=0x5678)

# If the device is found
if dev is not None:
    # Set the device configuration
    dev.set_configuration()

    # Read data (read 64 bytes from endpoint 0)
data = dev.read(0x81, 64)  # 0x81 is the input endpoint
print(f"Received data: {data}")
else:
    print("Device not found")

4. Advanced Features of PyUSB: Control Transfer and Data Transfer

PyUSB supports various USB transfer methods, including control transfer, bulk transfer, synchronous transfer, and interrupt transfer. In the example below, we demonstrate how to obtain the USB device descriptor through control transfer.

# Get device descriptor
dev = usb.core.find(idVendor=0x1234, idProduct=0x5678)

if dev is not None:
    desc = dev.ctrl_transfer(0x80, 0x06, 0x0100, 0, 8)
    print("Device Descriptor:", desc)

Comparison of PySerial and PyUSB

Performance Optimization Suggestions

1. Performance optimization for PySerial:

• Data buffering: You can use ser.in_waiting and ser.read() for data buffering to avoid blocking every time data is read.
• Using buffers: For devices that require frequent reading, appropriately increasing the read buffer size can reduce frequent read/write operations.

• Bulk transfer: Use the bulk transfer method of PyUSB to handle large amounts of data; it performs better than control transfer.
• Merge small data transfers: Try to avoid sending small USB packets by merging data to reduce the number of transfers.

Practical Case: Serial and USB Communication with Embedded Devices

In an embedded project, suppose you need to send sensor data from an Arduino device via serial and communicate with a computer via USB. Below is an example of how to combine PySerial and PyUSB to accomplish this task:

import serial
import usb.core

# Use PySerial to communicate with Arduino
ser = serial.Serial('COM1', 9600, timeout=1)
ser.write(b'Hello Arduino')
response = ser.readline()
print("Received from Arduino:", response.decode())

# Use PyUSB to read data from USB device
dev = usb.core.find(idVendor=0x1234, idProduct=0x5678)
if dev:
    dev.set_configuration()
    data = dev.read(0x81, 64)
    print("Received from USB device:", data)
else:
    print("USB device not found")

Conclusion

PySerial and PyUSB are powerful Python libraries that provide a simple and efficient way to communicate with hardware devices (such as serial and USB devices). This article introduced the basic usage and advanced features of these two libraries, and through practical cases, demonstrated how to apply them in embedded device development. By using these two libraries effectively, you can easily achieve data interaction between devices and computers, improving development efficiency.