ROSMicroPy

gentijo · February 7, 2024, 5:59am

Hi All,

I have been working on a Project called ROSMicroPy, an integration of MicroROS and Micropython supporting the ESP32 platform. ROSMicroPy

It’s rounding the corner of being done and I am looking for feedback.

Are the Docs clear
SDK implementation
If someone from eProsima can take a look at my Type Support system and let me know if I am painting myself into a corner, it would be greatly appreciated. Here is a write up on how it works ROSMicroPy Type Support Integration | ROSMicroPy

Suggestions and PR’s are welcome

SDK Docs: Python class: (ROSMicroPy) | ROSMicroPy

How to get started Welcome to ROSMicroPy Python Development | ROSMicroPy

What works:

You can register data types
Subscribe to events
Publish messages

What needs work:

You need to recompile to change the SSID/Password, I need to change the locus of control from MicroROS to Micropython for Wifi managment as the MicroROS network interface does not work with MicroPython’s WEBRepl
Type support probably has bugs, i need to expand on my testing. Type Support does not support sequences yet.
Server support
Documentation, Documentation, Documentation

Thank you
John

nuno · February 8, 2024, 2:12pm

This is great! I have not tried it yet on a device.

My initial suggestion would be to use Sphinx for the documentation, to make it easier to navigate.

Have you looked into running the ESP32 without the necessary agent on the remote machine, i.e., with embeddedRTPS , linked from GitHub - micro-ROS/micro_ros_espidf_component: micro-ROS ESP32 IDF component and sample code ?

gentijo · February 8, 2024, 6:04pm

Hi @nuno, thank you for responding. re:embeddedRTPS, I am sure it can be. My challenge is to understand the type support stack better, my education came about by attaching my Jtag debugger and setting a breakpoint rmw_publish, similar on the receive side. Then single step away.

I think, at the low level, I might have tied myself to the eProsima code, that’s why I was asking for advice about my Type Support code. My Type Support code is a bit of a side car along with the installed Type Support. The core of my code is generic, i.e. my serialize / deserialize uses what I am calling an instruction list to drive both. I went in this direction to allow for run time type definition natively in Python.

This posed a bit of a challenge as the MicroROS type support interface requires a structure that contains function pointers to the low level functions and my code uses the same core methods for all types.

I solved it by creating this big chunky macro that creates stub functions so serialize_slot1 → serialize, where serialize_slot one calls the core serialize function passing a 1 for the slot_id, the slot_id points to a run time defined slot with all the necessary type metadata.

So Micropython has it’s own (mostly) full implementation of a ROS Type system, but that Type System, is not a full replacement and depends on the installed Type System installed with MicroROS.

My intention in making this announcement was simply to let people use it and provide feedback, like yours, so I can get out of my bubble and make the code more usable for all.

Here are some code references.

How the Geometry:Twist type is defined in Microipython

github.com

gentijo/ROSMicroPy/blob/main/python_example_code/rostype/Twist.py

from rostype.Vector3 import Vector3

class Twist():
    
    dataMap = {
        "message_name": "Twist",
        "message_namespace": "geometry_msgs::msg",
        "components": [
            {
                "name": "linear",
                "type": "Vector3",
                "components": [
                    {
                        "name": "x",
                        "type": "float64"
                    },
                    {
                        "name": "y",
                        "type": "float64"
                    },

This file has been truncated. show original

How that type is registered and used to register a type definition and use that for subscribing to an event. ROSMicroPy/python_example_code/TwistedSubscriber.py at f1319054c0f0a0732b1b18593cd2df2a47f85e97 · gentijo/ROSMicroPy · GitHub

My big chunky macro

github.com

gentijo/ROSMicroPy/blob/f1319054c0f0a0732b1b18593cd2df2a47f85e97/extra_packages/ROSMicroPy/mp_uros_type_support/mp_uros_type_support.c#L32


      
          #define mpy_uros_type_support_slots 20
          dxc_cb_t *g_typeSupportCtrlBlks[mpy_uros_type_support_slots];
          
          /**
           * This specialized #define macro utilizes a feature in GCC where you can define functions in a function.
           * We will use this to define the Type Support functions but append a number that corresponds to an entry
           * in the typeSupport array entry. The functions defined call the real function and passes along a
           * slot number allowing the type support functions to have access to the schema data needed to process
           * data from Micropython to ROS
           */
          #define typeSupportEntry(n)                                                                                                            \
            bool mpy_uros_ts##n##_serialize(const void *untyped_ros_message, ucdrBuffer *cdr)                                                    \
            {                                                                                                                                    \
              return mpy_uros_typesupport_cdr_serialize(n, untyped_ros_message, cdr);                                                            \
            }                                                                                                                                    \
            bool mpy_uros_ts##n##_deserialize(ucdrBuffer *cdr, void *untyped_ros_message)                                                        \
            {                                                                                                                                    \
              return mpy_uros_typesupport_cdr_deserialize(n, cdr, untyped_ros_message);                                                          \
            }                                                                                                                                    \
            size_t mpy_uros_ts##n##_get_serialized_size(const void *mp_obj, size_t current_alignment)                                            \
            {                                                                                                                                    \

How that macro is used, it’s important to realize that the macro both defines code that is rendered at compile time, and runtime code that runs when init() is called. ROSMicroPy/extra_packages/ROSMicroPy/mp_uros_type_support/mp_uros_type_support.c at f1319054c0f0a0732b1b18593cd2df2a47f85e97 · gentijo/ROSMicroPy · GitHub

gentijo · February 8, 2024, 6:06pm

Thank you for the reference, I will look into it.

gentijo · March 1, 2024, 11:12pm

ROSMicroPy has been updated to IDF 5.1 along with Micropython V1.22-rel
This is in prep to incorporate LVGL and JSON forms along with IDF5.1 support for SRAM0/1 to be used for IRAM

Micropythons > V1.20 only support IDF5.1 now.

system · March 31, 2024, 11:12pm

This topic was automatically closed 30 days after the last reply. New replies are no longer allowed.

Topic		Replies	Views
Micro-Ros with Micropython Embedded esp32 , micropython	1	4912	August 23, 2022
Future for ROS2Arduino? Embedded	6	2173	January 15, 2022
micro-ROS porting to ESP32 Embedded embedded	28	25369	August 26, 2023
Request for comment, on device .msg compiler for Micropython Embedded ros2 , embedded , micropython , micro-ros	8	4262	June 27, 2023
MicroROS Platformio - New example available General ros2 , embedded	1	1095	November 7, 2022

ROSMicroPy

SDK Docs: Python class: (ROSMicroPy) | ROSMicroPy

How to get started Welcome to ROSMicroPy Python Development | ROSMicroPy

What works:

What needs work:

Related Topics