Скачать или смотреть Efficiently Reading Data from Serial Ports in Python: Minimizing CPU Load

Discover effective approaches to read from serial ports in Python while reducing CPU load. Explore best practices and techniques in handling serial data.
---
This video is based on the question https://stackoverflow.com/q/62321450/ asked by the user 'JakobVinkas' ( https://stackoverflow.com/u/11220030/ ) and on the answer https://stackoverflow.com/a/62514613/ provided by the user 'Doddie' ( https://stackoverflow.com/u/756908/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: CPU load of python serial read

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Efficiently Reading Data from Serial Ports in Python: Minimizing CPU Load

When working with serial communication in Python, especially in threaded applications, many developers encounter performance issues, particularly with CPU load. One common scenario involves needing to read data from a serial port without hindering the overall performance of the application. This guide will explore these challenges and present solutions to improve data reading efficiency while minimizing CPU load.

The Problem: High CPU Load with Serial Reads

In a recent case, a developer faced significant CPU load variations while trying to read data from a serial port in different configurations. Using the pyserial library, they implemented two different approaches for reading messages but noticed a stark increase in CPU load between the two methods. The question arose: What is the most efficient way to read data from a serial port in terms of performance and time complexity?

Different Approaches

First Implementation:

[[See Video to Reveal this Text or Code Snippet]]

In this method, the blocking read function waits indefinitely until two bytes are received. This can lead to high CPU usage if a short message is sent and creates a bottleneck.

Second Implementation:

[[See Video to Reveal this Text or Code Snippet]]

In this approach, the timeout is set to zero, allowing the read operation to return immediately, cycling through checks. However, this resulted in almost double the CPU load compared to other methods.

Proposed Solution: Separation of Byte Receiving and Message Parsing

To reduce CPU load while effectively reading from the serial port, it's beneficial to separate the byte receiving logic from message parsing. This method keeps the serial reading efficient without overloading the CPU with continuous checks.

Implementation Strategy

Here's an organized approach to implement the suggested method:

Use a Buffer: Utilize a deque to maintain the incoming bytes from the serial port.

Receive Bytes Function: Create a function that continuously reads bytes and appends them to the buffer.

Consume Messages Function: Process the buffer to decode messages once sufficient bytes are available.

Here’s how the code could look:

[[See Video to Reveal this Text or Code Snippet]]

Why This Works

Buffering: The usage of a buffer allows for efficient message handling without constant blocking, improving overall application throughput.

No Time Complexity Concern: While you may suspect that time complexity plays a significant role, our analysis reveals that the blocking nature of synchronous reads vastly affects performance more than theoretical complexities.

Final Thoughts

Optimizing CPU load when handling serial reads in Python requires a careful approach that balances between blocking reads and efficient byte management. By employing separate functions for receiving and processing messages, you can maintain effective communication while significantly reducing CPU overhead. If you're facing similar issues in your applications, consider implementing this strategy for better performance.