asyncio streamwriter not sending to uart

[ThinkTransit]

I'm having trouble getting an async streamwriter to work, streamreader works ok but streamwriter doesn't seem to send anything out on the uart. Can anyone see anything wrong with this?

class Modem():
    def __init__(self, uart):
        self.uart = uart
        self._sreader = asyncio.StreamReader(self.uart)
        self._swriter = asyncio.StreamWriter(self.uart, {})
        
    async def _run(self):

        logger.debug("Starting uart loop")
        while True:
            try:
                res = await self._sreader.readline()
                res = res.decode('utf8')
            except UnicodeError:  # Garbage: can happen e.g. on baudrate change
                logger.debug(f"Bad data received on UART { res }")
                continue
            except:
                logger.debug(f"Bad data on UART???")
                continue
            logger.debug(f"Received on UART {res}")
            await self._update(res)



    async def send_command(self, command):
        cmd = add_checksum(command)
        logger.debug("Sending to modem: %s" % cmd)
        self._swriter.write(b"$%s\n" % cmd)
        await self._swriter.drain()
        logger.debug("Finished sending to modem: %s" % cmd)

        
    async def send_ascii(self, text):
        await self.send_command(text)

I have also tried

await self._swriter.awrite(b"$%s\n" % cmd)

Thanks

[2dof]

Your class has no attribute self._update(res) .

how did you call your methods? for example based on example auart_hd.py

I have done as loopback on esp32 as example and it is work:

uart = UART(2, 9600, timeout=0,bits=8, parity=None, stop=1, tx=17, rx=16)  # esp32 looback: connect tx and tx 

async def main():
    
    modem1=Modem(uart)
    rx = asyncio.create_task(modem1._run())  # start uart reader listener 
   
    await modem1.send_command('my command 1')
    await modem1.send_command('my command 2 ')
    
    while True:
        await asyncio.sleep(1)
   

#  run main() app 
try:
        asyncio.run(main())
except KeyboardInterrupt:
        print('Interrupted')
finally:
        asyncio.new_event_loop()

[peterhinch]

Agreed. It is not clear from the example how the send_ methods get called.

[ThinkTransit]

Apologies for the lack of detail, send_command() is called from other modules like:

modem = Modem(UART(1, baudrate=115200, tx=37, rx=38)

await modem.send_command("my_command")

self._update(res) is used for processing the incoming stream, this part is working ok.

[2dof]

Are Your whole code : Your app (tasks) are running by asyncio.run() other asyncio event ?

if Your code is good (according to peterhinch's docs and examples/tutorials) then try do loopback ( connect tx and rx pins in your device), at least you find out there the problem is (code or hardware connection)

[ThinkTransit]

Yes everything is run by asyncio.run()

Thanks I will test the with a loopback, good idea.

[ThinkTransit]

Thanks @2dof and @peterhinch I solved this problem and it had nothing to do with asyncio, totally unrelated, code posted above is working as expected.

My device wakes periodically to send data using a modem, the modem requires a logic high on the RX input when the mcu (ESP32) is sleeping). In my deepsleep routine I was holding the UART TX pin high with the following.

# To prevent swarm modem triggering a wake event set tx pin high
tx_pin = Pin(pins.MODEM_TX, Pin.OUT, value=1, hold=True)

The Pin hold persists during deepsleep so UART doesn't work on wake-up unless the pin is first released.