Multitasking and dynamic PUPDevice creation

[afarago]

In my scenario I would like to create a multitasked program and dynamically create / remove devices.

When using the multitask, run_task tools I receive an error This can only be called before multitasking starts.

Is my approach of creating PUPDevice dynamically completely wrong?

Code:

from pybricks.hubs import PrimeHub
from pybricks.iodevices import PUPDevice
from pybricks.parameters import Button, Color, Direction, Port, Side, Stop
from usys import version, implementation
from pybricks.tools import wait, StopWatch, multitask, run_task

hub = PrimeHub()

def report_status_line(line):
    # it could be a buffered queue, yet for sake of simplicity go for print
    print(line)

async def monitor_status(callback, threshold_ms):
    lastvalue = None
    while True:
        value = callback()
        if (lastvalue != value):
            lastvalue = value
            report_status_line(value)

        if threshold_ms == None: break
        # print("1",threshold_ms)
        await wait(threshold_ms)
        # print("2",threshold_ms)

class PortReporter:
    def __init__(self, port):
        self.port = port
        self.portid = str(port).replace("Port.","")
        self.device = None
        self.deviceid = None

    def create_reporter(self):
        return monitor_status(lambda: f"P,{self.portid},{self.deviceid},{self.report_value()}", 100)

    def report_value(self):
        if not self.device:
            try:
                print("init ",1,self.port)
                self.device = PUPDevice(self.port)
                print("init ",2,self.port)
                info = device.info()
                self.deviceid = info["id"]
            except Exception as e:
                print(e, self.port)
                return "---"
        else:
            try:
                # device, deviceid = self.devices[idx]
                if self.deviceid in [48,49,65,75,76]: # SPIKE/Technic angular motors
                    value = self.device.read(3)[0] # APOS
                elif self.deviceid == 63: # SPIKE Force Sensor
                    forcevalue = self.device.read(0)[0]
                    value = forcevalue if forcevalue > 0 else self.device.read(1)[0] # FORCE or TOUCH 
                else:
                    value = self.device.read(0)[0] 
                return value
            except:
                # on error return empty value and disconnect this reporter
                self.devices = None
                # self.statusReporters[idx] = None
                return "---"

class HubCenterStatus:
    def __init__(self):
        self.scheduled_tasks = []
        self.init_ports()
        self.init_hub_reporters()

    def init_ports(self):
        self.ports = [Port.A, Port.B]
        try: 
            self.ports.append(Port.C)
            self.ports.append(Port.D)
        except AttributeError: pass
        try: 
            self.ports.append(Port.E)
            self.ports.append(Port.F)
        except AttributeError: pass

        for port in self.ports:
            reporter = PortReporter(port)
            self.scheduled_tasks.append(reporter.create_reporter())

    def init_hub_reporters(self):
        self.scheduled_tasks.extend([
            monitor_status((lambda : f"H,{hub.system.name()},{version},{implementation[2]},{implementation[3]}"), None),
            monitor_status((lambda : f"H:BAT,{hub.battery.voltage()},{hub.battery.current()},{hub.charger.status()}"), 10*1000),
            monitor_status((lambda : f"H:BUT,{"+".join(sorted(str(b).replace("Button.","")[0] for b in hub.buttons.pressed()))}"), 100),
            # monitor_status((lambda : f"H:IMU,{int(hub.imu.heading())},{1 if hub.imu.stationary() else 0}"), 100),
        ])

# ---------------------

hubcenter = HubCenterStatus()

# ---------------------

async def main():
    await multitask(*hubcenter.scheduled_tasks)

# Run the main program.
run_task(main())

[laurensvalk]

When using the multitask, run_task tools I receive an error This can only be called before multitasking starts.

As the error describes, motors and sensors can currently only be initialized before multitasking starts.

Creating a sensor object initializes a few things that may take some time. Since object creation is always synchronous, we require that it is done before multitasking starts to avoid blocking the loop.

It might be possible to defer initialization until the sensor is used for the first time, but that would take some work.

Or... we could accept the blocking nature in the loop and just allow it. In most cases, (re-)initializing devices on the fly is a user error and this exception helps you find it. But I agree that it can be useful in some cases, like the Port Viewer you're working on.

[afarago]

Ok, understood.
Definitely not the key use case, so for the time being, no point to follow-up.

I was just curious about the design decision and wanted to confirm my observation. Thank you!