Add sample client for the autoRef CI protocol

Author: g3force

cmd/ssl-auto-ref-ci-client/README.md

@@ -0,0 +1,17 @@
+# ssl-auto-ref-ci-client
+
+This folder contains a sample client that connects to the CI interface of an autoRef and the game-controller.
+
+## Protocol
+The communication is established with a bidirectional TCP connection. Messages are encoded with [Protocol Buffers](https://developers.google.com/protocol-buffers/). Each message is preceded by an uvarint containing the message size in bytes, see https://cwiki.apache.org/confluence/display/GEODE/Delimiting+Protobuf+Messages for details.
+
+The protobuf format can be found in [../../proto/ssl_autoref_ci.proto](../../proto/ssl_autoref_ci.proto).
+
+The default port is `10013`.
+
+## Sample client
+The sample client, that is included in this folder, can be used to test the connection. It can be run with 
+```bash
+go run cmd/ssl-auto-ref-ci-client/main.go
+``` 
+Pass it the `-h` parameter to get the available options.

cmd/ssl-auto-ref-ci-client/main.go

@@ -0,0 +1,136 @@
+package main
+
+import (
+	"bufio"
+	"flag"
+	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/ci"
+	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/ci/autoref"
+	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/sslconn"
+	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/state"
+	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/tracker"
+	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/vision"
+	"github.com/google/uuid"
+	"log"
+	"net"
+	"time"
+)
+
+var addressAutoRefCi = flag.String("addressAutoRef", "localhost:10013", "The address of the auto referee CI interface")
+var addressGcCi = flag.String("addressGc", "localhost:10009", "The address of the ssl-game-controller CI interface")
+
+var id = uuid.NewString()
+var name = "Test client"
+var detectionFrame = createSSlDetectionFrame()
+var refereeMsg *state.Referee
+var robotSpeed = float32(1)
+
+func main() {
+	flag.Parse()
+
+	autoRefConn := connect(*addressAutoRefCi)
+	gcConn := connect(*addressGcCi)
+
+	for {
+		simulate()
+		sendAutoRefCi(autoRefConn, detectionFrame)
+		trackerFrame := receiveAutoRefCi(autoRefConn)
+		sendCi(gcConn, trackerFrame)
+		refereeMsg = receiveCi(gcConn)
+		time.Sleep(10 * time.Millisecond)
+	}
+}
+
+func simulate() {
+	robotX := detectionFrame.RobotsBlue[0].X
+	*robotX += robotSpeed / 100 * 1000
+	if *robotX > 2000 || *robotX < -2000 {
+		robotSpeed *= -1
+	}
+}
+
+func connect(addr string) (conn net.Conn) {
+	conn, err := net.Dial("tcp", addr)
+	if err != nil {
+		log.Fatal("could not connect to ", addr)
+	}
+	log.Printf("Connected to %v", addr)
+	return
+}
+
+func createBall() (ball *vision.SSL_DetectionBall) {
+	ball = new(vision.SSL_DetectionBall)
+	ball.Confidence = new(float32)
+	ball.PixelX = new(float32)
+	ball.PixelY = new(float32)
+	ball.X = new(float32)
+	ball.Y = new(float32)
+	*ball.Confidence = 1
+	return
+}
+
+func createBot() (robot *vision.SSL_DetectionRobot) {
+	robot = new(vision.SSL_DetectionRobot)
+	robot.Confidence = new(float32)
+	robot.RobotId = new(uint32)
+	robot.PixelX = new(float32)
+	robot.PixelY = new(float32)
+	robot.X = new(float32)
+	robot.Y = new(float32)
+	robot.Orientation = new(float32)
+	*robot.Confidence = 1
+	return
+}
+
+func createSSlDetectionFrame() (p *vision.SSL_DetectionFrame) {
+	p = new(vision.SSL_DetectionFrame)
+	p.FrameNumber = new(uint32)
+	p.TSent = new(float64)
+	p.TCapture = new(float64)
+	p.CameraId = new(uint32)
+	p.Balls = []*vision.SSL_DetectionBall{createBall()}
+	p.RobotsBlue = []*vision.SSL_DetectionRobot{createBot()}
+	return
+}
+
+func sendCi(conn net.Conn, trackerPacket *tracker.TrackerWrapperPacket) {
+	timestamp := time.Now().UnixNano()
+	*trackerPacket.TrackedFrame.Timestamp = float64(timestamp / 1e9)
+	*trackerPacket.TrackedFrame.FrameNumber++
+	input := ci.CiInput{Timestamp: &timestamp, TrackerPacket: trackerPacket}
+	if err := sslconn.SendMessage(conn, &input); err != nil {
+		log.Println("Could not send message: ", err)
+	}
+}
+
+func receiveCi(conn net.Conn) *state.Referee {
+	reader := bufio.NewReaderSize(conn, 1)
+	output := ci.CiOutput{}
+	if err := sslconn.ReceiveMessage(reader, &output); err != nil {
+		log.Println("Could not receive message: ", err)
+	}
+	return output.RefereeMsg
+}
+
+func sendAutoRefCi(conn net.Conn, detectionFrame *vision.SSL_DetectionFrame) {
+	timestamp := time.Now().UnixNano()
+
+	*detectionFrame.TSent = float64(timestamp / 1e9)
+	*detectionFrame.TCapture = float64(timestamp / 1e9)
+	*detectionFrame.FrameNumber++
+	input := autoref.AutoRefCiInput{
+		Detection:      []*vision.SSL_DetectionFrame{detectionFrame},
+		RefereeMessage: refereeMsg,
+	}
+	if err := sslconn.SendMessage(conn, &input); err != nil {
+		log.Println("Could not send message: ", err)
+	}
+}
+
+func receiveAutoRefCi(conn net.Conn) *tracker.TrackerWrapperPacket {
+	reader := bufio.NewReaderSize(conn, 1)
+	output := autoref.AutoRefCiOutput{}
+	if err := sslconn.ReceiveMessage(reader, &output); err != nil {
+		log.Println("Could not receive message: ", err)
+	}
+	return output.TrackerWrapperPacket
+}

doc/AutoRefCi.md

@@ -2,6 +2,8 @@
 
 To ease integration of the ssl-game-controller and the auto-referee implementations, there are separate unicast protocols that avoid the asynchronous communication via multicast and allows for integration with simulators and running at non-realtime speeds.
 
+The default port is `10013`.
+
 ## Connection sequence
 
 The connection is described in the following sequence diagram:

generateProto.sh

@@ -42,6 +42,7 @@ protoc -I"./proto" -I"$GOPATH/src" --go_out="$GOPATH/src" proto/ssl_gc_engine_co
 
 # continuous integration communication
 protoc -I"./proto" -I"$GOPATH/src" --go_out="$GOPATH/src" proto/ssl_gc_ci.proto
+protoc -I"./proto" -I"$GOPATH/src" --go_out="$GOPATH/src" proto/ssl_autoref_ci.proto
 
 # generate javascript code
 pbjs -t static-module -w es6 -o src/proto.js \