Restore UART0 to REPL after using it for own purposes?

[george-hawkins]

I have a classic ESP32 board and want to communicate with it using serial over the board's USB-C connection.

I thought I could take UART0 from the REPL like so:

os.dupterm(None, 0)
uart0 = UART(0, baudrate=9600, tx=1, rx=3, timeout=0)

And then return it for use by the REPL and exit the program like so:

os.dupterm(UART(0, baudrate=115200, tx=1, rx=3), 0)
sys.exit()

However:

• I don't think the os.dupterm(None, 0) does anything - including it or leaving it out seems to make no difference. Is it necessary?
• More importantly, on trying to return the UART to the REPL and exit the program I get:

I.e. I see a few bytes of gibberish (presumably somehow the baud rate doesn't adjust immediately), then various uart driver error messages mixed in with the output from the REPL.

So, it seems to have partially worked - I'm seeing some output from the REPL but any key press results in the key being echoed followed by:

E (65868) uart: uart_write_bytes(1245): uart driver error

I'm not sure what to make of the E numbers - I see lots of different numbers that don't seem to map to error codes.

I've tried varying the arguments used when constructing the UART for return to the REPL, e.g. setting timeout=0, but nothing I've tried so far has made an obvious improvement over the current situation. I've also tried using init to change the settings of uart0 and passing that to os.dupterm rather than creating a new UART instance but that didn't change things.

Any help would be much appreciated.

I wrote a super simple program to demonstrate my problem. I have a button connected to pin 0 and when I press it, I take control or UART0 and when I release it, I attempt to return UART0 to the REPL and exit the program:

from machine import UART, Pin
import machine                                                                                                                                                            
import time
import os
import sys
                                                                                                                                                                          
BUTTON_PIN = 0

button = Pin(BUTTON_PIN, Pin.IN)
button_default_value = button.value()                                                                                                                                     

uart0 = None                                                                                                                                                              

while True:                                                                                                                                                               
    current_button_value = button.value()
    if current_button_value != button_default_value:                                                                                                                      
        button_default_value = current_button_value                                                                                                                       

        if uart0 is None:                                                                                                                                                 
            print('Taking over UART0')                                                                                                                                    
            time.sleep_ms(500)                                                                                                                                            
            os.dupterm(None, 0)                                                                                                                                           
            uart0 = UART(0, baudrate=9600, tx=1, rx=3, timeout=0)                                                                                                         
        else:                                                                                                                                                             
            os.dupterm(UART(0, baudrate=115200, tx=1, rx=3), 0)                                                                                                           
            sys.exit()

[george-hawkins]

I see that at one stage, it was impossible to do anything with UART0 but this changed with commit 919e586 from @pi-anl in March, 2022.

I've tried other things like assigning the UART0 pins to UART1 UART(1, tx=1, rx=3, ...) and then calling deinit on that before attempting to restore things to the REPL with os.dupterm(UART(0, tx=1, rx=3, ...), 0).

But all the variations that I've tried have failed to work.

I guess, I'm misunderstanding how os.dupterm is supposed to work or what one can do with UART(0).

[george-hawkins]

Forcing the board to reset and then, on restart, detecting a signal that tells my program to exit rather than acquire the UART0 pins seems to be one way of achieving what I want.

E.g. in this modification of the little demo in my first post, you can:

1. Click (and release) the button to grab UART0.
2. Click and hold to cause the program to call machine.reset() and then on restarting detect that the button is still held down and exit rather than the usual flow.

from machine import UART, Pin
import machine                                                                                                                                                            
import time
import os
import sys
                                                                                                                                                                          
BUTTON_PIN = 0
BUTTON_DEFAULT_VALUE = 1

button = Pin(BUTTON_PIN, Pin.IN)
button_value = button.value()

if button_value != BUTTON_DEFAULT_VALUE:
    print("Button held down during startup - exiting to REPL")
    sys.exit()
  
count = 0
  
while True:
    current_button_value = button.value()
    if current_button_value != button_value:
        button_value = current_button_value
        count += 1

        if count == 1:
            print('Taking over UART0')                                                                                                                                    
            time.sleep_ms(500)                                                                                                                                            
            uart0 = UART(0, baudrate=9600, tx=1, rx=3, timeout=0)                                                                                                         
        elif count == 3:
            machine.reset()

While this achieves what I want, it feels like the nuclear option to force the board to reset. I feel one should be able to restore UART0 to the REPL programmatically.

Also, I note that some state seems to survive the reset, e.g. if I assign pins 1 and 3 to UART1 above rather than UART0, i.e. do:

uart1 = UART(1, baudrate=9600, tx=1, rx=3, timeout=0)
             ^

... then, on resetting and exiting to the REPL, everything looks good initially - I see the REPL's banner text (MicroPython v1.22.1 on 2024-01-05; ... etc.) and the >>> prompt but can't enter anything, i.e. the REPL can transmit such that I can see its text output but it can't receive anything from me typing.

[xyzzy42]

The code to handle the UART REPL and machine.UART()s is totally different on ESP32. Both the same set of UARTs, but totally different code.

The code that initializes the UART REPL is not run again on a µpy soft reboot, nor is there any python interface to it. So there's no way to get it back, other than to reset the whole MCU.

[george-hawkins]

Thanks for the reply, Trent. So, is it the case that I can reliably expect to be able to take control of the REPL UART, i.e. create a machine.UART instance corresponding to the REPL UART, despite not then being later able to return it to the REPL?

It's a little unclear to me what I should and shouldn't expect to be able to do with UART0 from within a Python program, i.e. are there restrictions on what one can do with it? Looking at commit 919e586 from @pi-anl, it doesn't feel as if one has the same degree of control as with other UARTs (but perhaps I misunderstood the context of this commit, and perhaps things have changed since then).

You said:

The code that initializes the UART REPL is not run again on a µpy soft reboot, nor is there any python interface to it. So there's no way to get it back, other than to reset the whole MCU.

I'm using machine.reset (rather than machine.soft_reset) in my second example to reset the board. The documentation says this "Resets the device in a manner similar to pushing the external RESET button." I guess the crucial word here is "similar", as I've found some state does seem to survive this call that would not survive actually pressing the reset button (it kind of surprises me that the underlying ESP-IDF API doesn't provide some sort of true chip reset functionality).

[xyzzy42]

Thanks for the reply, Trent. So, is it the case that I can reliably expect to be able to take control of the REPL UART, i.e. create a machine.UART instance corresponding to the REPL UART, despite not then being later able to return it to the REPL?

I don't know about that. The code in ports/esp32/uart.c, which handles the REPL UART, doesn't appear to be written with the idea that the code in ports/esp32/machine_uart.c can take the uart away from it. Simply changing the baud rate is one thing. Trying to get to the TX and RX FIFOs first when other code had registered an interrupt handler is a different thing. I'm surprised it seems to work at all.

I'd either disable the REPL, move it from UART0, or just use another UART for your app. I'm pretty sure you can move the REPL UART to another UART, leaving UART0 (which the ROM bootloader can not be moved from) for another use.

If you must have both the REPL and your app's serial IO on the same UART, then use sys.stdin and sys.stdout for your serial IO.

[0wwafa]

So, what if I want to set momentarily UART0 to 921600, output to it and then reset it?