RoboCup simulation league is accepting your challenge (for free!)
Tags: programming, python, simulation, ros
Published: 2020-11-19 01:34:14

Introduction
======

Applications are now open for the Simulation DSPL competition of the RoboCup@Home Real Robot League.

In this competition, you will perform a cleanup task using HSR. The competition is done in a simulation environment and uses the open-source version of the HSR simulator. Combined with the "free for new teams" rule of RoboCup, you can participate in RoboCup completely free of charge.

![HSR](https://dev-to-uploads.s3.amazonaws.com/i/70tb6qijsdm2hwjd1iwi.png)

Below is how to participate.

How to participate in the challenge
============================

Register from the RoboCup Japan Committee page
-------------------------------------
Please register from the following URL (November 6 is the official registration deadline, but it is expected to be extended > now extended until November 27)
http://www.robocup.or.jp/japanopen2020b-en/news/Registration.html

Download the simulator
---------------------------
Please set up the HSR Simulator by reading the following README.
https://github.com/hsr-project/tmc_wrs_docker/blob/master/README.md

The README describes the steps to install the simulator on Linux, but it also works on Docker for Windows and Docker for Mac as well.

In the case of Docker for Windows, WSL2 is used internally. Since the number of processors used as default is small to run the simulator, it is recommended to increase the number by entering the following command at the command prompt:

```shell
notepad %UserProfile%.wslconfig
```

After the notepad opens, copy and paste the following text and save it:

```
[wsl2]
processors=2
swap=0
```

`processors` specifies the number of CPU cores you want to assign to WSL2. Setting a larger number will speed up the simulation.

Create the repository
---------------------
A sample project is available at the following URL. Make a copy from here:
https://github.com/devrt/wrs2020-robocup-challenge

If you are brave enough to join in the competition while putting your algorithms to the public, please click the "fork" button to fork the repository.

If you want to keep the algorithm private during the competition, please a private repository with the same name on github. Then copy the repository with the following commands:

```
$ git clone --bare https://github.com/devrt/wrs2020-robocup-challenge.git
$ cd wrs2020-robocup-challenge.git
$ git push --mirror https://github.com/[yourusername]/wrs2020-robocup-challenge.git
```

Register your algorithm to the scoring server
---------------------
The algorithm will be scored automatically on the scoring server.
Please register the repository to the build service at the following URL:

https://github.com/apps/devrt/installations/new

In the "Repository access" setting, if you are concerned about security, please only register the algorithm repositories. If you don't care about security, select "All repositories".

Developing Algorithms
---------------------

To develop your algorithm, please open the webIDE of the HSR simulator (http://localhost:3001/) and clone the repository to develop the algorithm.

In the sample project, there is a simple move algorithm in "wrs_challenge/scripts/move.py", so let's start by modifying it.

The HSR simulator comes with learning materials in Juypyter notebooks (the default language is Japanese, but the English translation is available by clicking the "Langs" menu item), so let's start by rewriting the algorithm as you progress through the learning materials.

After you git push the algorithm to the repository, the simulator will detect the source changes and automatically run the simulation for scoring.

About Scoring
================
In this year's Simulation DSPL, scores will be calculated according to the rules of WRS2020.

For more information on the rules, please read the official rulebook below:
https://worldrobotsummit.org/wrs2020/challenge/download/Rules/DetailedRules_Partner_EN.pdf

Task1
------
The tidy up task.
Put away toys and kitchen items scattered on and underneath the long table to the trays and the storage boxes.
You'll get bonus points for putting away the specific types of toys and kitchen items in the designated places specified in the rulebook. Regular points will be given by clean them up to any place.
![Task1](https://dev-to-uploads.s3.amazonaws.com/i/9ilutfzr61xq7fhr5xzn.png)

Task2a
------
The moving task.
You will move to the next room, but there is a small object lying in your path, and the score will be decreased if you hit it.
The object is small enough to interfere with your movement, so you can break through it even if you hit it (you'll get a bonus if you can get into the next room).
![Task2a](https://dev-to-uploads.s3.amazonaws.com/i/dhdqenpkh3ksakzlbu56.png)

Task2
-----
The human support task.
You get points for listening to a person's request (in the simulator, the content is published in the "/message" ROS topic) and bringing them the requested object from the shelf.
In this task, we can get partial points for bringing in the wrong object, so let's get the partial points as a first step.
![Task2](https://dev-to-uploads.s3.amazonaws.com/i/bnwqjt9zd9qrxc1s2lg1.png)

How the scoring server works
-------------
The scoring server uses GitHub webhooks to monitor changes made to the repository.
When changes are made to the repository, it builds a Docker image using Dockerfile in the top folder of the repository and connects the built Docker image to the simulator, and executes it.
Once the algorithm finish running, the post-run score is saved in the score sheet.
![system overview](https://dev-to-uploads.s3.amazonaws.com/i/21sqisu5s9ep6pkizcw2.png)

Libraries and other software needed to run the algorithm can be installed by editing the Dockerfile (in the sample project, the Dockerfile contains a configuration to install each dependent package defined in package.xml).
The command to execute the algorithm can be customized by changing the CMD line at the end of the Dockerfile.

Publication of the scoring results
-------------
The placement of objects changes randomly and the ranking of the algorithms running on that environment is published weekly (this ranking is for reference only).

Scoring is done for all git pushes, but the ranking is calculated for the algorithm in the default branch (main or master) of the repository. Experimental development should be done using a branch other than the default branch.

The final ranking will be calculated and announced just before the day of the competition, Saturday, December 19 - Sunday, December 20, 2020.

Information for Contestants
-------------

Please refer to the timetable below for the day's schedule.
https://github.com/RoboCupAtHomeJP/AtHome2020/blob/master/timetable/TimeTable2020.pdf

Sim-DSPL will be held from 9:00 am to 12:00 pm (JST) on the 19th for the simulation and announcement of the ranking.

The algorithm can be updated until 10:00 pm (JST) on the 18th (the day before the competition).
Please do not update the algorithm after that time.

In order to evaluate the average performance of the algorithm, we will run three simulations: Round1, Round2, and Round3. Object placement will change in each round, as will the number of objects placed in Task1. The final ranking is determined by the average score of the three rounds.

The execution of the simulation and the calculation of the scores are automatic. If there is an anomaly in the execution of the algorithm, the competitor can request a restart of the simulation only once. However, even if the score after the restart is lower than the current score, the record will be overwritten. So please request the restart with caution. Also, requests for restarts outside of the hours of 9:00 to 12:00 on the 19th will not be accepted. So please be sure to connect to the Zoom conference on the day of the competition if there is any possibility of restarting.

The simulator (including the scoring program) has been updated since the announcement of the competition, so please update the docker image by entering the following command

```
docker-compose down
docker-compose pull
docker-compose up
```

The scoring calculation replicates the rules of WRS2020. However, the penalties for dropping objects in task1 and for moving objects around the target object in task2 are not applied.

The WRS2020 rules allow 15 minutes for task 1 and 5 minutes for task 2, for a total of 20 minutes of competition time.
The simulation will be forced to end after 20 minutes, so please use the time effectively to score points.