Setting Up Webots

Setup instructions for Webots.

Webots is a physics environment created by Cyberbotics. This guide details how to set up Webots. It gives instructions on setting up Ubuntu (WSL) inside Windows for Windows users, and the rest of the guide is aimed at Ubuntu users (including Windows WSL Ubuntu users). If you would like to learn more about Webots itself, refer to the Webots User Guide.

Prerequisites

Windows

Follow the instructions for setting up Ubuntu in WSL on the Getting Started NUbook page under the Windows tab in the Docker section.
Since Webots uses a GUI, we will need to set up a way to launch and display the program. Use these instructions which is for a similar scenario, but with GitKraken instead of Webots. Take note of the following changes:
- You can ignore installing and launching GitKraken. Instead, we will use the Webots instructions later in this guide to install and launch Webots.
- When running XLaunch configuration, uncheck 'Native opengl' on the third window.
- To prevent having to set the DISPLAY environment variable every time, run the following command in Ubuntu:
```
echo 'export DISPLAY=$(cat /etc/resolv.conf | grep nameserver | awk '\''{print $2; exit;}'\''):0.0' >> ~/.bashrc
```
To be able to copy and paste into the Ubuntu terminal, right-click on the bar at the top of the Ubuntu window. Then click on Properties, and enable Use Ctrl+Shift+C/V as Copy/Paste in the Options tab. Note that this is Ctrl+Shift+C/V not Ctrl+C/V.

In Ubuntu run

sudo apt-get update
sudo apt-get install libxcb-icccm4 libxcb-image0 libxcb-keysyms1 libxcb-render-util0 libxcb-xfixes0 libxcb-xinerama0 libxcb-xkb1 libxkbcommon-x11-0 libxkbcommon0

You will need XLaunch running every time you want to run Webots.

Follow the rest of the steps on this page within Ubuntu.

Arch Linux

Run the following to obtain the required dependencies.

pacman -S --needed git lsb-release cmake swig glu glib2 freeimage freetype2 libxml2 libzip boost-libs gd libgcrypt libzip readline pbzip2 pciutils wget zip unzip jdk-openjdk libusb

Download our usb patch which helps the makefile link libusb properly.
After you do the clone step below, move the patch file webots_usb.patch into your webots install folder, and run git apply webots_usb.patch inside that folder to apply it. After that, you should be able to run make -j$(nproc) as usual.

Install libraries for cmake, protobuf, eigen, yaml-cpp, ninja-build, and clang-tidy:

sudo apt-get update
sudo apt-get install cmake-curses-gui libprotobuf-dev protobuf-compiler libeigen3-dev libyaml-cpp-dev ninja-build clang-tidy python3-dev libjpeg9-dev

Install Webots

Open a terminal, clone the NUWebots repository and change into the cloned directory:
```
cd ~
git clone https://github.com/NUbots/NUWebots.git
cd NUWebots
```
The NUWebots repo contains both NUbots-specific Webots files and the files needed to install Webots itself. The first command can be changed to any directory you would like. If you're not sure, just follow what is in this guide.
This step assumes you have done the previous step and are now in the NUWebots directory. Add the WEBOTS_HOME env variable to your .bashrc file:
```
echo export WEBOTS_HOME=$(pwd)/webots >> ~/.bashrc
source ~/.bashrc
```
Update the submodules for the Webots subtree
```
git submodule update --init
```
Move into the webots directory and install the Webots build dependencies:
```
cd webots
sudo ./scripts/install/linux_compilation_dependencies.sh
```
Build Webots:
```
make -j$(nproc)
```

Running the Official RoboCup Simulation in Webots

This section assumes you have completed the previous section, including adding the WEBOTS_HOME env variable to your .bashrc file (see step 2 above). Make sure this step is completed or adjust the following commands to your set up.

Set Up the Protos

Set up the symlink for the NUgus proto:
```
ln -s $WEBOTS_HOME/../protos/robot/NUgus $WEBOTS_HOME/projects/samples/contests/robocup/protos
```
This allows us to use our NUgus robot with the official RoboCup simulation.

Set Up the Controllers

Install dependencies for the referee:

cd $WEBOTS_HOME/projects/samples/contests/robocup/controllers/referee
pip3 install -r requirements.txt

Build the Robocup controllers:

cd $WEBOTS_HOME/projects/samples/contests/robocup
make -j$(nproc)

Install Game Controller

Install the ant build tool and Java Development Kit:
```
sudo apt-get install ant default-jdk
```
Clone the Robocup TC GameController repo:
```
cd ~
git clone https://github.com/RoboCup-Humanoid-TC/GameController.git
```
The first command can be changed to any directory you would like. If you're not sure, just follow what is in this guide.
Change into the cloned directory and build the GameController:
```
cd GameController
ant
```
Add the JAVA_HOME and GAME_CONTROLLER_HOME env variable to your .bashrc file:
```
echo export JAVA_HOME=/usr/lib/jvm/default-java >> ~/.bashrc
echo export GAME_CONTROLLER_HOME=$(pwd) >> ~/.bashrc
source ~/.bashrc
```
The second command assumes you are still in the GameController directory from the previous step.

Run Webots with GameController

Find your primary local IP address by running the following.
```
hostname -I
```
Your primary IP address is often the first of the addresses in the output returned. For example, if hostname -I returns 10.1.0.207 10.1.0.139 172.17.0.1, use 10.1.0.207.
Set the GAME_CONTROLLER_UDP_FILTER env variable to your local IP address from step 1 to ensure your instance of GameController is not affected by other instances of GameController on the network.
```
export GAME_CONTROLLER_UDP_FILTER=<IP_ADDRESS> # replace <IP_ADDRESS> with your IP address from step 1
```
Run the following to open Webots with the Robocup world and the GameController:
```
$WEBOTS_HOME/webots $WEBOTS_HOME/projects/samples/contests/robocup/worlds/robocup.wbt
```
Sometimes closing Webots doesn't properly close the GameController subprocess. If this happens you'll get an error about GameController when you next launch Webots. To fix, run the following command which terminates the GameController process, then start Webots again:
```
kill -9 $(pgrep -fi GameControllerSimulator.jar)
```

Set Up with the NUbots Robot Code

Running the RoboCup scenario requires two things: the Webots simulator, of which there is one instance; and the robot code, of which there can be any number of instances equal to the number of robots you would like to run. These programs can be run on any combination of computers. All robots and the Webots simulator can be run locally on one computer, or a separate computer for the Webots simulator and each robot, or any combination inbetween.

Use the Getting Started page to set up the codebase, configure and build on all computers that will be running robot code, if not done so already. When configuring, ensure that ROLE_webotsrobocup is ON.
Set your UDP filter on all computers that will be running robot code to prevent them from receiving conflicting GameController packets. Go to the GameController configuration file and set udp_filter_address to the <IP_ADDRESS> from the previous section in step 2.
Ensure the IP and ports are set up correctly. If you are running everything locally on the one computer, the default settings should work as is. If Webots and the robot code are run on separate computers, do the following:
1. As done previously, get the hostname of each computer by running hostname -I in a terminal on each computer.
2. On each computer you will be running the robot code on, run ./b edit config/webots.yaml and change the IP in server_address to the hostname of the Webots simulator computer found in the previous step. For any robots running on the same computer as the Webots simulator, do not change the IP.
3. On the computer you will be running the Webots simulator on, open the NUWebots repo in a text editor. Open the file webots/projects/samples/contests/robocup/controllers/referee/game.json (you can use Ctrl+p, search for game.json and the first file should be the correct one).
4. Under red: hosts: add the hostname of any computers you are running the robot code on. For any robots running on the same computer as the Webots simulator, do not add its own hostname.

Run the Webots simulator:

$WEBOTS_HOME/webots $WEBOTS_HOME/projects/samples/contests/robocup/worlds/robocup.wbt

Running One Robot

If you want to test the behaviour of one robot in the Webots RoboCup scenario, you can run the binary from the usual NUbots docker container. The robot can be run on the same computer or on a different computer to the Webots simulator.

Run ./b run webotsrobocup on the computer you want to run the robot code on.

Running Multiple Robots

If you're running more than one robot, you will need to set up a Docker container for each robot. There can be any combination of different or same computers for each robot container and webots itself. E.g. you can run webots itself and a robot on one computer, three robots on another computer, and three on another computer. The more computers you have, the more complicated the IP set up will be for the config files.

On all computers that will be running robot code, run ./b webots build webotsrobocup once to build the container with the webotsrobocup role. Even if you are running multiple robots on that computer, you only need to run this once.

Run the container with the command docker container run --rm --network=host -e ROBOCUP_ROBOT_ID=<ROBOT_ID> -e ROBOCUP_TEAM_COLOR=<TEAM_COLOUR> -e ROBOCUP_SIMULATOR_ADDR=<WEBOTS_IP>:<ROBOT_PORT> robocup-vhsc-nubots:robocup2021 webotsrobocup

Specifying <ROBOT_ID>, <TEAM_COLOUR> and <ROBOT_PORT> depending on which robot you want to run.

For example, if you are running everything locally on one computer, and you want to connect to robot number 1 on the red team, run docker container run --rm --network=host -e ROBOCUP_ROBOT_ID=1 -e ROBOCUP_TEAM_COLOR=red -e ROBOCUP_SIMULATOR_ADDR=127.0.1.1:10001 robocup-vhsc-nubots:robocup2021 webotsrobocup

Open a new terminal for each robot you want to run.

If you want to run two teams of three NUgus robots all locally on the one computer with Webots, run each of the following lines in different terminals once Webots is running.

docker container run --rm --network=host -e ROBOCUP_ROBOT_ID=1 -e ROBOCUP_TEAM_COLOR=red -e ROBOCUP_SIMULATOR_ADDR=127.0.1.1:10001 robocup-vhsc-nubots:robocup2021 webotsrobocup
docker container run --rm --network=host -e ROBOCUP_ROBOT_ID=2 -e ROBOCUP_TEAM_COLOR=red -e ROBOCUP_SIMULATOR_ADDR=127.0.1.1:10002 robocup-vhsc-nubots:robocup2021 webotsrobocup
docker container run --rm --network=host -e ROBOCUP_ROBOT_ID=3 -e ROBOCUP_TEAM_COLOR=red -e ROBOCUP_SIMULATOR_ADDR=127.0.1.1:10003 robocup-vhsc-nubots:robocup2021 webotsrobocup
docker container run --rm --network=host -e ROBOCUP_ROBOT_ID=1 -e ROBOCUP_TEAM_COLOR=blue -e ROBOCUP_SIMULATOR_ADDR=127.0.1.1:10021 robocup-vhsc-nubots:robocup2021 webotsrobocup
docker container run --rm --network=host -e ROBOCUP_ROBOT_ID=2 -e ROBOCUP_TEAM_COLOR=blue -e ROBOCUP_SIMULATOR_ADDR=127.0.1.1:10022 robocup-vhsc-nubots:robocup2021 webotsrobocup
docker container run --rm --network=host -e ROBOCUP_ROBOT_ID=3 -e ROBOCUP_TEAM_COLOR=blue -e ROBOCUP_SIMULATOR_ADDR=127.0.1.1:10023 robocup-vhsc-nubots:robocup2021 webotsrobocup

Running a NUbots Environment

Follow these steps to set up a NUbots developed environment rather than the RoboCup environment.

Move to the NUWebots folder:
```
cd $WEBOTS_HOME/..
```
Install the python dependencies:
```
pip3 install -r requirements.txt
```

Configure the codebase by running:

./b configure

Optional Flags

We can configure with several optional flags as follows:

./b configure [-i] [-- <flags>]

where -i runs an interactive configuration with ccmake, and <flags> can be any valid cmake command line flag. Some useful cmake flags are:

Flag	Effect	Default
`-DUSE_ASAN=ON`	Compile with address sanitizer	`OFF`
`-DUSE_UBSAN=ON`	Compile with undefined behaviour sanitizer	`OFF`
`-DENABLE_CLANG_TIDY=ON`	Analyse the code being compiled with clang-tidy	`OFF`
`-DWEBOTS_HOME=path/to/webots`	Tells the compiler where webots is (usually implicitly set by environment variable)	`/usr/local/webots`
`-DCMAKE_BUILD_TYPE=<build type>`	Tells the compiler what type of build type to use, out of {`Release`, `Debug`, `MinSizeRel`, `RelWithDebInfo`}	`Release`

Build the codebase by running
```
./b build
```
Navigate to the Webots folder
```
cd webots
```
Launch Webots by running
```
./webots
```
Open a NUbots world file inside Webots.
1. Click on File->Open World....
2. In the pop-up, navigate to the NUbots/NUWebots/worlds folder on your computer and open the world you would like to run.

Creating a New Controller

From the root of the NUWebots repository run

./b controller generate <name of controller>

Where <name of controller> is the name you want to use for the new controller. A folder and files will be created with this name, so they must be valid file names (don't use spaces in your controller name).

On this page