ESP32 Devkit V4 reading and writing data over USB to serial using the UART class

[bangell-rockhall]

I am trying to use the UART class on an ESP32 devkit V4 using the built in USB to serial CH340 chip and am having some trouble reading and writing data over serial.

This is the code which is running on the ESP32:

from machine import UART
import time

uart = UART(0, baudrate=115200) # set up the serial connection
print(uart)

uart.write('test\n')

def handle_command(command):
    """
    Handle a command received over serial.

    :param command: the command to handle
    """
    if command == b'p':
        uart.write("test3\n")
    else: # unrecognized command
        uart.write("error\n")

while True: # continuously read commands over serial and handle them
    if uart.any(): # if there is an incoming message
        message = uart.read()
        uart.write("test2\n")
        handle_command(message)

I have attempted to write data to the ESP32 over serial using the Arduino IDE's serial monitor as well as this Python class:

import serial
import time

# create a serial object
ser = serial.Serial(port = 'COM4',
		    baudrate = 115200,
		    bytesize = serial.EIGHTBITS,
		    parity = serial.PARITY_NONE,
		    stopbits = serial.STOPBITS_ONE,
		    timeout =  10)
time.sleep(10) # wait for the connection to establish

print("serial connection name: " + str(ser.name))
print("serial connect is open: " + str(ser.isOpen()))
print("baudrate: " + str(ser.baudrate))
print("bystesize: " + str(ser.bytesize))
print("parity: " + str(ser.parity))
print("stopbits: " + str(ser.stopbits))

ser.write(b'p\n') # send a command to the ESP32 and wait for the response
response = ser.readline().decode().strip()
print("received response: " + response)

ser.close() # close the serial connection

I used the print statements in the Python class to confirm both are using the same serial settings.

The issues I am running into are:

1. When I upload this code to the ESP32 which is using UART port 0, it basically bricks the device. Once the class listed above is uploaded it becomes impossible to upload any further code to the ESP32 without erasing and re-flashing the firmware.
2. The other problem I am having, and this probably does not come as a big surprise, is the ESP32 is not responding to any serial data or successfully writing serial data. I do not receive any errors when executing the code, but none of the write statements in the ESP32 code are showing up on the serial monitor.

Any advice is greatly appreciated.

[robert-hh]

Your device uses UART0 for REPL and stdio. As soon as you use UART0 for something else, REPL is blocked. And if you put your code into main.py, you lock yourself out. So you have to use either a different UART and a separate USB/UART bridge. Or you use sys.stdin.read() for reading and sys.stdout.write() for writing. Or sys.stdin.buffer.read()/sys.stdout.buffer.write() for raw I/O. There are more methods than read() and write(). The equivalent for uart.any() would be using select().

[bangell-rockhall]

Sorry for the delayed response, but thank you so much for your help robert-hh.

I have written a class which can read in single characters over serial, put those characters into a message, and then handle said message.

This code could be easily modified to make the messages larger than a single charter by using the command message += readSerial() in some form of a loop. Of course, logic would then have to be added make sure the message is then handled at the desired size, or when it matches a command, or whatever behavior is desired, but that is a larger project that goes beyond what the first post was about.

This code also has the advantage of not needing to disconnect from the REPL in order to read data from the serial port, which may be desirable to some.

import sys
import uselect

serialPoll = uselect.poll()
serialPoll.register(sys.stdin, uselect.POLLIN)

def handle_command(command):
    """
    Handle a command received over serial.

    :param command: (String) the command to handle
    """
    if command == None: # filter out empty messages
        return(1)
    print(command)
    if command == "p":
        sys.stdout.buffer.write("test\n")
    else: # unrecognized command
        sys.stdout.buffer.write("error\n")

def readSerial():
    """
    reads a single character over serial.

    :return: returns the character which was read, otherwise returns None
    """
    return(sys.stdin.read(1) if serialPoll.poll(0) else None)

while True:
    # continuously read commands over serial and handle them
    message = readSerial()
    handle_command(message)