ROS#

1. Download ROS TCP Endpoint
2. In your src folder of ROS TCP Endpoint, navigate to your Colcon worspace and run the following commands:

1
source install/setup.bash
2
colcon build
3
source install/setup.bash

3. In your Colcon workspace, run the following command, replacing <your IP address> with your ROS machine’s IP or hostname.

1
ros2 run ros_tcp_endpoint default_server_endpoint --ros-args -p ROS_IP:=192.168.0.5

• If you’re running ROS in a Docker container, 0.0.0.0 is a valid incoming address, so you can write ros2 run ros_tcp_endpoint default_server_endpoint --ros-args -p ROS_IP:=0.0.0.0
• On Linux you can find out your IP address with the command hostname -I
• On MacOS you can find out your IP address with ipconfig getifaddr en0

Once the server_endpoint has started, it will print something similar to [INFO] [1603488341.950794]: Starting server on 192.168.50.149:10000. (Alternative) If you need the server to listen on a port that’s different from the default 10000, here’s the command line to also set the ROS_TCP_PORT parameter:

1
ros2 run ros_tcp_endpoint default_server_endpoint --ros-args -p ROS_IP:=127.0.0.1 -p ROS_TCP_PORT:=10000

Unity#

1. Open the Package Manager (Window > Package Manager)
2. Click the + button in the upper lefthand corner of the window. Select Add package from git URL...
3. Enter the git URL for the package.
4. For the ROS-TCP-Connector, enter https://github.com/Unity-Technologies/ROS-TCP-Connector.git?path=/com.unity.robotics.ros-tcp-connector.

• (not necessary)For Visualizations, enter https://github.com/Unity-Technologies/ROS-TCP-Connector.git?path=/com.unity.robotics.visualizations.

5. Click Add.
6. open Robotics/ROS Settings from the Unity menu bar, and set the ROS IP Address variable to the IP you set earlier. (If you’re using Docker, leave it as the default 127.0.0.1.)
7. in the ROS Settings window, ROS2 users should switch the protocol to ROS2 now.

Publisher#

Unity publishes data (e.g., robot position coordinates) to a ROS 2 topic, which a ROS subscriber receives.

Concept: Unity can act as a Publisher, sending data continuously to a ROS topic. Typical Use Case: Streaming an object’s position, velocity, or any sensor-like data from Unity to ROS. Unity Side: You use the ROSConnection component to define the topic and message type, then call Publish() inside a Unity script. ROS Side: A ROS node subscribes to the same topic to consume Unity’s data.

Subscriber#

ROS2 publishes a topic to change the color, and Unity subscribes to that topic to update it.

Concept: Unity can also subscribe to ROS topics and react when messages arrive. Typical Use Case: ROS publishes sensor data or control commands, and Unity updates its simulation accordingly (e.g., changing color, triggering animations). Unity Side: In Unity, you register a callback for a topic using Subscribe(). ROS Side: A ROS node publishes messages to that topic.

Service#

Unity (Service Client) request an object’s pose in Unity. ROS (Service Server) calculates its pose and responds to Unity.

Concept: Unlike Publishers/Subscribers, a Service works as a request–response pattern. Typical Use Case: When Unity needs a precise answer at a specific moment. Unity as Service Client: Unity sends a request, e.g., “What’s the pose of this object?” ROS as Service Server: ROS computes the answer and returns it.

Service Call#

Concept: A Service Call can be repeated in sequence to drive a process step by step. Typical Use Case: Unity moves an object toward a goal. Once near the target, Unity requests a new goal from ROS, receives it, and continues.

Note: While Publisher and Subscriber cover most real-time data flows, Services shine when you need precise, one-off information. The Service Call tutorial illustrates how even a simple request–response can orchestrate dynamic behavior when chained together.

In practice, you’ll often combine these: Publishers for streaming state, Subscribers for reacting to commands, and Services for exact queries. The key is to choose the right communication model for the task at hand.

Running#

• Clone the Nav2 SLAM Example and run:

1
git clone https://github.com/Unity-Technologies/Robotics-Nav2-SLAM-Example.git
2
cd Robotics-Nav2-SLAM-Example/ros2_docker/colcon_ws

➡️ Expected Output: A 2D occupancy grid in RViz showing the robot’s map, with real-time updates as it navigates. You can extend this with custom visualization (e.g., battery status, camera feeds).

Visualization & Custom Visualizer#

DefaultVisualizationSuite includes:

• GoalPose → Robot position (topic-based).
• OccupancyGridVisualizer → SLAM map.
• LaserScanSensor → LiDAR scan.

You also need to add the following code in your Unity.

1
using System;
2
using System.Collections.Generic;
3
using RosMessageTypes.Geometry;                     // Generated message classes
4
using Unity.Robotics.Visualizations;                // Visualizations
5
using Unity.Robotics.ROSTCPConnector.ROSGeometry;   // Coordinate space utilities
6
using UnityEngine;
7

8
public class PoseTrailVisualizer : HistoryDrawingVisualizer<PoseStampedMsg>
9
{
10
    [SerializeField]
11
    Color m_Color = Color.white;
12
    [SerializeField]
13
    float m_Thickness = 0.1f;
14
    [SerializeField]
15
    string m_Label = "";
16

17
    public override Action CreateGUI(IEnumerable<Tuple<PoseStampedMsg, MessageMetadata>> messages)
18
    {
19
        return () =>
20
        {
21
            var count = 0;
22
            foreach (var (message, meta) in messages)
23
            {
24
                GUILayout.Label($"Goal #{count}:");
25
                message.pose.GUI();
26
                count++;
27
            }
28
        };
29
    }
30

31
    public override void Draw(Drawing3d drawing, IEnumerable<Tuple<PoseStampedMsg, MessageMetadata>> messages)
32
    {
33
        var firstPass = true;
34
        var prevPoint = Vector3.zero;
35
        var color = Color.white;
36
        var label = "";
37

38
        foreach (var (msg, meta) in messages)
39
        {
40
            var point = msg.pose.position.From<FLU>();
41
            if (firstPass)
42
            {
43
                color = VisualizationUtils.SelectColor(m_Color, meta);
44
                label = VisualizationUtils.SelectLabel(m_Label, meta);
45
                firstPass = false;
46
            }
47
            else
48
            {
49
                drawing.DrawLine(prevPoint, point, color, m_Thickness);
50
            }
51

52
            prevPoint = point;
53
        }
54

55
        drawing.DrawLabel(label, prevPoint, color);
56
    }
57
}