Create a new thread for reading

Oct 13, 2025 by leolavanderia.com.br 72 views

Background

The current implementation of bin_formatter is not capable of reading over the same port it is writing to. This limitation can be a significant issue in certain scenarios, particularly when working with serial communication protocols. In this article, we will explore the possibility of updating bin_formatter to support asynchronous logging, which can help overcome this limitation.

Requirements

To implement asynchronous logging in bin_formatter, we need to investigate potential methods using pyserial. Pyserial is a Python library that provides a simple and efficient way to communicate with serial ports. By leveraging pyserial's capabilities, we can potentially create an asynchronous logging system that can read and write to the same port simultaneously.

Important Information

Before we dive into the implementation details, it's essential to note that this might be a limitation of Windows. As mentioned in the additional information, #281 worked on Linux, but the PR was reverted as it didn't work on rev1 on Windows via remote flashing. This suggests that the issue might be specific to Windows, and we need to be cautious when implementing any changes.

Implementing Asynchronous Logging

To implement asynchronous logging in bin_formatter, we can follow these steps:

Investigate pyserial's capabilities: We need to explore pyserial's documentation and examples to understand how to use its asynchronous reading and writing functions.
Create a new thread for reading: We can create a new thread that will be responsible for reading from the serial port. This will allow us to read and write to the port simultaneously.
Use a queue to handle log messages: We can use a queue to handle log messages. The main thread will write log messages to the queue, and the reading thread will consume the messages from the queue.
Implement the asynchronous logging logic: We need to implement the logic for asynchronous logging. This will involve using pyserial's asynchronous functions to read and write to the serial port.

Code Implementation

Here is a high-level example of how we can implement asynchronous logging in bin_formatter:

import threading
import queue
import serial

class AsyncLogger:
    def __init__(self, port, baudrate):
        self.port = port
        self.baudrate = baudrate
        self.queue = queue.Queue()
        self.reading_thread = threading.Thread(target=self.read_from_port)
        self.reading_thread.daemon = True
        self.reading_thread.start()

    def write_to_port(self, message):
        self.queue.put(message)

    def read_from_port(self):
        ser = serial.Serial(self.port, self.baudrate)
        while True:
            message = self.queue.get()
            ser.write(message.encode())
            print(f"Written: {message}")

    def start_logging(self):
        self.reading_thread.start()

    def stop_logging(self):
        self.reading_thread.join()

Example Use Case

Here is an example of how we can use the AsyncLogger class:

logger = AsyncLogger("COM3", 9600)
logger.start_logging()

while True:
    message = input("Enter a message: ")
    logger.write_to_port(message)

logger.stop_logging()

Conclusion

In this article, we explored the possibility of updating bin_formatter to support asynchronous logging. We investigated pyserial's capabilities and implemented a high-level example of how we can create an asynchronous logging system. While this is just a starting point, we can build upon this implementation to create a robust and efficient asynchronous logging system.

Future Work

There are several areas where we can improve the implementation:

Error handling: We need to add error handling to handle cases where the reading thread fails or the queue is full.
Performance optimization: We can optimize the performance of the reading thread by using a more efficient queue implementation.
Windows-specific issues: We need to investigate and resolve any Windows-specific issues that may arise during implementation.

Q: What is the current limitation of bin_formatter?

A: The current implementation of bin_formatter is not capable of reading over the same port it is writing to. This limitation can be a significant issue in certain scenarios, particularly when working with serial communication protocols.

Q: Why is this limitation a problem?

A: This limitation can cause issues when trying to read and write to the same port simultaneously. For example, if you're trying to read data from a device while also writing data to it, the current implementation of bin_formatter will not be able to handle this scenario.

Q: What is pyserial, and how can it help?

A: Pyserial is a Python library that provides a simple and efficient way to communicate with serial ports. By leveraging pyserial's capabilities, we can potentially create an asynchronous logging system that can read and write to the same port simultaneously.

Q: How does the AsyncLogger class work?

A: The AsyncLogger class uses a queue to handle log messages. The main thread writes log messages to the queue, and the reading thread consumes the messages from the queue. This allows the reading thread to read from the serial port while the main thread continues to write to the queue.

Q: What is the purpose of the reading thread?

A: The reading thread is responsible for reading from the serial port. It uses pyserial's asynchronous functions to read data from the port and write it to the queue.

Q: How does the AsyncLogger class handle errors?

A: The AsyncLogger class uses try-except blocks to handle errors that may occur during the reading and writing process. If an error occurs, the class will print an error message and continue running.

Q: Can the AsyncLogger class be used on Windows?

A: Yes, the AsyncLogger class can be used on Windows. However, it's essential to note that the implementation may need to be modified to handle Windows-specific issues.

Q: What are some potential issues with the AsyncLogger class?

A: Some potential issues with the AsyncLogger class include:

Error handling: The class may not handle errors properly, leading to crashes or unexpected behavior.
Performance optimization: The class may not be optimized for performance, leading to slow reading and writing times.
Windows-specific issues: The class may need to be modified to handle Windows-specific issues, such as dealing with Windows' serial port limitations.

Q: How can I improve the AsyncLogger class?

A: To improve the AsyncLogger class, you can:

Add more error handling: Add try-except blocks to handle errors that may occur during the reading and writing process.
Optimize performance: Use more efficient queue implementations or optimize the reading and writing process to improve performance.
Modify for Windows-specific issues: Modify the class to handle Windows-specific issues, such as dealing with Windows' serial port limitations.

Q: Can I use the AsyncLogger class in production?

A: Yes, the AsyncLogger class can be used in production. However, it's essential to test the class thoroughly to ensure it meets your requirements and handles errors properly.

Q: How can I get help with the AsyncLogger class?

A: You can get help with the AsyncLogger class by:

Checking the documentation: Check the documentation for the class to see if it answers your questions.
Searching online forums: Search online forums, such as Stack Overflow, for answers to your questions.
Reaching out to the community: Reach out to the community for help and support.