Seirios RNS' features can be divided into three categories:

• Core Features : features that enable the robot to move manually and/or autonomously

• : features that supplement and improve the core features

• : features that non visual and only configurable from the robotic backend

The dashboard is the first page that you see after logging in. After mapping, saving and loading a map, it will be visualised here;

Speed controls, analog/keyboard control and toggle, and mode-dependent buttons will be displayed in this panel. This panel can be toggled to be hidden or shown too.

Under this category, users can manually drive their robots

1. Drive - to manually drive the robot with the onboard controls (keyboard or analog)

Granular controls are automatically applied; similar to a car's gas pedal/accelerator, users can granularly control the speed based on the set (0.1 - 0.9 m/s) limit with the joystick.

Seirios is our portfolio of flagship products aimed at making robots smarter and more agile. Under Seirios, there are two main products;

This prevents unintended collisions into the shins/legs of human users or other 'thin' obstacles, this is enabled by default in Seirios

Besides intuitive features on the interface, Seirios RNS brings key robotic capabilities that are not apparent on the user interface but silently powering and enabling robots to move in challenging environments Please visit the following articles for more information:

• Kerb-and-ramp navigation

• Anti - shin buster

Click the following tab to view checklists

Seirios RNS comes with REST APIs for you to utilize - for integration and advanced deployments. To view the list of APIs available:

Please enter <IPaddress>:8000/api-docs/swagger on your robot/PC.

Alternatively, please download this pdf to explore available APIs ⬇️

Installing Seirios RNS onto your robot PC is easy! Follow these step-by-step guides to ensure seamless integration and deployment of Seirios RNS.

If you need help or have any inquiries along the way, reach out to us at [email protected] or live chat at movel.ai/contact

Welcome to Seirios FMS!

In this section you will learn:

1. The general concepts and working of FMS

2. How to connect your first robot to FMS

1. Easy deploy - Guide to download and install the Seirios RNS:https://docs.movel.ai/new-collection/seirios-rns/documentation/installation-and-integration-1/easy-deploy-for-seirios 2. Odometry Check - Guide to do Odometry Check: https://docs.movel.ai/new-collection/seirios-rns/documentation/installation-and-integration-1/pre-installation-checks/robot-checks/3-4-odometry-check 3. Seirios Manual Book - Guide to use the Seirios RNS: https://drive.google.com/file/d/11NrQXgiUrichYsnISSpLR3FK3snGH4Li/view

Seirios RNS is able to navigate on uneven and rough terrains - conditions that will usually throw localisation off due to the tilt and different FOV angles when robots are on an inclined/downward position

These environments also include environments with kerbs and ramps - often seen in everyday public places.

Current inclination supported : ∠15°

1. The goal of Part 1 of the installation is to install Docker and it’s dependencies

2. In the same directory in the Terminal, run the command bash install-1-docker.sh

3. Wait for the installation to complete

Then we move to the last part to install Seirios-RNS.

From the mode switcher, select the Localise button and click Start

Once the laser scan is aligned properly, click save to localise

Linear check

• Align the bot appropriately to test 3-4 meters of linear, straight distance without an angular component. Test using the following command in Terminal: rostopic pub /cmd_vel geometry_msgs/Twist "linear: x: 0.0 y: 0.0 z: 0.0 angular: x: 0.0 y: 0.0 z: 0.0"

Likewise, repeat the same method to check angular speed calibration.

What types of robot bases/AGVs do you support?

Seirios supports Differential, Omnidirectional or Ackermann drives. For Ackermann steering, users are required to input a radius value in the Settings section;

FMS management features include the following (pages coming soon):

• User and role management

On top of the core features, Seirios RNS are bundled with supplementary features too;

Seirios FMS' features can be divided into three categories:

• Core Features: features that enable the FMS to fully operate in an environment

• Move the robot straight, and echo the /odom topic.

• Align the wheels accordingly to test straight linear movement. It’s recommended to draw lines on the floor for accuracy.

Before starting Robot checks:

1. Kill all Movel nodes (if you already have it previously installed)

2. Launch only the motor controller and the teleoperation keyboard twist for testing [OR] Run the following command: rostopic pub -r 10 /cmd_vel - for linear linear: x-0.1 for rotation only : angular: z-0.1

1. After restarting the PC/machine, Seirios will automatically start every time the machine powers up.

2. To start Seirios manually, open a Terminal and enter your workspace by running the command cd ~/catkin_ws/movel_ai

3. Run docker-compose up to start the docker containers for Seirios (output will be shown in the terminal) Run docker-compose up -d to start Seirios in the background (no output will be shown in the terminal)

4. To stop Seirios, go into the terminal where Seirios is currently running, and use Ctrl+C (if you run by using docker-compose up) OR run docker-compose down in another terminal with the same directory. This will lead to the Docker containers being stopped.

5. To check for docker containers running at any point of time, run docker ps. If Seirios is up and running, you should expect to see the different containers of Seirios components being displayed. Otherwise, it should yield an empty table. You can also check the version of Seirios by using docker ps.

Taking the node “/motors_ctrl” as an example. It is publishing to “/odom” topic with “nav_msgs/Odometry” message type, along with the other topics in the list. It also subscribes to “/cmd_vel” topic with message type “geometry_msgs/Twist”

1. Go into the folder ‘/home/<user>/catkin_ws/movel_ai/config/movel/config/’

2. In the parameter file costmap_common_params.yaml, ensure that the robot footprint is defined correctly.

   1. If the robot footprint is a polygon, configure the footprint parameter and comment out robot_radius. For example:

3. Here, the robot has a square footprint with the xy coordinates of the four corners as shown, while robot_radius is commented out.

   1. If the robot footprint is circular, configure the robot_radius parameter and comment out footprint. For example:

4. In base_local_planner_params.yaml:

   1. Go to “#Robot” section. To tune the speed of the robot, configure max_vel_x for linear speed, and max_vel_theta for angular speed.

5. If the autonomous navigation motion is jerky, go to “catkin_ws/movel_ai/config/cmd_vel_mux/config”, find cmd_vel_mux.yaml, and increase the value set for timeout_autonomous.

6. For in depth tuning of base_local_planner_params.yaml, refer to .

Project

FMS objects are organized in projects. A project can be thought of as a workspace in which users can operate and control multiple robots. It can contain multiple connected maps and multiple robots with various types. In practice, a project can cover a whole building, for example a whole warehouse with multiple floors and/or rooms.

A project is owned by a single user or an organisation. However, multiple users can be a member of the same project. A project is in many ways analogous to a repository in Git-based VCS platform such as Github or Gitlab, while the FMS can be analogised as "the Github".

A project contains all the things necessary to operate robots in an environment and it is independent from any other project. The following are entities under a project:

1. Robots

2. Maps

3. Tasks

This organisation means that the three objects above are unique to a project and they only exist within the scope of a project.

Robot

A user who is a member of a project can control and operate robots in the project. A robot is owned by a project and it cannot exist in more than one projects simultaneously.

A user can do the following actions on a robot:

1. Teleoperate

2. Create map

3. Localise

4. Send a command (task, cancel, pause, resume)

A robot has a few properties. Three important properties of a robot are Robot Type, Plugin Type, and Robot Token.

A robot connected to FMS has a robot type. A user can create a robot type within a project and categorise robots into a type to differentiate robots with different functions or characteristics.

When the robot connects to FMS, FMS automatically detects the plugin type. This plugin type is used to determine certain payloads and messages which will be relevant if a user wants to use special tasks such as custom tasks and aux tasks.

Robot token is used as the identifier of a robot. This token is unique for every robot and is generated when the user creates a new robot.

Map

Map represents the physical environment in which the robots operate. Other objects such as robots and (most) tasks are located somewhere on a map. In a project, map is stored in Library.

A user can do the following actions on a map:

1. Import a map

2. Create a map with a robot

3. Edit a map (add zones, navigation graph)

4. Connect two maps

Task

A task is an action that can be done by a robot. In general, a task involves a robot to navigate to a certain point on a map. Similar to RNS, there are two basic tasks in FMS: waypoint and trail. There are also custom task and auxiliary task in FMS, though these concepts are slightly different than those of RNS.

There are only two types of tasks in Seirios RNS;

• Trail : where robot will follow the generated lines closely (will not deviate outside). When faced with obstacles, robot will stop until obstacles are removed.

• Waypoints: where robot will not follow the lines and obstacles will be dynamically avoided (unless setting is toggled to stop-at-obstacle)

Trails

Teleop Trail

In this mode, users are required to Mark each point and a line will be generated between points.

Mark Trail

Similar to Teleop Trail, instead of moving the robot to mark, use the on-screen marker to drop points. Lines will be generated automatically.

Zone

The Zone feature can automatically generate points (trail style) in a specified area.

The generated zone will look like this, where points will be generated close to each other;

Waypoints

Waypoints are similar to Mark Trail where the only difference is that the robot does not follow the generated line closely. Obstacles will be avoided as the robot navigates in its environment.

Seirios RNS supports multiple mapping algorithms. Jump to the algorithm of interest here on the right panel (desktop view only) ➡️

2D Mapping

The most commonly used mapping algorithm, the cameras mounted on robots populate and generate a map of its surroundings

Users can manually teleoperate the robot, to 'reveal' the map represented by white areas in the map

Auto Mapping 🚩

Incorporating this feature into Seirios allows users to automatically map large areas without manually driving with virtual controls. The auto-mapping feature was originally developed for a wall-scanning construction project

Automatic mapping without manual controls from users

3D Mapping 🚩

For higher accuracy, range and better visual representation of environmental features, users can opt to map in 3D. A 2D map will be generated from a 3D map too

RTAB-MAP 🚩

RTAB-Map (Real-Time Appearance-Based Mapping) is a RGB-D, Stereo and Lidar Graph-Based SLAM approach based on an incremental appearance-based loop closure detector.

As its namesake, it uses real time images to map the environment

ORB-SLAM Camera Based Mapping 🚩

ORB-SLAM is a keyframe and feature-based Monocular SLAM. It operates in real-time in large environments, being able to close loops and perform camera relocalisation from very different viewpoints.

Seirios is able to support mapping with the use of monocular, stereo, and RGB-D cameras. Green 'dots' are features recognised and stored in the map data, generating a 2D map

Supported Platforms

Hardware Requirements

RNS Plugin doesn't perform any heavy computation as it only acts as an adapter or a communication bridge between FMS and RNS. You can safely run RNS Plugin inside your robot without any significant performance cost.

Required Ports

Please ensure that the ports below are allowed in the robot's machine to ensure that communication with FMS is working properly.

Licensing

RNS Plugin doesn't require a license as it's only an adapter between FMS and RNS.

Different users may have different use cases to edit a map. With the map editor feature, users are able to;

1. Annotate - name an area

2. Create no-go zones (where robots will not be able to navigate into/to)

3. Yes-go zones (where users are able to 'clear' obstacles formed during the mapping process or to undo no-go zones)

Users can access the map editor by clicking this icon

Users will be presented with a set of options to edit the map;

Options are categorised by shapes - where users are able to choose whether to Annotate/Name, create No-go zones, and Yes-Go Zones. These categories are 'Squares', 'Polygon' and 'Others' (single lines)

A single line as an option can be used to create precise and thin obstacles such as walls

FMS' core features can be categorised into basic and advanced features.

Basic Features

Basic features are the minimum set of features needed to work with FMS:

• Dashboard:

  • Teleoperation

  • Mapping

Advanced Features

Advanced features are features that enable users to make use of the full potential of RNS. These include:

• Fleets

• Custom task and Aux task

• Task list

• Task scheduling

Installation Steps

Before you start installing the RNS Plugin, it's important to note that the current main method of installing RNS Plugin is by using Docker. You'll need to install docker on your own or use our installation script.

1. Download the latest FMS Easy Deploy version and unzip/extract the folder to a preferred directory

FMS Easy Deploy contains the installation scripts and will also act as the working space for the RNS Plugin installation.

1. Install docker on the host machine

You can install docker on your own by following the guide from the official website, or you can also install docker by using our docker installation script from the fms easy deploy directory:

1. Run the installation script

After installing docker, we can proceed with the installation process which mainly involves pulling the official RNS Plugin docker image.

1. Start the containers

In order to start the RNS Plugin, you can use the start script which will load the environment variables and run the containers based on the docker compose file.

You can also use the stop script to stop the docker containers easily.

Uninstalling RNS Plugin

If you want to uninstall RNS Plugin which involves removing docker images and volumes. We provide a convenience script:

Installation Steps

Before you start installing FMS, it's important to note that the current main method of installing FMS is by using Docker. You'll need to install docker on your own or use our installation script.

1. Download the latest FMS Easy Deploy version and unzip/extract the folder to a preferred directory

FMS Easy Deploy contains the installation scripts and will also act as the working space for the FMS installation.

1. Install docker on the host machine

You can install docker on your own by following the guide from the official website, or you can also install docker by using our docker installation script from the fms easy deploy directory:

1. Run the installation script

After installing docker, we can proceed with the installation process which mainly involves pulling the official FMS docker images.

1. Start the containers

In order to start FMS, you can use the start script which will load the environment variables and run the containers based on the docker compose file.

You can also use the stop script to stop the docker containers easily.

Uninstalling FMS

If you want to uninstall FMS which involves removing docker images and volumes. We provide a convenience script:

1. The goal of Part 2 of the installation is to install Seirios, prepare the catkin_ws, and create the appropriate docker-compose.yaml file.

2. In the same directory in Terminal, run the command bash install-2-seirios.sh

3. Wait for the installation to complete

4. Restart the PC/machine after the installation

The Queue Manager is a feature for users to;

• View past, present (active) and future tasks that are queued

• Re-arrange tasks (admin only)

Presently, there are 2 ways to view the Queue Manager

• Method 1 : In Homepage view, by clicking the white status bar the Queue manager will appear

• Method 2 : By clicking the persistent icon at the top left of the screen, if not in Homepage view

Re-arrange the order of queue list by dragging the tasks up or down

Robot Checks:

Installation Steps

Before you start installing FMS, it's important to note that the current main method of installing FMS is by using Docker. You'll need to install docker on your own or use our installation script.

1. Download the latest FMS Easy Deploy version and unzip/extract the folder to a preferred directory

FMS Easy Deploy contains the installation scripts and will also act as the working space for the FMS installation.

1. Install docker on the host machine

For windows version, please install the from the Official Docker Website. Note that this will also require installing WSL2.

1. Run the installation script

After installing docker desktop, you can navigate to the FMS Easy Deploy directory and go to fms_easy_deploy/fms/windows/ which will contain all the necessary batch scripts. You can then just click the install.bat to run the installation batch script which will pull the Official FMS Docker Images.

1. Start the containers

In order to start FMS, you can use the start script (start.bat) which will load the environment variables and run the containers based on the docker compose file.

You can also use the stop script (stop.bat) to stop the docker containers easily.

Uninstalling FMS

If you want to uninstall FMS which involves removing docker images and volumes. We provide a convenience script uninstall.bat

1. Open a new terminal window. Execute this command: rostopic pub /cmd_vel geometry_msgs/Twist "linear: x: 0.0 y: 0.0 z: 0.0 angular: x: 0.0 y: 0.0 z: 0.0"

2. Change the linear: x: to 0.1-0.5 as we only want to move the robot straightly forward. Leave all the other values to 0.0.

3. Measure the distance the robot moved. And record the time between when the robot started to move and when the robot stopped. Calculate speed by dividing the distance over time.

4. Check whether your calculated speed matches up to the value that you have given for linear x.

5. If not, please recalibrate your wheels.

Alternatively, you may use rosrun telelop_twist_keyboard teleop_twist_keyboard.py. Similarly, give it a linear speed between 0.1-0.5. Then repeat Steps 3 - 5 above.

Note:

• If your robot is non-holonomic, it shouldn't be able to slide sideways. y should be 0.0.

• If your robot is not flight-capable, z should be 0.0.

Validating Odometry Data

We provide you with a script that enables you to verify the odometry data by inputting the velocity and duration. The robot will then move at the specified velocity for the given duration. Subsequently, the script will calculate and provide the distance traveled by the robot based on these inputs.

This will facilitate the verification of your odometry data, making it easier and more efficient for you.

You can download the script .

Dashboard is where you can see the robots operating in the environment.

1. Map switcher. If you have more than one maps loaded, the map switcher allows you to switch views between loaded maps.

2. Status bar. The status bar shows the current status and current active task (if available) of the active robot.

Supported Platforms

There are two types of Non-Fully Qualified Tasks, Auxiliary Tasks, and Custom Tasks.

Auxiliary Tasks

Auxiliary tasks are executables such as lights, music, sound, or others*.

They are created and executed independently.

Seirios RNS (Robot Navigation Software) introduces a powerful feature that significantly enhances the efficiency of defining navigation stations for robots. This document covers the steps to utilize the new bulk station management feature, which allows users to import station details from an Excel file. This feature can create or update over 500+ stations in a matter of seconds, a significant improvement over the manual method. The feature is available from version 4.30.1 for both Frontend and Backend.

Feature Summary

The bulk station management feature enables users to define multiple stations simultaneously by importing data from an Excel file. This reduces the manual effort required to set stations one by one, which can be time-consuming and prone to error.

Benefits

The following subpages are categories of frequently asked questions on Seirios.

There are 4 categories of questions;

Users can create one or more (no limit) stations for a specific map to dock to - for charging or for other tasks (such as picking of objects with a robotic arm payload)

Creating stations

Users are required to drive the robot manually in the map (in the interest of accuracy and precision) and upon reaching the point of interest, capture the pose and store it as a station

What are the supported devices or minimum resolutions

From the top left corner, click the hamburger menu button to expand the options and click on Task Manager. You will be presented with two options, Tasklist and Scheduler.

These two options share many similarities but Scheduler introduces the element of time on top of queued tasks.

Creating a Project

To be able to use FMS, you need to create a project. Everything in FMS (robots, maps, tasks, etc.) is organised in projects. To create a project, from the FMS application home click "Add Projects" or "Create" > "Project" from the top right.

Fill in the details then click "Submit". You then should see there's a new project on the list.

Enter the project and you should be directed to the new project's dashboard.

Adding Your First Robot

Now that we have a project, let's add a robot to the project. Inside the project, under the "Robots" tab, click "Create Robot".

Fill in the details, then click "Submit".

You will get a robot key. Copy and paste this robot key to your robot's plugin. Refer to this tutorial for a quick start with RNS plugin. Now you can close the dialog.

You will see the new robot appear on the list. When the robot is connected, the connection status should turn green.

Add and Load a Map to FMS

Robots must operate within a map. For this, we need to add a map to FMS. There are several ways to add a map to FMS. We will discuss two methods: importing from file and creating a map with robot (mapping).

Adding a Map to FMS

Import a Map from File

To import a map from file, go to "Library" tab and click "Import Map from File" on the top left.

Fill in the map information and upload the files. You need both the PGM and YAML files of the map (following the ROS mapping system). Then click "Submit".

You should now see the new map on the list.

Adding a Map by Mapping

To add a new map by mapping, go to the Dashboard tab and switch the mode to manual mapping.

To begin the mapping process, click "Manual" on the control panel.

Drive the robot with keyboard or joystick.

When you're done, click "Save".

A new map will then appear on the list in "Library".

Loading a Map to Dashboard

Now we will use the map(s) that we just added into the dashboard so the robots can use it for navigation and localisation. For this, under the "Library" tab, click "Load Maps".

FMS allows multiple maps to be loaded at the same time (e.g. for multi-floor operations). Robots will be able to navigate between maps. To add a map to dashboard, click the little "+" button on the map card. Then click "Save".

If you go to the Dashboard, you should see that the maps are now visible.

Adding and Running a Task

Now that we have robots operating in a map, let's put the robot to work. We can send robots to do tasks. Let's create our first task.

Under the "Dashboard" tab, switch the mode to "Waypoint".

Add waypoints on the map by dragging across the map and clicking "Mark" where you want your waypoint to be, then click "Save". Name your waypoint.

To execute the task, click the tasks shortcut icon and choose your task.

Choose the agent to execute the task. You can also ask the FMS to automatically assign the task to any one robot. Then click "Run Now".

You shall now see that the assigned robot is executing the task.

Next Steps

Congratulations, you've executed your first task on FMS. Now let's see the other features that FMS has to offer.

1. Launch the robot's motor and sensor drivers.

2. Run rosnode list to find the names of the ROS nodes of the drivers.

3. Run rosnode info <node> , where <node> is the name of the nodes determined from step 2. Sample output:

4. From the information displayed from running step 3, make sure that:

   1. The robot motor driver node subscribes to the topic /cmd_vel for velocity commands.

   2. The Lidar driver node publishes laser data to the topic /scan

5. If the topic names are not set as in step 4, remap them in the launch files of the drivers by adding a line in the launch files in the following format:

6. While the robot base and lidar are launched, run rosrun rqt_tf_tree rqt_tf_tree and check that the frames are linked in this order: odom → base_link → laser.
7. If the frames of base_link and laser are not linked correctly, there are two options you can link them. You can select one of them. (Prefer use Broadcast a transformation)

   1. Broadcast a transformation refer to this .

   2. Create static transformation

8. With the driver nodes running, run RVIZ using: rosrun rviz rviz, do the following checks:

   1. Laser data ("/scan") can be seen and is orientated in the correct direction.

   2. Movement direction during teleoperation is correct.

Step 1

The easy-deploy package can be obtained from our Movel AI representative or can be downloaded from the following mirrors. Please ensure the right mirror for the right architecture (arm64 or x86 is selected)

Follow the instructions on the following pages to completely install Seirios RNS:

Move the easy-deploy zip file to your home directory /home/<USER> and extract the zip using the Archive Manager (<USER> refers to the account username).

Step 2

1. Now, we need to run the installation in a Terminal

2. Right-click in the file explorer and open a Terminal in the extracted easy-deploy folder/directory

Then we move to the next part to install docker.

In order to start integrating your robot into FMS, you'll need to create a Robot Plugin which acts as the communication bridge between your robot and FMS.

It's also important to note that FMS is designed to be software agnostic, meaning that our system and APIs are not tied to a specific robot system. In general, most robot systems should be compatible with our APIs.

A robot plugin can run as a standalone program or it can run alongside as a process in your robot system. As long as it is able to send and receive data from or to the FMS, then it can be classified as a robot plugin.

FMS has built-in support for Seirios RNS, you don't to create an additional robot plugin if you're already using it.

You can check this article on how to enable the FMS Mode from Seirios RNS.

Generally, you will need to do these three steps to create a functional robot plugin:

1. Decide which capabilities you want to integrate from your robot to FMS

FMS is packed with many features and you might find that you don't need all the available features. You can specifically pick features that you want your robot to be able to perform from the perspective of FMS. This concept is called Capabilities and it can help you save time when you are creating your robot plugin.

For example, if your robot is able to perform navigation task by sending a Goal Point but it is not able to Teleoperate manually. You can specify that when you're initializing your plugin and those capabilities will be reflected later in the FMS UI. In this case, the teleoperation joystick will not be shown for the respective robot.

You can read more about Capabilities .

1. Integrate your robot with the FMS Robot API

You can integrate your robot with FMS in two ways:

(a) Use the FMS Robot SDK, currently only supported in Python and soon Node.js.

(b) Manually integrate to the FMS Robot API by interacting with our HTTP and MQTT APIs.

You can read more about the integration process with FMS Robot API .

1. Deploy and run your robot plugin

After you've finished writing your robot plugin, then you can run it either as a binary or as a docker container. As mentioned in the beginning of the article, there are no specific approach on how to deploy the robot plugin.

For best practices on the deployment, you can check the article .

Installation Steps

Before you start installing RNS Plugin, it's important to note that the current main method of installing RNS Plugin is by using Docker. You'll need to install docker on your own or use our installation script.

1. Download the latest FMS Easy Deploy version and unzip/extract the folder to a preferred directory

FMS Easy Deploy contains the installation scripts and will also act as the working space for the RNS Plugin installation.

1. Install docker on the host machine

For windows version, please install the from the Official Docker Website. Note that this will also require installing WSL2.

1. Run the installation script

After installing docker desktop, you can navigate to the FMS Easy Deploy directory and go to fms_easy_deploy/rns_plugin/windows/ which will contain all the necessary batch scripts. You can then just click the install.bat to run the installation batch script which will pull the Official RNS Plugin Docker Image.

1. Start the containers

In order to start the RNS Plugin, you can use the start script (start.bat) which will load the environment variables and run the containers based on the docker compose file.

You can also use the stop script (stop.bat) to stop the docker containers easily.

Uninstalling RNS Plugin

If you want to uninstall RNS Plugin which involves removing docker images and volumes. We provide a convenience script uninstall.bat

Technical Resources relating to the Seirios Software:

We also have made our Seirios Manual Book available for download by clicking .

The Settings modal can be shown by clicking on the top left menu icon. Here you will find the following settings;

Robot Customisations

The following features are bundled with the following features.

Please refer to the respective features' page for additional details, images and information by referring to the menu on the left or by clicking the hyperlinks below.

You can migrate or close your current robot images, database, and configuration of Seirios RNS to another robot, depending on your needs.

Backup Data

1. Backup the custom image from docker

Backing up the custom images (not the default ones) is the most important because in our cloud, we don't have any custom images of the clients, we only have the default images. Since custom images may be different for each client/robot.

Usually, the default images are named “registry.gitlab.com/<path>:<tag>”, but the custom images are usually named by adding some word behind the tag like “registry.gitlab.com/<path>:<tag>-<client>” or another name.

1. Check the name of your custom image on your docker-compose.yaml file,

or you can check on the docker ps (if you are already running the container):

1. See the image using docker image ls :
2. Save the docker images to a tar archive file: docker save seirios-ros-development > ~/catkin_ws/movel_ai/seirios-ros-development.tar Change the seirios-ros-development to your custom image name, and you can change the tar filename as well see if the new tar file is generated

2. Backup the default images from docker

It’s also important to back up the default images as well because if it’s not, the new PC has to download the images (it took > 6 GB) and also needs a credential key from movel.ai, you can ask the credential key to .

Otherwise, if you want to backup the default images as well, you can also backup the images using the same steps above.

3. Back up the database

You probably want to copy all the logs, maps, and some tasks that are already saved on your robot to another robot. So you don't have to do mapping and creating the tasks again.

Please follow the instructions below to back up the database:

1. Go inside the seirios-mongo container, and copy the db to the folder you want to save it inside the container, by executing the following command:

docker exec -i seirios-mongo /usr/bin/mongodump --db=movelweb --out=/backup_db

1. Create a folder on the pc, this will be a location for the database file, by executing this command:

mkdir -p ~/catkin_ws/movel_ai/backup_db

1. Copy the folder inside the docker container to outside, by following this command:

docker cp <container_name>:/backup_db ~/catkin_ws/movel_ai/backup_db

4. Back up the config and the ~/catkin_ws/movel_ai folder

Since we already copied the database and images to ~/catkin_ws/movel_ai folder, and the docker-compose.yaml and all the configuration files are already on ~/catkin_ws/movel_ai as well. Then the next step is you can copy all the files and folders on ~/catkin_ws/movel_ai folder.

---------------------

Restore Data

1. Restore the docker-compose and config on ~/catkin_ws/movel_ai

Please copy ~/catkin_ws/movel_ai folder from your old robot to the new robot, to restore the docker-compose.yaml and all the configurations.

2. Restore the docker image

Since we already copied the image as a tar archive file, you can load it into docker as a docker image file by executing this command:

docker load < ~/catkin_ws/movel_ai/seirios-ros-development.tar

Change the seirios-ros-development.tar to your docker image name.

Then check if all the images are loaded properly or not by executing the following command: docker image ls .

3. Restore the database

First, make sure you run the seirios-mongo container on the docker.

To restore the database that you already saved before, you can execute the following command on the new PC:

docker exec -i seirios-mongo /usr/bin/mongorestore --db=movelweb ~/catkin_ws/movel_ai/backup_db .

Technical Resources relating to the FMS:

How to Integration the Kudan Packages into Seirios RNS

First, you have to download the Kudan ROS Packages, If you haven't installed the Seirios RNS yet, you can download the kudan-movel easy deploy package using this (only for x86_64 architecture). But if you already installed the Seirios RNS yet, you can contact for the link to download the Kudan Packages. Then please make sure your seirios-ros image version is at least 2.48.9 or newer. You can check it by executing this command: docker ps | grep seirios-ros And see the version on this line:

If your version is older than 2.48.9, please contact for updating the version.

1. Kudan Setup

1. Copy the kdlidar_ros package into the ~/catkin_ws/movel_ai/ folder

2. Change the permission of kdlidar_ros, so it can be executed inside the docker chmod -R +x ~/catkin_ws/movel_ai/kdlidar_ros/

3. Configure tf/transform parameters in these launch files:

2. Docker Setup

1. Create the ros_entrypoint.sh in the ~/catkin_ws/movel_ai/ folder.

   Also, change the permission of the ros_entry_point.sh by executing this command: sudo chmod +x ~/catkin_ws/movel_ai/ros_entrypoint.sh

2. Edit your docker-compose.yaml file in the

3. task_supervisor Config Setup

Edit the task_supervisor.yaml (at ~/catkin_ws/movel_ai/config/task_supervisor/config/task_supervisor.yaml)

1. Add kudan_localization_handler to the plugins section with the following lines and comment if there's any plugin with the same type number. Example:

2. Add a kudan_localization_handler section with the following parameters at the end of the file:

For seamless integration with Seirios RNS, it is important to set up some key robotics software and drivers in your robot system. The following is a checklist of things that Seirios RNS requires your robot system to have before Seirios is installed:

• Motor drivers

  • Ensure that the motor driver node is running properly and can be controlled via teleoperation from the command line.

  • Ensure that the motor driver node is subscribed to the /cmd_vel topic

  • Else, remap it to subscribe to /cmd_vel topic

• Sensors

  • Ensure that the sensors are launched and running properly

  • Ensure that they are publishing data to the appropriate ROS topics

• TF check

  • Ensure that all the robot links have an appropriate tf to the odom link

  • The tf tree can be visualized using $ rosrun rqt_tf_tree rqt_tf_tree

TF for base_link to scan:

• Ensure that there is a direct tf link between the base_link frame and the laser frame as it is required by Seirios RNS

• RVIZ sensor data visualisation

  • Using RViz, visualize the sensor data. The fixed frame used should be odom

  • Add the tf visualization and ensure all the frames tfs have no warnings

This manual is intended to give you a complete guide on how to integrate your robot into FMS. You can explore the following guides below:

If you prefer a hands-on approach, we also have a tutorial on integrating the Turtlebot3 Simulation Robot into FMS.

Mapping

1. Q: No map is loaded even after the successful installation of Seirios RNS A: Use the Mapping feature to create your first map. Please refer to the in the above sections in full detail to start mapping

Seirios supports a wide range, variety, and combination of sensors on robots for various applications.

The following are sensors tried and tested with Seirios RNS on various robots types

How it works

Pebble Planner takes the global plan, decimates it to space out the poses as “pebbles”, then tries to reach them one by one.

It does this by rotating towards the next pebble, then accelerating until the maximum velocity is reached.