Is it possible to have an additional serial port (UART) on the RP2040?

[jp02]

Hi all,
I'm new on this forum, I'm french and very old sorry.. I'm learning Micropython because my grandchildrens are learning python. I did a lot of programs with the faboulous Basic-Bascom for AVR
I need three serial ports on a Raspberry Pico.
In Basic-Bascom, you can create a soft serial port. Is this possible with MicroPython?
thank you,
Gustave

[GitHubsSilverBullet]

Depends on whether you want to only send or send/receive data.
If you're only sending, the documentation explains how to reconfigure a UART to use different pins.
So you could toggle back and forth between several UART pins.

You could also use the PIOs to create additional Rx/Tx UARTs. But that needs at least some coding.

[jean-claudeF]

I am currently working on this, doing it with PIO

Here is a class for TX:

"""
Class for PIO UART TX on any pin
Use like this:
pio_tx = PIO_TX(0, txpin, baud)
pio_tx.print("Hello from PIO")
"""
from machine import Pin
from rp2 import PIO, StateMachine, asm_pio

class PIO_TX():
    
    H = PIO.OUT_HIGH
    
    @asm_pio(sideset_init = H, out_init = H, out_shiftdir = PIO.SHIFT_RIGHT)
    def pio_tx():
        pull()
        set(x, 7)  .side(0)       [7]
        
        label("bitloop")
        out(pins, 1)              [6]
        jmp(x_dec, "bitloop")
        
        nop()      .side(1)       [6] 
   
    
    def __init__(self, index, pin, baud):
        self.txpin = pin
        self.baud = baud
        self.index = index
        self.sm = StateMachine(self.index, self.pio_tx, 
            freq=8 * self.baud, sideset_base=Pin(self.txpin) ,
            out_base=Pin(self.txpin))
        self.sm.active(1)
    
    def print(self, s, end = '\n\r'):
        s += end
        for c in s:
            self.sm.put(ord(c))
    
    def close(self):
        self.sm.active(0)
        
#--------------------------------------
if __name__ == '__main__':
    sm_index = 0
    txpin = 15
    baud = 9600
    import time
    pio_tx = PIO_TX(sm_index, txpin, baud)
    
    try:
        while True:
            pio_tx.print("Hello")
            time.sleep(1)
    except KeyboardInterrupt:
        pio_tx.close()

By the way, I have loved BASCOM when I was working with AVR.
Since I switched to Linux, I do (nearly) everything with Python

[jean-claudeF]

Concerning RX, I have a class that reads CR terminated messages on any pin.
However there is a glitch at unregular intervals. Maybe it comes from using an interrupt to update the buffer.
My second idea was using DMA instead of the interrupt. I have it working (nearly), but DMA is more for fixed length transfers.

If anybody her is smarter with this than me, I would like to hear from him or her.

[jp02]

Many thanks Jean-Claude , I know you. I wrote the e_books "Basic des microcontrôleurs AVR" and we exanged some mails years ago.
jean-Pierre Duval (Gustave)
I need only tx , it is perfect.

[KnorkFox]

... I need three serial ports on a Raspberry Pico. In Basic-Bascom, you can create a soft serial port. Is this possible with MicroPython? thank you, Gustave

Hi Gustave!
I am still a beginner, but as far as i know, the pico has 4 full serial ports, with the REPL on the first port. With only TX, you could use 8 pins as uart. There is an example in the source.

micropython/examples/rp2/pio_uart_tx.py

Line 14 in 5f058e9

def uart_tx():

Fox

[robert-hh]

The PICO has two standard serial ports. REPL is at the USB interface, which acts at the PC like a serial port. The link you gave is for UART implementation using the PIO state machines, like @jean-claudeF mentioned.

[jp02]

For my first post I am delighted, I thank you all and...see you soon!

[jean-claudeF]

I'm still working on RX, that's a bit more tricky.
For the moment I have this:

"""
Class for PIO UART RX on any pin
Use like this:

pio_rx = PIO_RX(sm_index, txpin, baud)
while True:
    if pio_rx.data_ready:
        s = pio_rx.get_data()
"""

from machine import Pin
from rp2 import PIO, StateMachine, asm_pio

triggerpin = Pin(3, Pin.OUT)

class PIO_RX():

    @asm_pio(autopush=True, push_thresh=8,in_shiftdir=PIO.SHIFT_RIGHT)
    def uart_rx_mini():
        # Wait for 8+1 bits to come in
        # and call the interrupt handler
        wait(0, pin, 0)
        set(x, 7)                 [10]
        label("bitloop")
        in_(pins, 1)
        jmp(x_dec, "bitloop")     [6]
        irq(1, rel(0))
        
    def __init__(self, sm_index, pin, baud):
        self.rxpin = pin
        self.baud = baud
        self.index = sm_index
        self.buffer = []
        self.data_ready = False
        self.decode_errors = 0
        
        self.sm = StateMachine(self.index, self.uart_rx_mini, freq= 8 * self.baud,
          in_base = Pin(pin, Pin.IN, Pin.PULL_UP),
          jmp_pin = Pin(pin, Pin.IN, Pin.PULL_UP),)     
        self.sm.irq(self.int_handler)
        self.sm.active(1)
        
    
    def int_handler(self, sm):
        # Get 1 byte and append it to the buffer
        # On carriage return set data_ready = True
        # Duration can be measured on triggerpin
        
        # !!! sm is a placeholder for the reference to the state machine that is automatically passed
        # when the interrupt is called  !!!
        # When an interrupt occurs, MicroPython automatically passes a reference to the state machine that triggered the interrupt.
        # This must be used otherwise we get an error that is difficult to find
        
        triggerpin.value(1)
        
        if sm.rx_fifo():
            data = sm.get()
            data = data >> 24
            
            self.buffer.append(data)
            if data == 13:
                self.data_ready = True
        
        triggerpin.value(0)
       
    
    def get_data(self):
        # Get data and empty buffer 
        b = self.buffer
        self.buffer = []
        self.data_ready = False
        return b

    def bytes2string(self, b):
        try:
            bb = bytes(b)
            s = bb.decode('UTF-8') 
        except:
            s = "\nERROR . Received " + str(len(b)) + "bytes"
            self.decode_errors += 1
        return s
    
    def get_data_s(self):
        # Get data, decode to string and empty buffer 
        b = self.get_data()
        s = self.bytes2string(b)
        
        
        return s
#---------------------------------------------------------------------
    
def test1():    
    #baud = 9600
    baud = 57600
    
    # These are too high:
    #baud = 115200
    #baud = 230400
    #baud = 460800
    
    rxpin = 15
    sm_index = 0

    pio_rx = PIO_RX(sm_index, rxpin, baud)
    
     while True:
        
        if pio_rx.data_ready:
            #s = pio_rx.get_data_s()
            #s = s[:-2]      # remove '\r\n'
            s = pio_rx.get_data_s()
            s = s.replace('\n', "")
            print(pio_rx.decode_errors, s )
            
        time.sleep(0.01)
        
#------------------------------------------------------------------
if __name__ == '__main__':
    import time
    test1()

It works (nearly) fine. Only problem: sometimes (e.g. 79 of 13070 messages) there is an error.
I suppose the problem is the interrupt handler routine that sometimes takes too much time.

[jean-claudeF]

I have also tried using DMA and got it partially working (for a fixed length message).
Still have to learn a bit more...