Sending multiple serial functions concurrently.

[Delta0001]

While using telemetrix-aio, I am finding that it takes an extremely long time for my callbacks to respond after a pin's output changes. To illustrate, I have combined blink.py with digital.py to get the following (cut out copyright and function comments for readability):

import asyncio
import sys
import time

from telemetrix_aio import telemetrix_aio

# some globals
DIGITAL_PIN = 12  # arduino pin number

# Callback data indices
CB_PIN_MODE = 0
CB_PIN = 1
CB_VALUE = 2
CB_TIME = 3


async def the_callback(data):
    date = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(data[CB_TIME]))
    print(f'Pin: {data[CB_PIN]} Value: {data[CB_VALUE]} Time Stamp: {date}')

async def digital_in(my_board, pin):
    # set the pin mode
    await my_board.set_pin_mode_digital_input(pin, the_callback)

async def blink(my_board, pin):

    # set the pin mode
    # await my_board.set_pin_mode_digital_output(pin)

    # toggle the pin 4 times and exit
    for x in range(4):
        print('ON')
        await my_board.digital_write(pin, 1)
        await asyncio.sleep(1)
        print('OFF')
        await my_board.digital_write(pin, 0)
        await asyncio.sleep(1)


# get the event loop
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)

# instantiate telemetrix_aio
board = telemetrix_aio.TelemetrixAIO()

try:
    # start the main function
    loop.run_until_complete(digital_in(board, DIGITAL_PIN))

    loop.run_until_complete(blink(board, DIGITAL_PIN))
except KeyboardInterrupt:
    loop.run_until_complete(board.shutdown())
    sys.exit(0)

Output of after running my code (cut out copyright and connection messages for readability):

ON
OFF
ON
OFF
ON
OFF
ON
OFF

Output of after stepping through my code (slowly stepping through a break point in the callback):

ON
Pin: 12 Value: 1 Time Stamp: 2022-06-28 14:19:23
OFF
ON
Pin: 12 Value: 0 Time Stamp: 2022-06-28 14:19:47
OFF
Pin: 12 Value: 1 Time Stamp: 2022-06-28 14:20:01
ON
Pin: 12 Value: 0 Time Stamp: 2022-06-28 14:20:14
OFF
Pin: 12 Value: 1 Time Stamp: 2022-06-28 14:20:24
ON
Pin: 12 Value: 0 Time Stamp: 2022-06-28 14:20:37
OFF
Pin: 12 Value: 1 Time Stamp: 2022-06-28 14:20:52
Pin: 12 Value: 0 Time Stamp: 2022-06-28 14:21:02

As you can see in the first output, running the code (even with a 1 second delay on blink) was fast enough that it never got a chance for the callback to return.
The second output shows that while manually stepping through the code, I got all 8 callbacks. But the callbacks I got back were extremely delayed and would return the read two writes after!

Is this expected behavior? And if so, what is the right way to write something that will do a blocking read and blocking write?

[MrYsLab]

I may be misunderstanding the intent of the code, so let me state what I believe it is doing. Please correct me if I am misunderstanding.

1. Pin 12 is being established as an input pin:

loop.run_until_complete(digital_in(board, DIGITAL_PIN))

2. The blink function sets pin12 as an output and then toggles pin12 four times.

A digital pin can be either an input or an output, but not both simultaneously. The digital_in function establishes the pin as an input, then blink sets it as an output.

I am not sure why you are getting callbacks at all since Telemetrix4Arduino triggers off of the pin's current mode. Only if the pin is a digital input (which it no longer is), can a report be generated.

Please let me know if this answers your question.

[Delta0001]

Thanks for the quick reply!

A digital pin can be either an input or an output, but not both simultaneously

This seems to be the key. You are right, I was erroneously trying to use both simultaneously. It seems like I was still getting callbacks because it is possible to write to an input pin which still enables/disables the pullup resistor.
My theory is that during period where pin_mode is changed to INPUT_PULLUP, it tries to read the last value which is is probably the last write value(?). Either way, I am using the pins non-bidirectional and will test it further tomorrow.

Thanks again!

[MrYsLab]

@Delta0001 Please be aware that most Arduino boards have limited buffer space for serial communication, and Arduinos do not support flow control. Some commands may get lost if you rapidly send many commands that fill up the Arduino's buffer. The remedy, in that case, is to put a short delay between sending the commands.