Calling MicroPython from C code

[gentijo]

@stinos do you have any examples on how to call a function in micropython from C code asynchronously
ref: http://web.mit.edu/people/amliu/vrut/python/ext/callingPython.html

[stinos]

What do you mean with 'asynchronously'? Python's async? In a different C thread? In any case: it' still just a function call, I think everything in this library is orthogonal to any type of multithreading/async features. That happens on another level.

[gentijo]

I am adapting Micropython to work with MicroROS, see https://github.com/gentijo/RosBots.
https://micro.ros.org/

ROS has a notion of message subscription, where you can subscribe to messages and when a node sends a message you are notified via a callback which will occur in a separate thread from Micropython. Micropython may also be performing another task as the same time, so it needs to be thread safe.

The calling pattern in my head would allow boot.py to subscribe to messages such as cmd_vel,
where "cmd_vel" is mapped to a callback to a Python module / method.

At the C/ROS layer, the call back registered by the Python boot code will be stored as a variable.
When the ROS layer receives the message it will forward it to the MicroPython layer using that registered callback while also marshalling the data supplied by the message into the Micropython namespace.

I was looking to see if your wrapper functions supported that style of operation.

Thank you
John

[stinos]

The principle is certainly possible, but the only thing micropython-wrap could provide is marshalling (of C++ types mostly, C to some extent as well if wrapped in appropriate types), creating Python modules, and MicroPython initialization (which are just the essentials from other ports' main.c but pasted in one single function). But it doesn't provide thread-safety because it doesn't really sit at the appropriate level to do so. And there are too many different ways to do that;

a callback which will occur in a separate thread from Micropython

So ROS provides that thread? Note at some point you need to initialize MicroPython before it can be used. Which would then need to be done in an entry point of such thread, or in a callback called once only. Or you keep a flag to figure out if it's done already.

Micropython may also be performing another task as the same time, so it needs to be thread safe.

That could be done with microPython threading though depending on which platform you run this that might not be available.

Otherwise it's a bit tricky, depends on what you want to do there, as said there are multiple ways to do that. For example an architecture I'm running is:

• one thread runs micropython
• another thread posts commands to a thread-safe C++ queue
• whenever the micropython code runs something like ProcessQueue it's going to take commands of the queue and run them. These commands can run Python code in turn, which is at that point thread-safe as far as Python is concerned because it runs in that thread, and which are (if needed) made thread-safe by having mutexes in the underlying C++ code when objects on the other thread need to be accessed