Initial Steps

Developing ROS 2 applications for cube:its is fastest when using VS Code Dev Containers. This is the recommended and supported workflow. It provides:

• A pre-configured ROS 2 development environment
• The correct dependencies for cube:its and Vanetza
• Reproducible builds across Linux, macOS, and Windows
• Separation between the host system and ROS 2 tooling
• Network connection to the cube:evk

With dev containers, ROS 2, colcon, Python tools, and build dependencies do not need to be installed on the host. VS Code handles this automatically.

1. Clone the Example Repository (Host)

We provide a complete ROS 2 workspace with cube:its examples:

1
2
host:~$ git clone https://github.com/cubesys-GmbH/ros_v2x_apps
host:~$ cd ros_v2x_apps

Open this folder in VS Code (with the Dev Containers extension). When VS Code detects the .devcontainer/ folder, it will ask:

"Reopen in Container?"

Click Yes.

VS Code will now build the development container and open a full ROS 2 environment inside it.

2. Start cube:its in Remote Mode (On the cube:evk)

On the cube:evk, run:

1
cube:~$ start-its --remote

This launches cube:its in a mode where it exposes all ROS 2 nodes and topics over your network. Your dev container on the host can now discover and interact with these topics.

3. Build the Workspace (Host, inside Dev Container)

Open a terminal inside the dev container:

1
2
host:~$ cd dev_ws/
host:~$ colcon build

Example output:

1
2
3
4
Starting >>> v2x_apps
Finished <<< v2x_apps [3.72s]

Summary: 1 package finished [4.62s]

Source the workspace:

1
host:~$ source install/setup.bash

4. Configure ROS Discovery for Remote Communication

To interact with cube:its running on the cube:evk, set the discovery domain and range:

1
2
host:~$ export ROS_DOMAIN_ID=42
host:~$ export ROS_AUTOMATIC_DISCOVERY_RANGE=SUBNET

5. Verify the Connection

Now your dev container should see all ROS 2 topics exposed by cube:its:

1
host:~$ ros2 topic list

Example output:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/its/cam_ego_view
/its/cam_provided
/its/cam_received
/its/cam_transmitted
/its/denm_received
/its/cpm_provided
/its/cpm_received
/its/cpm_transmitted
/its/position_vector
/kinematics/body_motion
/kinematics/ground_motion
/kinematics/ground_motion_vehicle
/kinematics/position
/vanetza/btp_indication
...

If you see these topics, you are now fully connected to cube:its from your Dev Container.

You can now:

• write ROS 2 nodes in Python or C++
• subscribe to CAM, CPM, DENM, or position topics
• publish your own DENMs
• access kinematic data (GNSS, heading, motion, IMU fusion)
• run tests and debug directly from your laptop

All without installing ROS 2 locally.

Why This Workflow?

Isolation

The host stays unmodified. ROS 2 runs inside the dev container.

Reproducibility

Every team member runs the same environment.

Split execution

The cube runs the full V2X stack. The host runs only the application code.

Rapid iteration

Write, build, run, and test against the real V2X radio, GNSS, IMU, and facility layers.

Next Steps

You are now set up to develop and run ROS 2 applications that interact with the cube:evk.

• Write a subscriber for /its/cam_received
• Consume GNSS using /its/position_vector
• Build higher-level ITS applications using CPM, DENM, VAM, etc.

For detailed examples, continue with ITS Facilities.