How to cross compile ROS2 distro by taken VxWorks RTOS as an example

© 2020 WIND RIVER. ALL RIGHTS RESERVED.
How to cross-compile ROS2 distro by
taken VxWorks RTOS as an example
 Andrei Kholodnyi | Principal Technologist | Wind River Systems

2 © 2020 WIND RIVER. ALL RIGHTS RESERVED.
 Wind River & Robots
 What it VxWorks
 Why cross-compilation
 How to cross-compile
 ROS2 distro structure for cross-
compile
 Setup ROS2 for cross-compilation
 ROS2 cross-compilation
 Run ROS2 example using QEMU
 Conclusion
TOPICS OF MY TALK TODAY
> ROS2 Mobile Robotics, Dependability
> Industrial, TSN, intelligent edge
> ROS2 Open Source Community (real-time WG co-chair)
> Products, Solutions; Partnerships & University Programs
Andrei Kholodnyi
Principal Technologist
Technology Office
> Thematic pathfinding for the new technologies (Autonomous
Robotics, Dependability, TSN)
> Continuous Innovation
> Improve existing and create new company products
> Participation to alliances (GENIVI, FASTR, PICMG)
> Led and delivered IVI, telematics and connectivity automotive
projects
FOCUS
RELEVANT PROJECTS (selection)

NASA
MITSUBISHI ELECTRIC
OUR SOFTWARE RUNS ALL THESE ROBOTS

What is VxWorks RTOS
 32/64 bits on ARM, Intel, MIPS, PowerPC, RISC-V
 Proprietary real-time OS, POSIX PSE52
 Kernel/user space separation, user space optional
 C/C++11/14, possible to develop kernel C++ modules and user apps
 Safety certifiable: DO-178, ISO 26262, IEC 61508
 Toolchain LLVM 8, Dinkumware C/C++ libs
 Proprietary build system
 Kernel shell
 Eclipse-based IDE, Windows/Linux hosts

What is a native compilation?
ROS2 dependencies: ASIO,
tinyxml2, OpenCV, Eigen, PCL
Tools: Cmake, autotools, make etc,
Python3.8
POSIX OS: Linux
ROS2 apps (Hello, World!)
stdlibc++, Python3.8
Toolchain: compiler, linker, libc
Desktop PC: Intel 86_64 HW
Python3.8
POSIX OS: Linux
Raspberry Pi4: ARM aarch64 HW
Tools: ament, colcon
Libs: rcl, rclcpp
View: Rviz, Qt
Libs: rcl, rclcpp
View: Rviz, Qt

What is a cross compilation?
Python3.8
POSIX OS: VxWorks
libc, libc++,
POSIX OS: VxWorks
libc, libc++
Embedded: Intel 86_64 HW
Libs: rcl, rclcpp
View: Rviz, Qt
Libs: rcl, rclcpp

Why to cross compile
 Different HW arch on the target: Intel, ARM, PowerPC, RISC-V, MIPS,
SPARC
 Different Operating systems on the target: VxWorks, QNX, eSol,
FreeRTOS, Zephyr
– it is not possible to compile natively even on Linux Intel
– User space incompatibility with the same CPU instruction set
 Tuning for performance, footprint etc.
 Who knows what HW architecture Raspberry Pi4 has ?

How to cross compile
 Cross-compile toolchain (OS and Arch specific)
– How to create a toolchain https://wiki.osdev.org/OS_Specific_Toolchain
– Prebuilt ARM: sudo apt install gcc-arm-linux-gnueabihf
 Emulator – QEMU to run cross-compiled binaries
– sudo apt install qemu
 Where to get cross-compiler tools?
– Ubuntu repos
– Directly by vendors (depending on OS and HW Ach)
– VxWorks SDK https://labs.windriver.com/downloads/wrsdk.html#read

A native compilation – Hello, <OS> <HW Arch>
$ cat hello.c
#include <stdio.h>
#include <sys/utsname.h>
Int main (void)
{
struct utsname data;
uname(&data);
printf ("Hello, %s!n", data.sysname);
return 0;
}
$ gcc -Wall hello.c -o hello -static && ./hello
Hello, Linux x86_64

A cross compilation – Hello, <OS> <HW Arch>
$ source $HOME/wrsdk-vxworks7-qemu/toolkit/wind_sdk_env.linux
#include <stdio.h>
#include <sys/utsname.h>
Int main (void)
{
struct utsname data;
uname(&data);
printf ("Hello, %s!n", data.sysname);
return 0;
}
$CC -Wall hello.c -o hello -static && ./hello
Segmentation fault (core dumped)

QEMU to run cross-compiled binaries
POSIX OS: VxWorks
Hello, World!
Linux OS
$ qemu-system-x86_64 -m 512M -kernel
$WIND_SDK_TOOLKIT/../bsps/itl_generic_2_0_2_1/boot/vxWorks -net nic -display
none -serial stdio -monitor none -append "bootline:fs(0,0)host:vxWorks
h=192.168.200.254 e=192.168.200.1 u=target pw=boot o=gei0" -usb -device usb-
ehci,id=ehci -device usb-storage,drive=fat32 -drive
file=fat:ro:./,id=fat32,format=raw,if=none

Run ./hello on VxWorks
-> cmd
[vxWorks *]#
[vxWorks *]# cd /bd0a
[vxWorks *]# ls hello.c hello
[vxWorks *]# ./hello Launching process './hello' ...
Process './hello' (process Id = 0xffff8000005bde80) launched.
Hello, VxWorks 7 x86 Processor (ACPI_BOOT_OP) SMP/SMT

What do we need to cross compile ROS2?
 ROS2 dashing sources
 VxWorks SDK - https://labs.windriver.com/downloads/wrsdk.html
– Cross compilation toolchain
– toolchain.cmake and platform.cmake
– VxWorks kernel
– Some user space libraries and headers: libc, libc++, libcrypto etc.
 VxWorks ROS2 build - https://github.com/Wind-River/vxworks7-ros2-build
– ROS2 dependencies
– ROS2 dashing release
 VxWorks ROS2 patches - https://github.com/Wind-River/vxworks7-layer-
for-ros2
– VxWorks specific patches, e.g. missing functions
– ROS2 specific patches, e.g. https://github.com/ros2/rosidl_python/issues/111

ROS2 dashing release
 Target binaries
– rclcpp, rmw, dds
 Tools
– ament, colcon, lint, cmake etc.
 Visualization tools
– ros-visualization (rviz, rqt)

Setup ROS2 for the cross-compilation
 Source VxWorks cross-compilation environment
 Strip down ROS2 build to the packages you need on the target
 Patch ROS2 dashing release
 Cross-compile dependencies (asio, tinyxml2, etc.)
 Cross-compile ROS2 dashing release

Toolchain.cmake and VxWorks.cmake
$ $HOME/vxworks7-ros2-build
$ cat buildspecs/cmake/rtp.cmake
... set(CMAKE_SYSTEM_NAME VxWorks)
set(CMAKE_SYSTEM_VERSION 7)
set(CMAKE_CROSSCOMPILING ON)
$ cat buildspecs/cmake/Platform/VxWorks.cmake
...
set(CMAKE_INCLUDE_PATH
/include
/include/usr/h/published/UTILS_UNIX
/include/usr/h/public)
set(CMAKE_LIBRARY_PATH
/lib
/include/usr/lib/common)

Strip down ROS2 build to the packages we need
$ cat pkg/ros2/packages.mk
...
ROS_IGNORE_DIRS= ros-visualization
ros2/rviz
ros2/poco_vendor
osrf/osrf_testing_tools_cpp
ros-planning
ros2/rmw_connext
ros2/rosidl_typesupport_connext
ros2/rmw_opensplice
ros2/rosidl_typesupport_opensplice
ament/ament_lint
ament/uncrustify_vendor
ros2/rcl_logging/rcl_logging_log4cxx
eclipse-cyclonedds
# Ignore Python-specific packages
ROS_IGNORE_DIRS+= ament/ament_cmake/ament_cmake_pytest
osrf/osrf_pycommon
ros2/demos/demo_nodes_py
ros2/geometry2/tf2_py
ros2/kdl_parser/kdl_parser_py
ros2/rclpy
ros2/rosidl_python/rosidl_generator_py

ros-visualization/rqt/rqt_gui_py
ROS2_EXAMPLES=examples_rclcpp_minimal_action_client
examples_rclcpp_minimal_client
examples_rclcpp_minimal_publisher
examples_rclcpp_minimal_subscriber
examples_rclcpp_minimal_action_server
examples_rclcpp_minimal_composition
examples_rclcpp_minimal_service
examples_rclcpp_minimal_timer

Strip down ROS2
tinyxml2, libyaml, Eigen, PCL
Python3.8
POSIX OS: Linux
ROS2 apps (examples, tests)
Libs: rcl, rclcpp,
rmw, rclpy
View: Rviz, Qt
ROS2 dependencies: tinyxml2,
libyaml
POSIX OS: VxWorks
ROS2 apps (examples)
libc, libc++
Libs: rcl, rclcpp, rmw

Cross-compile ROS2
colcon build --symlink-install --cmake-force-configure --packages-select examples_rclcpp_minimal_timer
--cmake-args
-DCMAKE_BUILD_TYPE=Debug
-DCMAKE_VERBOSE_MAKEFILE:BOOL=ON
-DBUILD_TESTING:BOOL=OFF
colcon build --symlink-install --cmake-force-configure --packages-select examples_rclcpp_minimal_timer
--cmake-args
-DCMAKE_BUILD_TYPE=Debug
-DCMAKE_VERBOSE_MAKEFILE:BOOL=ON
-DCMAKE_PREFIX_PATH=$HOME/vxworks7-ros2-build/export/root
-DCMAKE_TOOLCHAIN_FILE=$HOME/vxworks7-ros2-build/buildspecs/cmake/rtp.cmake
-DBUILD_TESTING:BOOL=OFF
Starting >>> examples_rclcpp_minimal_timer
Finished <<< examples_rclcpp_minimal_timer [3.91s]
Summary: 1 package finished [4.51s]

Run ROS2 example using QEMU
$ $HOME/vxworks7-ros2-build
$ qemu-system-x86_64 -m 512M -kernel $WIND_SDK_TOOLKIT/../bsps/itl_generic_2_0_2_1/boot/vxWorks -net
nic -display none -serial stdio -monitor none -append "bootline:fs(0,0)host:vxWorks h=192.168.200.254
e=192.168.200.1 u=target pw=boot o=gei0" -usb -device usb-ehci,id=ehci -device usb-storage,drive=fat32
-drive file=fat:ro:./export/root,id=fat32,format=raw,if=none
-> cmd [vxWorks *]#
[vxWorks *]# set env LD_LIBRARY_PATH="/bd0a/lib„
[vxWorks *]# cd /bd0a/llvm/bin/
[vxWorks *]# rtp exec -u 0x20000 timer_lambda.vxe
Launching process 'timer_lambda.vxe' ...
Process 'timer_lambda.vxe' (process Id = 0xffff80000046f070) launched.
[INFO] [minimal_timer]: Hello, world!

Conclusion
 We have seen how easy to cross-compile ROS2 for the non-Linux POSIX
OS – VxWorks in this case
 We have learned what are the differences between native and cross-
compilation
 We have prepared and setup a cross development environment and built
ROS2 binaries
 We have learned how to split ROS2 packages in host and target parts
 We have used QEMU to run cross-compiled binaries on the development
host

How to cross compile ROS2 distro by taken VxWorks RTOS as an example

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to How to cross compile ROS2 distro by taken VxWorks RTOS as an example

Similar to How to cross compile ROS2 distro by taken VxWorks RTOS as an example (20)

Recently uploaded

Recently uploaded (20)

How to cross compile ROS2 distro by taken VxWorks RTOS as an example

Editor's Notes