Integrating with pySerial and maintaining BLE connection

[JBrakefield]

Update 04/08/2021: I may have worked around the issues below by setting up a while loop, but my limited understanding of async is getting in the way of my code behaving as expected. I need to call serial functions as part of the callback handle (handle_rx) but sometimes data is "sent" but not "received", or even if I do get "received" by script 1 (below) I don't see the same results on the other side of the COM port pair.

I'm using pySerial to connect python with a virtual COM port that is paired with another virtual COM port (COM2 <-> COM4). I can successfully talk between the two using two methods: (1) dual python scripts, or (2) a python script to terminal (Tera Term).

I want to do all this while paired to BLE with bleak, so that I may type a message in the terminal (COM2) and have it received by COM4 into python and then to my device over BLE. So far I succeed at sending a message and receiving the return message, but with mixed results. I'm also having the issue of the BLE connection being severed after the first command/return event, ending the script.

I was once able to send a command that returns multiple lines (more than 20 bytes) without any problems. Now, however, my script is stalling after the first chunk and only sends the rest if I send successive commands with a known small return. I have to send that smaller command over and over for the script to finish flushing out the first command's return data. Then, as stated above, my script ends and the BLE connection is severed.

1. How do I keep my BLE connection 'on' or 'paired' while I play around with sending data through the virtual COM ports?
2. How do I properly deal with the 20 byte limit (or whatever it really it)?

My code below:

import asyncio
import logging

from bleak import BleakClient

import serial


serialPort = serial.Serial(port = "\\\\.\\COM4", baudrate=115200,
                        bytesize=8, timeout=2, stopbits=serial.STOPBITS_ONE)

def com4listen():
    serialString = ""   # Used to hold data coming over UART
    while(1):
        # Wait until there is data waiting in the serial buffe
        if(serialPort.in_waiting > 0):
            # Read data out of the buffer until a carraige return / new line is found
            serialString = serialPort.readline()
            # return message
            return serialString.decode('Ascii')
    # serialPort.close()

def com4return(return_message):
    serialString = ""   # Used to hold data coming over UART
    serialPort.write(return_message)
    while(1):
        # Wait until there is data waiting in the serial buffe
        if(serialPort.in_waiting > 0):
            # Read data out of the buffer until a carraige return / new line is found
            serialString = serialPort.readline()
            # return message
            return serialString.decode('Ascii')

    # serialPort.close()

UART_SERVICE_UUID = "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
UART_TX_CHAR_UUID = "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
UART_RX_CHAR_UUID = "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"

async def run(address, debug=False):
    log = logging.getLogger(__name__)
    if debug:
        import sys

        log.setLevel(logging.DEBUG)
        h = logging.StreamHandler(sys.stdout)
        h.setLevel(logging.DEBUG)
        log.addHandler(h)

    def handle_rx(_: int, data: bytearray):
        print("received:", data)
        com4return(data)

    async with BleakClient(address) as client:
        log.info(f"Connected: {client.is_connected}")

        #paired = await client.pair(protection_level=2)
        paired = await client.pair()
        log.info(f"Paired: {paired}")

        await client.start_notify(UART_RX_CHAR_UUID.lower(), handle_rx)

        text = com4return(b'')
        print("Sending command...")
        #await client.write_gatt_char(LIGHT_CHARACTERISTIC, b"\x00")
        await client.write_gatt_char(UART_TX_CHAR_UUID.lower(), bytes(text, encoding = 'ascii'))
        print("sent:", text)
        await asyncio.sleep(1.0)


if __name__ == "__main__":
    address = "CA:CD:39:85:9D:20"
    loop = asyncio.get_event_loop()
    loop.set_debug(True)
    loop.run_until_complete(run(address, True))```

[hbldh]

Sorry for not responding earlier, but this is a question that I cannot answer quickly and therefore it has not been dealt with...

If the problem is "How do I make the connection last longer than the 1 second that await asyncio.sleep(1.0) provides", then try using an asyncio.Event that you wait on at the end of the run method. This could be triggered by an external force like in the async_callback_with_queue example.

The 20 byte limit is not a problem that Bleak imposes per se, but it is a limit negotiated by your OS and your peripheral. Bleak can do little to modify it, as far as I have found out, but I may be wrong on this.