Linux build

Table of Contents

• Documentation
• Prerequisites
• System Recommendation
• Major installations
• Unreal Engine
• Set Unreal Engine environment variable
• Clone & Build AGRARSENSE
• ROS1 and ROS2
• install some pip packages needed for testing
• install Fast-RTPS dependencies
• install Cyclone DDS dependencies
  • Visualizing sensor output with rviz
  • Creating packaged build
  • Modifying AGRARSENSE source

Documentation

Topic	Link
Getting Started	Getting Started
Using the Simulator	Using the Simulator
Using Vehicles	Using Vehicles
Using Walkers	Using Walkers
Sensors	Sensors
Setupping sensors	Setupping sensor
Creating own levels	Creating own levels
Building from source on Linux	Building on Linux
Building from source on Windows	Building on Windows
Installing on Linux	Installing on Linux
Installing on Windows	Installing on Windows

Prerequisites

In this section, you will find essential information regarding the system requirements, software installations, and other dependencies necessary before starting the development of AGRARSENSE.

The project directory structure is as follows:

├── AGRARSENSE [root]
    └── Data (Created when simulator is launched)
        ├── All data saved from the Simulator
    └── Docs
        ├── All documentation files
    └── Examples
        └── ExampleJsonFiles
        └── ROS1
        └── ROS2
    └── Utils
        ├── Build scripts for Agrarsense unreal project
    └── Unreal
        └── Agrarsense [Unreal project files]
            └── Content
                ├── All blueprints, models and other assets
            └── Plugins
                ├── Plugins C++ source
            └── Source
                ├── Agrarsense simulator C++ source
            ├── LinuxCompile.sh         - build script for compiling the project for Linux
            ├── LinuxOpenProject.sh     - build script for opening the project for Linux
            ├── LinuxCreatePakcage.sh   - build script for creating packaged build for Linux

System Recommendation

• Intel i7 / Intel i9 9th or newer / AMD Ryzen 7 / AMD Ryzen 9
• 16+ GB RAM or more
• NVIDIA RTX 3070/3080 or newer / AMD RX 6700 XT or newer
• 150+ GB disk space for source version
• Ubuntu 20.04 / Windows 10 / Windows 11

Major installations

Unreal Engine

You can either install pre-compiled Unreal Engine 5.3 for Linux by following this guide, or you can install our fork of the Unreal Engine which is preferred.

We have made our own fork of the Unreal Engine where we have made few optimizations to the engine to improve sensors performance.

To install our fork of the engine, you need to have a GitHub account linked to Unreal Engine's account.

Note. Compiling Unreal Engine from source will take ~1-4 hours depending on your CPU!

To build our fork of the Unreal Engine:

1. Clone the repository

git clone -b AGRARSENSE https://github.com/frostbitunreal/unrealengine ~/UnrealEngine

2. Navigate to cloned folder:

cd ~/UnrealEngine

3. Run the configuration scripts and compile the engine:

If you are installing the Unreal Engine for the first time on your machine, these commands will to prompt register Unreal Engine types and ask for sudo password. Click yes and enter sudo password to be able to compile the engine.

./Setup.sh && ./GenerateProjectFiles.sh && make

If you modify the Unreal Engine source after first compilation, you must compile the Unreal Engine again with following command. Unreal Engine will only compile the parts you have modified, not the entire Unreal Engine.

make

Set Unreal Engine environment variable

In order to AGRARSENSE to find the correct installation of Unreal Engine, we need to set the environment variable.

To set the variable for this session only:

export UE5_ROOT=~/UnrealEngine

To set the variable so it persists across sessions:

1. Open ~/.bashrc or ./profile.

gedit ~/.bashrc
# or 
gedit ~/.profile

2. Add the following line to the bottom of the file:

export UE5_ROOT=~/UnrealEngine

3. Save the file and reset the terminal.

Clone & Build AGRARSENSE

1. Clone the repository

git clone https://AMKFrostBit@dev.azure.com/AMKFrostBit/AGRARSENSE/_git/Agrarsense

2. Navigate to AGRARSENSE Unreal project folder

cd Agrarsense/Unreal/Agrarsense/

3. Build AGRARSENSE

To compile and open the Unreal Editor with one command

./LinuxOpenProject.sh

ROS1 and ROS2

ROS noetic is required for the project to be able to communicate between Unreal Engine and ROS. The simulator supports ROS2 via ROS1 to ROS2 bridge.

ROS noetic is only offically supported on Ubuntu 18.04 and 20.04. Ubuntu 22.04 doesn't offically support ROS noetic.

AGRARSENSE Unreal project will work without a ROS installation but you cannot get or send any data to or from the simulator.

1. Install ROS noetic

   sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list'
    
   sudo apt install curl
    
   curl -s https://raw.githubusercontent.com/ros/rosdistro/master/ros.asc | sudo apt-key add -
    
   sudo apt update
    
   sudo apt install ros-noetic-desktop-full -y
    
   echo "source /opt/ros/noetic/setup.bash" >> ~/.bashrc
    
   source ~/.bashrc

2. Install ROSBridge

   https://github.com/code-iai/ROSIntegration states this: >The recommended way to install rosbridge is from source (requires the rosauth package) – Even though you could install rosbridge using apt, there have been numersous issues where these apt packages do not reflect the code in the ros1 branch. Hence, it is best to install from source.

   • Install from apt packages

     sudo apt-get install ros-noetic-rosauth
     sudo apt-get install ros-noetic-rosbridge-suite
     echo "alias ROS1='source /opt/ros/noetic/setup.bash'" >> ~/.bashrc

3. When launching ROS server, you can either launch it manually from Ubuntu WSL Terminal roslaunch rosbridge_server rosbridge_tcp.launch bson_only_mode:=True or in windows terminal wsl -e bash -lic "roslaunch rosbridge_server rosbridge_tcp.launch bson_only_mode:=True"

   To run python scripts with ROS connection you need to install Python ROS packages: ```sh pip install –extra-index-url https://rospypi.github.io/simple/ rospy pip install –extra-index-url https://rospypi.github.io/simple/ tf2_ros ``` If connection doesn't go through from windows to Ubuntu WSL, you need to set **"ROS_IP"** in command prompt. ```sh set ROS_IP=192.168.x.x ```

4. When ROS is installed follow this guide to install ROS2 (Foxy). First, you need to install ROS2 without ros1_bridge.

   Launch new terminal ``` locale # check for UTF-8

   sudo apt update && sudo apt install locales sudo locale-gen en_US en_US.UTF-8 sudo update-locale LC_ALL=en_US.UTF-8 LANG=en_US.UTF-8 export LANG=en_US.UTF-8

   locale # verify settings sudo apt install software-properties-common sudo add-apt-repository universe sudo apt update && sudo apt install curl sudo curl -sSL https://raw.githubusercontent.com/ros/rosdistro/master/ros.key -o /usr/share/keyrings/ros-archive-keyring.gpg echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/ros-archive-keyring.gpg] http://packages.ros.org/ros2/ubuntu $(. /etc/os-release && echo $UBUNTU_CODENAME) main" | sudo tee /etc/apt/sources.list.d/ros2.list > /dev/null sudo apt update && sudo apt install -y \ libbullet-dev \ python3-pip \ python3-pytest-cov \ ros-dev-tools

install some pip packages needed for testing

python3 -m pip install -U \ argcomplete \ flake8-blind-except \ flake8-builtins \ flake8-class-newline \ flake8-comprehensions \ flake8-deprecated \ flake8-docstrings \ flake8-import-order \ flake8-quotes \ pytest-repeat \ pytest-rerunfailures \ pytest

install Fast-RTPS dependencies

sudo apt install –no-install-recommends -y \ libasio-dev \ libtinyxml2-dev

install Cyclone DDS dependencies

sudo apt install –no-install-recommends -y \ libcunit1-dev mkdir -p ~/ros2_foxy/src cd ~/ros2_foxy vcs import –input https://raw.githubusercontent.com/ros2/ros2/foxy/ros2.repos src sudo apt upgrade sudo rosdep init rosdep update rosdep install –from-paths src –ignore-src -y –skip-keys "fastcdr rti-connext-dds-5.3.1 urdfdom_headers" cd ~/ros2_foxy/ colcon build –symlink-install –packages-skip ros1_bridge

5. After ROS2 is build from source (without ros1_bridge)
   You need to 'source' both ROS1 and ROS2.

source /opt/ros/noetic/setup.bash source ~/ros2_foxy/install/setup.bash

Then build only ros1_bridge

cd ~/ros2_foxy/ colcon build –symlink-install –packages-select ros1_bridge –cmake-force-configure

>NOTE: To use ROS1 rosbridge_server, you shouldn't add both ROS1 and ROS2 to ~.bashrc, since it mixes the packages. Instead, use ROS1 as intended and source ROS2 `ONLY` when needed

echo "alias ROS2='source ~/ros2_foxy/install/setup.bash'" >> ~/.bashrc

   By typing ROS2 in terminal, it sources the ROS2 bash file and removes ROS2 alias
 
## Custom ROS Messages
 
1. Clone messages from github
    ~~~
    git clone https://AMKFrostBit@dev.azure.com/AMKFrostBit/AGRARSENSE/_git/AGRARSENSE_ROS_Messages
    ~~~
 
2. Build ROS1 messages
    
    Type "ROS1" to launch ros2 build bash. (Alias made earlier in .bashrc)
    ~~~
    ROS1
    cd ~/AGRARSENSE_ROS_Messages/ros1ws/
    catkin_make
    ~~~
    
    when the ROS1 build is finished close the wsl windows
 
3. Open **New Terminal**
    
    Type "ROS2" to launch ros2 build bash. (Alias made earlier in .bashrc)
    ~~~
    ROS2
    cd ~/AGRARSENSE_ROS_Messages/ros2ws/
    colcon build
    ~~~
    
    - when the ROS2 build is finished close the wsl windows
 
4. Rebuild ROS1_Bridge again
    
    1. **Launch new Terminal**
    
    2. Source both ROS1 and ROS2 and both workspaces:
        ~~~
        ROS1 && ROS2
        source ~/AGRARSENSE_ROS_Messages/ros1ws/devel/setup.bash
        source ~/AGRARSENSE_ROS_Messages/ros2ws/install/setup.bash
        ~~~
    
    3. Next navigate to ros2_foxy directory and rebuild bridge
        ~~~
        cd ~/ros2_foxy/
        colcon build --packages-select ros1_bridge --cmake-force-configure
        ~~~
    
    4. After the bridge has successfully built
    
        ~~~
        echo "'source ~/AGRARSENSE_ROS_Messages/ros1ws/devel/setup.bash'" >> ~/.bashrc
        ~~~
 
## Testing AGRARSENSE
 
To test everything works correctly you can the following:
 
1. Open new terminal and Launch Unreal Editor
 
```sh
    cd ~/Agrarsense/Unreal/Agrarsense && ./LinuxOpenProject.sh

1. Start ROS1 with new terminal

roslaunch rosbridge_server rosbridge_tcp.launch bson_only_mode:=True

1. Start ROS1 to ROS2 Bridge with new terminal

ROS2 && ros2 run ros1_bridge dynamic_bridge --bridge-all-topics

1. In Unreal Editor navigate to Content/Agrarsense/Maps/TestMaps/SensorShowCase and open SensorShowCaseMap level
2. Press play
3. Spawn wanted sensors through the user interface
4. Open new terminal and type following command to see all current ROS topics

rostopic list

Visualizing sensor output with rviz

rviz is short for ROS Visualization. It's easy way visualize ROS messages, for example camera images and Lidar pointclouds.

1. First follow Testing AGRARSENSE
2. Open new terminal and launch rviz

rviz

1. Now that rviz is open click 'Add' from the bottom left corner. This opens new window. In the window click 'By topic' tab. This tab should show all topics that rviz is able to visualize. For example if you have Lidar sensor active in the simulation, you should see /Agrarsense/Sensors/Lidar0/PointCloud2. Select that and click ok.
2. Click 'Fixed Frame' and rename it to world and you should now see Lidar sensor pointcloud being visualized.

Creating packaged build

To create packaged shipping build for disturbution, you can either:

A. Create package without opening the Unreal Editor with following command. This script packages the project into ./Build folder

./LinuxCreatePackage.sh

B. or launch the Unreal Editor with following command and create the package in the Unreal Editor.

./LinuxOpenProject.sh

Maps to include in the packaged build is defined in DefaultGame.ini file.

Modifying AGRARSENSE source

When modifying Blueprints or Widget Blueprints in Unreal Editor, simply click compile and save in the Unreal Editor as in with any Unreal project.

When modifying AGRARSENSE Unreal project C++ source or plugins C++ source, you must close the Unreal Editor, compile C++ and then open the Unreal Editor again or else changes will not take effect. This can be done with same scripts as above.

Note. Unreal Engine does support compiling C++ in Unreal Editor through Live Coding but your experience may vary.

To compile and open the Unreal Editor with one command:

./LinuxOpenProject.sh

To just compile C++ source and plugins:

./LinuxCompile.sh