uasync slow

[jm54]

I wrote simple uasync tcp to serial bridge
but it is very slow .us2n at https://github.com/tiagocoutinho/us2n/b ... er/us2n.py is faster
someone could help me to improve my soft ? ( i am beginner )

Code: Select all

import uasyncio as asyncio

import machine, ssd1306
from machine import UART

import logging

# Init Display
i2c = machine.I2C(scl=machine.Pin(22), sda=machine.Pin(21))
oled = ssd1306.SSD1306_I2C(128, 64, i2c, 0x3c)

#Init Uart
uart = UART(2)    # init with given baudrate
uart.init(115200, bits=8, parity=None, stop=1)

oled.fill(0)
oled.text("Boot", 0, 0)
oled.show()

async def server(reader, writer):
    print(reader, writer)
    sreader = asyncio.StreamReader(uart)
    swriter = asyncio.StreamWriter(uart, {})
    loop.create_task(ListenToSerial(writer,sreader))    
    loop.create_task(ListenToTcp(reader,swriter))

async def ListenToSerial(Wr,Sr):
     while True:
         FromSerial = await Sr.read(1)
         await Wr.awrite(FromSerial)
  
         
async def ListenToTcp(Re,Ws):    
        while True:            
            FromTcp=await Re.read(1)
            await Ws.awrite(FromTcp)
            

logging.basicConfig(level=None)
loop = asyncio.get_event_loop()
loop.call_soon(asyncio.start_server(server, "192.168.1.49", 8081))
loop.run_forever()

[pythoncoder]

You are reading characters one at a time. If your data is organised as lines of text, you might get faster processing using readline methods.

If data is not line-oriented you might read N characters at a time, but then you'd probably need a timeout to handle the case where fewer than N characters are sent to your bridge, followed by a long gap.

[jm54]

dear peter
In fact i need reading one by one because this bridge , bridge one esp32 to repl uart of another esp32 or ttgo
with the soft ''tibbo'' your can map local virtual com to tcp port , like this you can use soft like thonny or EsPy
to access the uart port ( repl ) of the second esp or ttgo to program, see boot etc

[pythoncoder]

A baudrate of 115K implies an interval of about 80μs between characters. On an ESP32, even under ideal conditions, uasyncio takes longer than this to switch between tasks. Handling one character at a time you're never going to achieve that kind of throughput. I'd be astonished if you achieved 1/10 of that.

This is pushing uasyncio beyond what it can achieve. Your choices are either to handle data in larger quantities, or to abandon uasyncio in favour of a hard interrupt driven solution.

[jm54]

i made change reading 50 characters

async def server(reader, writer):
print(reader, writer)
sreader = asyncio.StreamReader(uart)
swriter = asyncio.StreamWriter(uart, {})
loop.create_task(ListenToSerial(writer,sreader))
loop.create_task(ListenToTcp(reader,swriter))

async def ListenToSerial(Wr,Sr):
while True:
FromSerial = await Sr.read(50)
print(FromSerial)
await Wr.awrite(FromSerial)

async def ListenToTcp(Re,Ws):
while True:
FromTcp=await Re.read(50)
await Ws.awrite(FromTcp)

it's quite good with thonny python
can I cancel task server when the communication ( tcp <> Serial ) is establish ? what is the best way ?

i use i2c display with init like this
i2c = machine.I2C(scl=machine.Pin(22), sda=machine.Pin(21))
how to use it with asyncio ? like this?

async def display():
global count
while True:
count += 1
oled.fill(0)
oled.text('My string)', 0, 0)
oled.show()
await asyncio.sleep_ms(1000) # Pause 1s