Using the robot with a user PC

This setup tutorial will guide you through setting up your PC to use it with Robotont.

Setting up the PC

Installing Ubuntu

Download Ubuntu image on your PC from the following link: Ubuntu 24.04.2 (Noble Numbat).
For installing Ubuntu on your PC, follow the guide Install Ubuntu Desktop.

Installing ROS

For installing ROS 2 Jazzy, follow the guide for Ubuntu (deb packages).

Creating a colcon workspace

Create a workspace for colcon as shown here.

Cloning Robotont’s packages

All Robotont’s packages can be accessed from Robotont’s GitHub.

Packages necessary to run the demos from PC’s Terminal are the following:

You can find the demos from the following repositories:

See the demos_on_robot for more information about the demos.

To clone the packages:

git clone https://github.com/robotont/package_name.git

Building the colcon workspace

cd colcon_ws
colcon build

Sourcing the workspace

Make the workspace visible to ROS 2 (must be done for every new Terminal session)

source ~/colcon_ws/install/setup.bash

For automatic sourcing:

echo "source ~/colcon_ws/install/setup.bash" >> ~/.bashrc

Network Setup

In order to work with Robotont one of the most convenient ways is to build a network connection between the robot and your PC.

There are different ways in which you can connect to the robot remotely.

AP connection
Client connection

AP connection

Access Point (AP) connection involves connecting directly to the robotont’s own network.

This method allows for direct communication with the robot without needing an external network infrastructure and is the easiest way to connect.

The topology of the network can be seen in the following image:

You can achieve this by connecting the user PC to Robotont’s network.

Client connection

This method involves connecting the robot and the user PC to the same network. The user PC can then connect to the robot using the robot’s IP address or hostname.

This approach can be used to have multiple Robotonts and PCs within the same network. That is particularly helpful when setting up a classroom with multiple Robotonts.

Distributed ROS 2

ROS 2 is designed for distributed systems out of the box. Unlike ROS, it does not use a central ROS Master. Instead, nodes discover each other using DDS.

There are two options for setting up a distributed system, either using static IPs or defining hostnames on each of the devices.

Note

For consistent networking, assign static IP addresses or use DHCP reservation for both the robot and your PC

On Robotont (on-board computer):

export ROS_DOMAIN_ID=10
export ROS_IP=192.168.200.1

On PC:

export ROS_DOMAIN_ID=10
export ROS_IP=192.168.200.101

Important

Replace the IP addresses with the actual addresses of the devices

To make these settings persistent, append them to the .bashrc file:

echo 'export ROS_DOMAIN_ID=10' >> ~/.bashrc
echo 'export ROS_IP=192.168.200.101' >> ~/.bashrc

Note

The ROS_IP variable is helpful if you have multiple network interfaces or encounter issues with node discovery. In many typical setups, ROS 2 nodes will communicate without setting it

On each device:

Edit the `/etc/hosts` file:
```
sudo nano /etc/hosts
```
Add entries like this:
```
192.168.200.1   robotont-1
192.168.200.101 laptop-1
```
Important

Replace the IP addresses with the actual addresses of the devices
Save and exit. You can now use hostnames in your ROS 2 setup. Test with:
```
ping robotont-1
```

If the ping succeeds, hostname resolution is working. ROS 2 nodes can communicate with no extra configuration beyond being on the same subnet.

Optional

On both devices, set common DDS domain:

export ROS_DOMAIN_ID=10

To make this persistent:

echo 'export ROS_DOMAIN_ID=10' >> ~/.bashrc

Verifying Communication

On the Robotont, start a ROS 2 publisher:
```
ros2 run demo_nodes_cpp talker
```
On the PC, start a ROS 2 subscriber:
```
ros2 run demo_nodes_cpp listener
```

If setup correctly, the PC should receive messages from the Robotont.

SSH

SSH provides a safe and reliable way to remotely connect to the robot, allowing you to check its status and execute commands from your PC.

You can connect to the robot using either its IP address or hostname (if defined in the source machine’s /etc/hosts file).

Follow these steps:

Open a new Terminal window on your PC
Connect your PC to Robotont’s network
Start the SSH connection using either the robot’s hostname or IP address:

ssh <username>@<target_hostname>

Hint

Replace <username> with an user registered on the target machine and <target_hostname> with the robot’s hostname, e.g

ssh peko@robotont-3

ssh <username>@<target_ip_address>

Hint

Replace <username> with an user registered on the target machine and <target_ip_address> with the robot’s IP address, e.g

ssh peko@192.168.1.200

If prompted with a “yes/no” question about authenticity, type yes and press Enter.
Enter the password when prompted
Verify the login:

When logged in, the terminal prompt will change to peko@robotont-X (or similar), indicating you are connected to the robot. This helps you identify which terminal is connected remotely.
ROS environment setup:

The robot should automatically source its ROS environment on login. To check which workspaces are being sourced, you can run:
```
tail ~/.bashrc
```

Tip

If you have connection issues, double-check the robot’s network settings and ensure you are using the correct hostname or IP address

Troubleshooting Tips

Make sure both devices are on the same network/subnet.
Check that firewalls allow multicast UDP traffic.
Use the same ROS_DOMAIN_ID on all machines.
If communication issues persist:
- Try a different DDS implementation (e.g., Cyclone DDS or Fast DDS).
- Explicitly set the middleware with:
```
export RMW_IMPLEMENTATION=rmw_cyclonedds_cpp
```