rclcs

WARNING : The rcl api and the generated message types did change recently and I couldn’t adapt yet. You will be able to compile everything but you will run into segfaults while execution! These are usually some easy fixes by adapting the methods called in the rcl. Also support for windows is more than buggy at the moment! (Feel free to get it running)

rclcs is C# wrapper for ROS2. It is designed to provide an interface similar to the rclcpp. The idea behind the wrapper is to reproduce the ros message as a C# struct with the same memory layout as their C counterparts. So the messages (structs) can directly be passed to the rcl without any conversions. For easier usage these structs are wrapped into classes so you don’t have the inconvenience of memory handling.

Important: I needed to force building 64bit assemblies. If you need 32bit support you have to add fitting targets in your csproj files and adapt the add_msbuild cmake function to build the 32bit target instead!

How to use

These instructions are mostly the same on Windows and Linux.

Get your copy of ROS and compile it according to the documentation:

For Linux : https://github.com/ros2/ros2/wiki/Linux-Development-Setup

For Windows: https://github.com/ros2/ros2/wiki/Windows-Development-Setup

Make sure you’ve got mono/ .Net in a version installed that targets at least the framework version 4.5.1.

Then from your ros2 workspace base directory:

  cd src/ament
  git clone https://github.com/firesurfer/dotnet_cmake_module
  cd ../ros2
  git clone https://github.com/firesurfer/rclcs
  cd rosidl
  git clone https://github.com/firesurfer/rosidl_generator_cs

Then edit the file in rosidl_typesupport/rosidl_default_generators/CMakeLists.txt and add the following line after the other generators:

  ament_export_dependencies(rosidl_generator_cs)

Then go back to the ros2 workspace and do:

Linux

rm -rf build/ install/
./src/ament/ament_tools/scripts/ament.py build

Windows

rmdir /S /Q build install
python src\ament\ament_tools\scripts\ament.py build

Afterwards take a look at the Examples section.

Install to the GAC (Global assembly cache)

This is optional but useful. But it just makes sense if the code is stable. By installing the assembly into the GAC you won’t need the WindowsAssemblyLoader or the MONO_PATH any more (See examples for more information). But you are tied to the installed version of the rclcs.

1. Create a keyfile: (sn is called sn.exe on windows)

sn -k <keypair name>

1. Tell the compiler to use it:

In your CMakeLists.txt in the add_assemblies section add to the COMPILER_ARGS

"-keyfile:<Path to the keypair>"

1. Install to the GAC:

gacutil -i <assembly name>

Examples

You can have look at my testing workspace which contains some examples (And is still a bit messy, but you should get ahead with it).

For windows you need to use the WindowsAssemblyLoader as main method and replace the line inside the StartMain(string[] args) function with your own start function.

For starting your own project see starting your own project

What works at the moment

• Init and deinit RCL
  • Errorhandling of return values, throwing exceptions where useful.
  • Implemented rmw errorhandling methods
• Create a Node
• Create a Publisher
• Create a Subscription
• Create a Service/Client

File truncated at 100 lines see the full file