How to handle fast flipping of RE/DE pins when using ESP32 and RP2040 UART as RS485

[yfyungit]

Description

When using ESP32 and RP2040's UART for RS485 communication, how to handle the fast flipping of RE/DE pins, the different transmission speeds at different baud rates, how to know whether all data on UART has been sent, and how to switch to receiving data as quickly as possible after sending.

Code Size

No response

Implementation

I hope the MicroPython maintainers or community will implement this feature

Code of Conduct

Yes, I agree

[peterhinch]

Moved to Discussions because this is not a Micropython bug report.

[moferreira]

The code that follows is to read data from a power meter via RS485. I guess you can easily adapt it to your needs. And yes, it is "over commented"... The CRC functions are not included as you may need to use the appropriate for your needs. If you remove the CRC checking you can read any RS485. Also, I limited the readings to 1 per second to comply with the meter limitations.

from machine import UART, Pin
pin = 3
rw_pin = Pin(pin, Pin.OUT)
ser = UART(<your serial parameters>)

def read_register(cmd):
    from time import sleep
    sleep(1)                     # Respect the maximum allowed reads per second
    LOOP_COUNTER = 3             # Number of 0.1 tries (3 = 30 tries)
    num_digits = len(cmd)        # Check if command has an even number of digits
    if not num_digits % 2 == 0:  # Is it a correct command?
        print(f"Command {cmd} does not have an even number of digits.")
        return False             # Fail if the command isn't valid
    cmd = add_crc(cmd)           # Add CRC to the sent command
    # Convert to hex byte array, MicroPython does not do it directely
    cmd_crc = bytearray(int(cmd[i:i+2], 16) for i in range(0, len(cmd), 2))
    if not ser:                  # Check if serial connection was successful
        print("No serial port available.")
        return False             # Fail could not open serial
    rw_pin.value(0) if rw_pin is not None else None # Flip RS485 to read mode
    ser.read()                   # Clear any input in the buffer
    rw_pin.value(1) if rw_pin is not None else None # Flip RS485 to write mode
    ser.write(cmd_crc)           # Write the command to the serial port
    sleep(0.1)                   # Delay to flush data into RS485
    rw_pin.value(0) if rw_pin is not None else None # Flip RS485 to read mode
    loop = 0                     # Initialize loop counter
    while ser.any() < 3:         # Wait until at least 3 bytes are available in the buffer
        sleep(0.1)               # Wait 100 ms
        loop += 0.1              # Increment loop counter
        if loop > LOOP_COUNTER:  # Timeout if the response takes too long
            return False
    data = ser.read(3).hex()     # Read the first 3 bytes and convert them to hex
    # Check for error response
    if data[0:4] == "01c5" or data[0:4] == "0184":
        # Process the error for debugging
        print(process_error(data))
        return False
    # Get the expected byte count (data + CRC)
    byteCount = int(data[4:6], 16) + 2
    loop = 0                     # Reset the loop counter
    while ser.any() < byteCount: # Wait for the full response to arrive
        sleep(0.1)               # Wait 100 ms
        loop += 0.1              # Increment loop counter
        if loop > LOOP_COUNTER:  # Timeout if we don't receive the full data in time
            print("Could not get remaining data. Aborting...")
            return False
    # Read the remaining data
    data += ser.read(ser.any()).hex()
    if not verify_crc(data):     # Verify the CRC of the received data
        print("Got a response with wrong CRC.")
        return False
    return data                  # Return collected data

[moferreira]

And sorry... It is proper to work for MODBUS.

[yfyungit]

Thank you very much for your answer, but I find that this is not the solution I need. My actual requirement is that after the detection of UART sending data, RS485 can switch to the receiving data state at the fastest speed.

…

---- Replied Message ---- | From | ***@***.***> | | Date | 11/10/2024 00:05 | | To | micropython/micropython ***@***.***> | | Cc | 悦妃云 ***@***.***>, Author ***@***.***> | | Subject | Re: [micropython/micropython] How to handle fast flipping of RE/DE pins when using ESP32 and RP2040 UART as RS485 (Discussion #16193) | And sorry... It is proper to work for MODBUS. — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you authored the thread.Message ID: ***@***.***>

[robert-hh]

You can use several mechanisms to respond when the UART data has been sent.

1. Call uart.flush() which will wait until the data has been sent. see https://docs.micropython.org/en/latest/library/machine.UART.html#machine.UART.flush
2. Call uart.txdone() which will return immediately and tell, if still data is to be sent. See https://docs.micropython.org/en/latest/library/machine.UART.html#machine.UART.txdone

[moferreira]

This is a great feature! Thanks for sharing.

[yfyungit]

Ok, thank you very much