Skip to content
master
Switch branches/tags
Code
This branch is up to date with master.
Contribute

Latest commit

 

Git stats

Files

Permalink
Failed to load latest commit information.
Type
Name
Latest commit message
Commit time
 
 
cmd
 
 
 
 
doc
 
 
 
 
pkg
 
 
 
 
 
 
src
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

CircleCI Go Report Card Go Doc Release Coverage

ssl-game-controller

The ssl-refbox replacement that was introduced at RoboCup 2019.

Screenshot of Interface

See FAQ for some general information.

Usage

If you just want to use this app, simply download the latest release binary. The binary is self-contained. No dependencies are required.

You can also use pre-build docker images:

docker pull robocupssl/ssl-game-controller
# Run GC with default configuration
docker run -p 8081:8081 robocupssl/ssl-game-controller
# Mount local directories 
docker run -p 8081:8081 \
  # Local config dir
  -v "$(pwd)"/config:/config \
  # Local data dir (current state)
  -v "$(pwd)"/data:/data \
  robocupssl/ssl-game-controller

The controller will generate a default config file to config/ssl-game-controller.yaml on the first start. Afterwards, you can change all settings there.

Runtime Requirements

  • No software dependencies (except for development, see below)
  • 64bit Linux, Windows, OSX (build your 32bit binaries yourself...)
  • Display Resolution of 1920x1080 is recommended
  • A reasonable Web-Browser (mostly tested on Chrome)
  • (optional) To view the field, you need the ssl-vision-client

External Runtime Dependencies

ssl-vision - Receive Geometry packages for correct field dimensions
If not available, make sure to configure to correct dimensions in config/ssl-game-controller.yaml.

tracker-source implementation that produces TrackerWrapperPacket - Get ball and robot positions.
Required for:

  • Check ball placement progress
  • Check for correct number of robots per team
  • Check if game can continue (ball and robots prepared)
  • Check for "no progress"
  • Check if keeper may be changed via team protocol

The TIGERs AutoRef is a tracker-source implementation. If no tracker-source is available, the above features will not work.

Reference Clients

There are some reference clients:

Integration into your own framework

The game-controller is designed to be integrated into your own AI framework, if you do not want to implement your own controller for testing purposes.

Download the release binary from the Github release and run it from inside your framework. You can adapt the ssl-game-controller.yaml config file that is generated on first startup, like changing the default ports. Some parameters can also be passed via command line. Find the available parameters with the -h option. Make sure to use non-standard ports whenever possible to avoid any interference with a real field setup.

There are three modes that you can run the ssl-game-controller with:

  1. system (default): Use system time
  2. vision: Receive messages from ssl-vision and use the timestamps from these messages as the time source. This is mostly useful, when you produce your own ssl-vision frames from simulation.
  3. ci: Connect your software directly to the GC via TCP. You send the current timestamp and tracker packets and will receive the resulting referee message.

It is highly recommended using the ci mode when you integrate the GC with your own simulator. It has following advantages:

  1. No multicast network traffic is required that might be published to your local network (make sure to unset network.publish-address)
  2. You have full control of the data flow. The GC will not do anything asynchronously in the background
  3. You define the time and thus the speed.
  4. You provide the ssl-vision tracking data directly.

If you use external simulators like grSim, you can consider using the vision mode instead. That way, the game-controller uses the time and speed of the simulator, even if it is not running in real time. You then still need to run a tracking-source implementation like an AutoRef if you require the additional features described in [External Runtime Dependencies](#External Runtime Dependencies).

When you enable ci mode, referee messages will still be published via multicast, unless the address is unset (set to an empty string). That way, you can still integrate an autoRef. It is not yet possible to use the autoRefs without multicast.

When the ci mode is enabled (via ssl-game-controller.yaml -> time-acquisition-mode), a TCP port is opened (default: 10009). The protocol is defined in proto/ssl_gc_ci.proto. You send CiInput messages and receive CiOutput messages. The protocol is the same as for the team-client. Each input will produce one or more outputs. This is, because some changes will generate multiple messages. CiOutput messages will also be pushed to the CI client for manual changes from the UI or UI API.

The GC requires some input data, see [External Runtime Dependencies](#External Runtime Dependencies). In the ci mode, you have to provide the geometry statically in config/ssl-game-controller.yaml. The ball and robot positions must be sent with the CiInput. It is sufficient to fill in the required fields and keep the optional empty.

A small sample test client for the ci mode can be found here: ssl-ci-test-client

If you can not use the ci mode, you can alternatively connect to the GC using the UI WebSocket API. The API is defined in proto/ssl_gc_api.proto and available at the path /api/control under the same port as the UI.

Examples

Development

Requirements

You need to install following dependencies first:

  • Go >= 1.17
  • Node
  • Yarn

Prepare

Download and install to GOPATH:

go get -u github.com/RoboCup-SSL/ssl-game-controller/...

Switch to project root directory

cd $GOPATH/src/github.com/RoboCup-SSL/ssl-game-controller/

Download dependencies for frontend

yarn install

Run

Run the backend:

go run cmd/ssl-game-controller/main.go

Run the UI:

# compile and hot-reload
yarn serve

Or use the provided IntelliJ run configurations.

Build self-contained release binary

First, build the UI resources

# compile and minify UI
yarn build

Then build the backend with packr

# get packr
go get github.com/gobuffalo/packr/packr
# install the binary
cd cmd/ssl-game-controller
packr install

Update generated protobuf code

Generate the code for the .proto files with ./generateProto.sh, after you've changed anything in a .proto file.