circuitpython/tests/circuitpython-manual/busio/uart_echo.py

import busio
import board
import time

i = 0

u = busio.UART(tx=board.TX, rx=board.RX)

while True:
    u.write(str(i).encode("utf-8"))
    time.sleep(0.1)
    print(i, u.in_waiting)  # should be the number of digits
    time.sleep(0.1)
    print(i, u.in_waiting)  # should be the number of digits
    r = u.read(64 + 10)
    print(i, u.in_waiting)  # should be 0
    print(len(r), r)
    i += 1
A few minor fixes for corner cases * Always clear the peripheral interrupt so we don't hang when full * Store the ringbuf in the object so it gets collected when we're alive * Make UART objects have a finaliser so they are deinit when their memory is freed * Copy bytes into the ringbuf from the FIFO after we read to ensure the interrupt is enabled ASAP * Copy bytes into the ringbuf from the FIFO before measuring our rx available because the interrupt is based on a threshold (not > 0). For example, a single byte won't trigger an interrupt. 2021-02-25 19:50:57 -05:00			`import busio`
			`import board`
			`import time`

			`i = 0`

			`u = busio.UART(tx=board.TX, rx=board.RX)`

			`while True:`
			`u.write(str(i).encode("utf-8"))`
			`time.sleep(0.1)`
run code formatting script 2021-03-15 09:57:36 -04:00			`print(i, u.in_waiting) # should be the number of digits`
A few minor fixes for corner cases * Always clear the peripheral interrupt so we don't hang when full * Store the ringbuf in the object so it gets collected when we're alive * Make UART objects have a finaliser so they are deinit when their memory is freed * Copy bytes into the ringbuf from the FIFO after we read to ensure the interrupt is enabled ASAP * Copy bytes into the ringbuf from the FIFO before measuring our rx available because the interrupt is based on a threshold (not > 0). For example, a single byte won't trigger an interrupt. 2021-02-25 19:50:57 -05:00			`time.sleep(0.1)`
run code formatting script 2021-03-15 09:57:36 -04:00			`print(i, u.in_waiting) # should be the number of digits`
A few minor fixes for corner cases * Always clear the peripheral interrupt so we don't hang when full * Store the ringbuf in the object so it gets collected when we're alive * Make UART objects have a finaliser so they are deinit when their memory is freed * Copy bytes into the ringbuf from the FIFO after we read to ensure the interrupt is enabled ASAP * Copy bytes into the ringbuf from the FIFO before measuring our rx available because the interrupt is based on a threshold (not > 0). For example, a single byte won't trigger an interrupt. 2021-02-25 19:50:57 -05:00			`r = u.read(64 + 10)`
run code formatting script 2021-03-15 09:57:36 -04:00			`print(i, u.in_waiting) # should be 0`
A few minor fixes for corner cases * Always clear the peripheral interrupt so we don't hang when full * Store the ringbuf in the object so it gets collected when we're alive * Make UART objects have a finaliser so they are deinit when their memory is freed * Copy bytes into the ringbuf from the FIFO after we read to ensure the interrupt is enabled ASAP * Copy bytes into the ringbuf from the FIFO before measuring our rx available because the interrupt is based on a threshold (not > 0). For example, a single byte won't trigger an interrupt. 2021-02-25 19:50:57 -05:00			`print(len(r), r)`
			`i += 1`