Wondering about a few topics (datalogging; remote control; await uses; await wait(0))

[TechnicBRICKs]

Hello,
I've a few generic questions/observations, then I decided to put them into a single post rather than opening individual ones. Hope this is ok!

1. I can't find any Pybricks classes that support datalogging for the Technic Hub.
   I know this hub does not have a file system, but still is there any other solution than writing to the console output?

2. Are there any plans to support custom remote control designs in the smartphone?In my use case I've a cooperative MOC with several hubs running. I'd like to have a solution where I can set or change values to test certain variables and currently the solution is to change them in code and upload them in the several hubs, which is not very convenient.This solution might allow even broader use cases.

3. For multitasking purposes it is necessary in some cases to add the 'await' keyword before the call of certain methods.
   I understand this is required for those that take longer to complete, as is the case of some motor methods. In certain cases it is also obvious this is not needed or it can't even be used (like run and stop methods), but that's not always the case.
   Would it be possible to make explicit in the documentation, which methods require an 'await' in case of multitasking use?

4. While programming with blocks, if one looks at the generated python code, it is possible to realize that Pybricks adds some "await wait(0)" statements. Almost always before while statements and always after these.It doesn't seem necessary when I write my own code, hence can you comment on this behaviour?

Thanks and best regards,
Fernando

[dlech]

1. I know this hub does not have a file system, but still is there any other solution than writing to the console output?

There is an undocumented AppData class that can be used to send data over Bluetooth as well. It is not documented because we haven't written the counterpart to that the runs on your computer, so you would have to figure that out.

2. Are there any plans to support custom remote control designs in the smartphone?

No definite plans at this time.

2. g. I'd like to have a solution where I can set or change values to test certain variables and currently the solution is to change them in code and upload them in the several hubs,

This sounds like it could be done already using the Bluetooth broadcasting/observing. All of the hubs in the MOC would be observing, then add one more hub to act as the broadcaster (or some other BLE device where you can control advertising data - arduino/rpi/etc.). The same data gets broadcast to all hubs, so they would all receive the same data at the same time.

3. Would it be possible to make explicit in the documentation, which methods require an 'await' in case of multitasking use?

This is already documented. If the docs for a method say async def instead of just def, then they need to be awaited, otherwise strange and unexpected things will happen. If it just says def, then trying to await it will fail.

4. While programming with blocks, if one looks at the generated python code, it is possible to realize that Pybricks adds some "await wait(0)" statements. Almost always before while statements and always after these.It doesn't seem necessary when I write my own code, hence can you comment on this behaviour?

Multitasking uses coroutines rather than threads. For non-programmers, this probably doesn't mean much, so I'll give an analogy.

It's kind of like waiting in a queue at the bank.

For threads, if someone is taking too long for the request to be handled, they are forced to step aside and let the next person in line have a turn. After a while, the teller returns their attention to the first person to see if they are ready to continue or now. This process continues and tries to fairly share the tellers time with all customers.

For coroutines, no one else can force the customer to step aside. The customer has to volunteer to do that themselves. If one person keeps making more transactions and never goes to the back of the line, everyone else in the queue never gets to do anything.

The await statements means letting the next person in line have a turn. If a function has an infinite loop with no await, the no one else gets a turn. In your own code, your loops were perhaps not infinite, so you would not notice as much.

Here is an example:

# "bad" example
async def wait_for_sensor():
    while not touch_sensor.pressed():
        # There is no `await` inside of the loop.
        # No other code can run until the touch sensor is pressed!
        pass

If the touch sensor was pressed soon or there was no control loops being blocked, you might not notice a problem with the code above. But the proper way to write it is as below.

# "good" example
async def wait_for_sensor():
    while not touch_sensor.pressed():
        # This gives other functions/tasks a chance to run while
        # we are waiting for the sensor event.
        await wait(0)

[TechnicBRICKs]

Many thanks for your answers!!

2. Thanks! I also thought about making one of the hubs as a master who sends such values to all others.
   The remote solution would still usefull, although I understand it may not justify the effort on your side,

3. Thanks, my bad!
   I just found it (again). Not exactly as you mentioned, but the await keyword preceeds some methods on the documentation.
   They are not so much, and that's probably why I didn't remember of these being there.

4. Thanks, I perfectly understand your explanation!
   Indded I've infinite loops in my example, but also other await calls within. Hence I probably don't need such await wait(0), nevertheless I understand your approach as a safety good practice and I'll use from know on.
   Didn't really understand why you use it also before some of the while statements as in the example (screenshot) above, though.

[dlech]

4. Didn't really understand why you use it also before some of the while statements as in the example (screenshot) above, though.

I think that is just because it is automatically generated code. And I think it is more that it is at the beginning of the function rather than before each while loop. It just so happens that your programs don't have anything else before the while loop. The code generator could probably be a bit smarter about this, but it probably assumes that it can't know if there are any other awaits in the function and so just always adds one just to be safe.

[dlech]

3. They are not so much, and that's probably why I didn't remember of these being there.

Yes, they are easy to miss. Maybe we could use a different background color or add an icon or something to make it easier to see there is something different.

[laurensvalk]

Great questions and great answers, thanks!

As far as the location of the await wait(0) goes, it is indeed at the start of loops and functions. This is the standard Blockly way of avoiding infinite loop traps. Making it a bit smarter would require some kind of parsing of the code. Just checking for the existence of an await isn't enough, since it may not be executed if it is inside an if/else block, for example. But we could indeed avoid adding it if the user already has their own wait at the very beginning.

but still is there any other solution than writing to the console output?

Note that you can print comma separated lines so you can plot them by just pasting it into a spreadsheet editor. This is pretty quick. Here are some examples.

You can multitask it with your code so logging stops at exactly the right time:

[TechnicBRICKs]

Thank you Laurens!

I've myself used to print data and import into an Excel for a study, that I also posted here some years ago (BTW, I owe you an update there).
I was just wondering about more "advanced" usecases, where I may want to collect data and write other messages simultaneously, thus avoiding to write them in the same output.
But ofc there are many possible ways to go around this. Nevermind, I was just asking how it goes currently.