diff --git a/camera/camera_test.go b/camera/camera_test.go deleted file mode 100644 index 486bd1c..0000000 --- a/camera/camera_test.go +++ /dev/null @@ -1,171 +0,0 @@ -package camera - -import ( - "bufio" - "fmt" - "github.com/cyrilix/robocar-protobuf/go/events" - "github.com/golang/protobuf/proto" - log "github.com/sirupsen/logrus" - "io" - "io/ioutil" - "net" - "strings" - "sync" - "testing" -) - -type MockPublisher struct { - notifyChan chan []byte - initNotifyChan sync.Once -} - -func (p *MockPublisher) Close() error { - if p.notifyChan != nil { - close(p.notifyChan) - } - return nil -} - -func (p *MockPublisher) Publish(payload []byte) { - p.notifyChan <- payload -} - -func (p *MockPublisher) Notify() <-chan []byte { - p.initNotifyChan.Do(func() { p.notifyChan = make(chan []byte) }) - return p.notifyChan -} - -func TestPart_ListenEvents(t *testing.T) { - simulatorMock := SimulatorMock{} - err := simulatorMock.Start() - if err != nil { - t.Errorf("unable to start mock server: %v", err) - } - defer func() { - if err := simulatorMock.Close(); err != nil { - t.Errorf("unable to close mock server: %v", err) - } - }() - - publisher := MockPublisher{} - - part := New(&publisher, simulatorMock.Addr()) - go func() { - err := part.Start() - if err != nil { - t.Fatalf("unable to start camera simulator: %v", err) - } - }() - defer func() { - if err := part.Close(); err != nil { - t.Errorf("unable to close camera simulator: %v", err) - } - }() - - simulatorMock.WaitConnection() - log.Trace("read test data") - testContent, err := ioutil.ReadFile("testdata/msg.json") - lines := strings.Split(string(testContent), "\n") - - for idx, line := range lines { - err = simulatorMock.EmitMsg(line) - if err != nil { - t.Errorf("[line %v/%v] unable to write line: %v", idx+1, len(lines), err) - } - - byteMsg := <-publisher.Notify() - var msg events.FrameMessage - err = proto.Unmarshal(byteMsg, &msg) - if err != nil { - t.Errorf("unable to unmarshal frame msg: %v", err) - continue - } - if msg.GetId() == nil { - t.Error("frame msg has not Id") - } - if len(msg.Frame) < 10 { - t.Errorf("[%v] invalid frame image: %v", msg.Id, msg.GetFrame()) - } - } -} - -type SimulatorMock struct { - ln net.Listener - muConn sync.Mutex - conn net.Conn - writer *bufio.Writer - newConnection chan net.Conn - logger *log.Entry -} - -func (c *SimulatorMock) EmitMsg(p string) (err error) { - c.muConn.Lock() - defer c.muConn.Unlock() - _, err = c.writer.WriteString(p + "\n") - if err != nil { - c.logger.Errorf("unable to write response: %v", err) - } - if err == io.EOF { - c.logger.Info("Connection closed") - return err - } - err = c.writer.Flush() - return err -} - -func (c *SimulatorMock) WaitConnection() { - c.muConn.Lock() - defer c.muConn.Unlock() - c.logger.Debug("simulator waiting connection") - if c.conn != nil { - return - } - c.logger.Debug("new connection") - conn := <-c.newConnection - - c.conn = conn - c.writer = bufio.NewWriter(conn) -} - -func (c *SimulatorMock) Start() error { - c.logger = log.WithField("simulator", "mock") - c.newConnection = make(chan net.Conn) - ln, err := net.Listen("tcp", "127.0.0.1:") - c.ln = ln - if err != nil { - return fmt.Errorf("unable to listen on port: %v", err) - } - go func() { - for { - conn, err := c.ln.Accept() - if err != nil && err == io.EOF { - c.logger.Errorf("connection close: %v", err) - break - } - if c.newConnection == nil { - break - } - c.newConnection <- conn - } - }() - return nil -} - -func (c *SimulatorMock) Addr() string { - return c.ln.Addr().String() -} - -func (c *SimulatorMock) Close() error { - c.logger.Debug("close mock server") - - if c == nil { - return nil - } - close(c.newConnection) - c.newConnection = nil - err := c.ln.Close() - if err != nil { - return fmt.Errorf("unable to close mock server: %v", err) - } - return nil -} diff --git a/cmd/rc-simulator/rc-simultator.go b/cmd/rc-simulator/rc-simultator.go index dbbd73e..224968a 100644 --- a/cmd/rc-simulator/rc-simultator.go +++ b/cmd/rc-simulator/rc-simultator.go @@ -3,30 +3,35 @@ package main import ( "flag" "github.com/cyrilix/robocar-base/cli" - "github.com/cyrilix/robocar-simulator/camera" - "log" + "github.com/cyrilix/robocar-simulator/pkg/gateway" + log"github.com/sirupsen/logrus" "os" ) -const DefaultClientId = "robocar-camera" +const DefaultClientId = "robocar-simulator" func main() { - var mqttBroker, username, password, clientId, topicBase string + var mqttBroker, username, password, clientId, topicFrame string var address string + var debug bool mqttQos := cli.InitIntFlag("MQTT_QOS", 0) _, mqttRetain := os.LookupEnv("MQTT_RETAIN") cli.InitMqttFlags(DefaultClientId, &mqttBroker, &username, &password, &clientId, &mqttQos, &mqttRetain) - flag.StringVar(&topicBase, "mqtt-topic", os.Getenv("MQTT_TOPIC"), "Mqtt topic to publish camera frames, use MQTT_TOPIC if args not set") + flag.StringVar(&topicFrame, "mqtt-topic-frame", os.Getenv("MQTT_TOPIC"), "Mqtt topic to publish gateway frames, use MQTT_TOPIC_FRAME if args not set") flag.StringVar(&address, "simulator-address", "127.0.0.1:9091", "Simulator address") + flag.BoolVar(&debug, "debug", false, "Debug logs") flag.Parse() if len(os.Args) <= 1 { flag.PrintDefaults() os.Exit(1) } + if debug { + log.SetLevel(log.DebugLevel) + } client, err := cli.Connect(mqttBroker, username, password, clientId) if err != nil { @@ -35,7 +40,7 @@ func main() { defer client.Disconnect(10) - c := camera.New(camera.NewMqttPublisher(client, topicBase), address) + c := gateway.New(gateway.NewMqttPublisher(client, topicFrame, "", ""), address) defer c.Stop() cli.HandleExit(c) diff --git a/controls/controls.go b/pkg/controls/controls.go similarity index 97% rename from controls/controls.go rename to pkg/controls/controls.go index 0293593..1b0dcdf 100644 --- a/controls/controls.go +++ b/pkg/controls/controls.go @@ -5,7 +5,7 @@ import ( "encoding/json" "fmt" "github.com/cyrilix/robocar-protobuf/go/events" - "github.com/cyrilix/robocar-simulator/simulator" + "github.com/cyrilix/robocar-simulator/pkg/simulator" log "github.com/sirupsen/logrus" "io" "net" diff --git a/controls/controls_test.go b/pkg/controls/controls_test.go similarity index 99% rename from controls/controls_test.go rename to pkg/controls/controls_test.go index 6f5c8ad..bc01caf 100644 --- a/controls/controls_test.go +++ b/pkg/controls/controls_test.go @@ -5,7 +5,7 @@ import ( "encoding/json" "fmt" "github.com/cyrilix/robocar-protobuf/go/events" - "github.com/cyrilix/robocar-simulator/simulator" + "github.com/cyrilix/robocar-simulator/pkg/simulator" log "github.com/sirupsen/logrus" "io" "net" diff --git a/camera/camera.go b/pkg/gateway/gateway.go similarity index 58% rename from camera/camera.go rename to pkg/gateway/gateway.go index 04f5219..2d8edea 100644 --- a/camera/camera.go +++ b/pkg/gateway/gateway.go @@ -1,4 +1,4 @@ -package camera +package gateway import ( "bufio" @@ -6,7 +6,7 @@ import ( "fmt" "github.com/avast/retry-go" "github.com/cyrilix/robocar-protobuf/go/events" - "github.com/cyrilix/robocar-simulator/simulator" + "github.com/cyrilix/robocar-simulator/pkg/simulator" mqtt "github.com/eclipse/paho.mqtt.golang" "github.com/golang/protobuf/proto" "github.com/golang/protobuf/ptypes/timestamp" @@ -18,7 +18,7 @@ import ( func New(publisher Publisher, addressSimulator string) *Gateway { l := log.WithField("simulator", addressSimulator) - l.Info("run camera from simulator") + l.Info("run gateway from simulator") return &Gateway{ address: addressSimulator, @@ -27,7 +27,7 @@ func New(publisher Publisher, addressSimulator string) *Gateway { } } -/* Simulator interface to publish camera frames into mqtt topic */ +/* Simulator interface to publish gateway frames into mqtt topicFrame */ type Gateway struct { cancel chan interface{} @@ -49,6 +49,8 @@ func (p *Gateway) Start() error { select { case msg := <-msgChan: go p.publishFrame(msg) + go p.publishInputSteering(msg) + go p.publishInputThrottle(msg) case <-p.cancel: return nil } @@ -116,7 +118,7 @@ func (p *Gateway) listen(msgChan chan<- *simulator.TelemetryMsg, reader *bufio.R var msg simulator.TelemetryMsg err = json.Unmarshal(rawLine, &msg) if err != nil { - p.log.Errorf("unable to unmarshal simulator msg: %v", err) + p.log.Errorf("unable to unmarshal simulator msg '%v': %v", string(rawLine), err) } if "telemetry" != msg.MsgType { continue @@ -129,7 +131,7 @@ func (p *Gateway) publishFrame(msgSim *simulator.TelemetryMsg) { now := time.Now() msg := &events.FrameMessage{ Id: &events.FrameRef{ - Name: "camera", + Name: "gateway", Id: fmt.Sprintf("%d%03d", now.Unix(), now.Nanosecond()/1000/1000), CreatedAt: ×tamp.Timestamp{ Seconds: now.Unix(), @@ -139,11 +141,40 @@ func (p *Gateway) publishFrame(msgSim *simulator.TelemetryMsg) { Frame: msgSim.Image, } + log.Debugf("publish frame '%v/%v'", msg.Id.Name, msg.Id.Id) payload, err := proto.Marshal(msg) if err != nil { p.log.Errorf("unable to marshal protobuf message: %v", err) } - p.publisher.Publish(payload) + p.publisher.PublishFrame(payload) +} + +func (p *Gateway) publishInputSteering(msgSim *simulator.TelemetryMsg) { + steering := &events.SteeringMessage{ + Steering: float32(msgSim.SteeringAngle), + Confidence: 1.0, + } + + log.Debugf("publish steering '%v'", steering.Steering) + payload, err := proto.Marshal(steering) + if err != nil { + p.log.Errorf("unable to marshal protobuf message: %v", err) + } + p.publisher.PublishSteering(payload) +} + +func (p *Gateway) publishInputThrottle(msgSim *simulator.TelemetryMsg) { + steering := &events.ThrottleMessage{ + Throttle: float32(msgSim.Throttle), + Confidence: 1.0, + } + + log.Debugf("publish throttle '%v'", steering.Throttle) + payload, err := proto.Marshal(steering) + if err != nil { + p.log.Errorf("unable to marshal protobuf message: %v", err) + } + p.publisher.PublishThrottle(payload) } var connect = func(address string) (io.ReadWriteCloser, error) { @@ -155,25 +186,62 @@ var connect = func(address string) (io.ReadWriteCloser, error) { } type Publisher interface { - Publish(payload []byte) + PublishFrame(payload []byte) + PublishThrottle(payload []byte) + PublishSteering(payload []byte) } -func NewMqttPublisher(client mqtt.Client, topic string) Publisher { +func NewMqttPublisher(client mqtt.Client, topicFrame, topicThrottle, topicSteering string) Publisher { return &MqttPublisher{ - client: client, - topic: topic, + client: client, + topicFrame: topicFrame, + topicSteering: topicSteering, + topicThrottle: topicThrottle, } } type MqttPublisher struct { - client mqtt.Client - topic string + client mqtt.Client + topicFrame string + topicSteering string + topicThrottle string } -func (m *MqttPublisher) Publish(payload []byte) { - token := m.client.Publish(m.topic, 0, false, payload) - token.WaitTimeout(10 * time.Millisecond) - if err := token.Error(); err != nil { +func (m *MqttPublisher) PublishThrottle(payload []byte) { + if m.topicThrottle == "" { + return + } + err := m.publish(m.topicThrottle, payload) + if err != nil { + log.Errorf("unable to publish throttle: %v", err) + } +} + +func (m *MqttPublisher) PublishSteering(payload []byte) { + if m.topicSteering == "" { + return + } + err := m.publish(m.topicSteering, payload) + if err != nil { + log.Errorf("unable to publish steering: %v", err) + } +} + +func (m *MqttPublisher) PublishFrame(payload []byte) { + if m.topicFrame == "" { + return + } + err := m.publish(m.topicFrame, payload) + if err != nil { log.Errorf("unable to publish frame: %v", err) } } + +func (m *MqttPublisher) publish(topic string, payload []byte) error { + token := m.client.Publish(topic, 0, false, payload) + token.WaitTimeout(10 * time.Millisecond) + if err := token.Error(); err != nil { + return fmt.Errorf("unable to publish to topic: %v", err) + } + return nil +} diff --git a/pkg/gateway/gateway_test.go b/pkg/gateway/gateway_test.go new file mode 100644 index 0000000..d60b321 --- /dev/null +++ b/pkg/gateway/gateway_test.go @@ -0,0 +1,289 @@ +package gateway + +import ( + "bufio" + "encoding/json" + "fmt" + "github.com/cyrilix/robocar-protobuf/go/events" + "github.com/golang/protobuf/proto" + log "github.com/sirupsen/logrus" + "io" + "io/ioutil" + "net" + "strings" + "sync" + "testing" + "time" +) + +type MockPublisher struct { + notifyFrameChan chan []byte + initNotifyFrameChan sync.Once + notifySteeringChan chan []byte + initNotifySteeringChan sync.Once + notifyThrottleChan chan []byte + initNotifyThrottleChan sync.Once +} + +func (p *MockPublisher) Close() error { + if p.notifyFrameChan != nil { + close(p.notifyFrameChan) + } + if p.notifyThrottleChan != nil { + close(p.notifyThrottleChan) + } + if p.notifySteeringChan != nil { + close(p.notifySteeringChan) + } + return nil +} + +func (p *MockPublisher) PublishFrame(payload []byte) { + p.notifyFrameChan <- payload +} +func (p *MockPublisher) PublishSteering(payload []byte) { + p.notifySteeringChan <- payload +} +func (p *MockPublisher) PublishThrottle(payload []byte) { + p.notifyThrottleChan <- payload +} + +func (p *MockPublisher) NotifyFrame() <-chan []byte { + p.initNotifyFrameChan.Do(func() { p.notifyFrameChan = make(chan []byte) }) + return p.notifyFrameChan +} +func (p *MockPublisher) NotifySteering() <-chan []byte { + p.initNotifySteeringChan.Do(func() { p.notifySteeringChan = make(chan []byte) }) + return p.notifySteeringChan +} +func (p *MockPublisher) NotifyThrottle() <-chan []byte { + p.initNotifyThrottleChan.Do(func() { p.notifyThrottleChan = make(chan []byte) }) + return p.notifyThrottleChan +} + +func TestPart_ListenEvents(t *testing.T) { + simulatorMock := SimulatorMock{} + err := simulatorMock.Start() + if err != nil { + t.Errorf("unable to start mock server: %v", err) + } + defer func() { + if err := simulatorMock.Close(); err != nil { + t.Errorf("unable to close mock server: %v", err) + } + }() + + publisher := MockPublisher{} + + part := New(&publisher, simulatorMock.Addr()) + go func() { + err := part.Start() + if err != nil { + t.Fatalf("unable to start gateway simulator: %v", err) + } + }() + defer func() { + if err := part.Close(); err != nil { + t.Errorf("unable to close gateway simulator: %v", err) + } + }() + + simulatorMock.WaitConnection() + log.Trace("read test data") + testContent, err := ioutil.ReadFile("testdata/msg.json") + lines := strings.Split(string(testContent), "\n") + + for idx, line := range lines { + err = simulatorMock.EmitMsg(line) + if err != nil { + t.Errorf("[line %v/%v] unable to write line: %v", idx+1, len(lines), err) + } + + eventsType := map[string]bool{"frame": false, "steering": false, "throttle": false} + nbEventsExpected := len(eventsType) + wg := sync.WaitGroup{} + // Expect number mqtt event + + wg.Add(nbEventsExpected) + finished := make(chan struct{}) + go func() { + wg.Wait() + finished <- struct{}{} + }() + + timeout := time.Tick(100 * time.Millisecond) + + endLoop := false + for { + select { + case byteMsg := <-publisher.NotifyFrame(): + checkFrame(t, byteMsg) + eventsType["frame"] = true + wg.Done() + case byteMsg := <-publisher.NotifySteering(): + checkSteering(t, byteMsg, line) + eventsType["steering"] = true + wg.Done() + case byteMsg := <-publisher.NotifyThrottle(): + checkThrottle(t, byteMsg, line) + eventsType["throttle"] = true + wg.Done() + case <-finished: + log.Trace("loop ended") + endLoop = true + case <-timeout: + t.Errorf("not all event are published") + t.FailNow() + } + if endLoop { + break + } + } + for k, v := range eventsType { + if !v { + t.Errorf("no %v event published for line %v", k, line) + } + } + } +} + + +func checkFrame(t *testing.T, byteMsg []byte) { + var msg events.FrameMessage + err := proto.Unmarshal(byteMsg, &msg) + if err != nil { + t.Errorf("unable to unmarshal frame msg: %v", err) + } + if msg.GetId() == nil { + t.Error("frame msg has not Id") + } + if len(msg.Frame) < 10 { + t.Errorf("[%v] invalid frame image: %v", msg.Id, msg.GetFrame()) + } +} +func checkSteering(t *testing.T, byteMsg []byte, rawLine string) { + var input map[string]interface{} + err := json.Unmarshal([]byte(rawLine), &input) + if err != nil { + t.Fatalf("unable to parse input data '%v': %v", rawLine, err) + } + steering := input["steering_angle"].(float64) + expectedSteering := float32(steering) + + var msg events.SteeringMessage + err = proto.Unmarshal(byteMsg, &msg) + if err != nil { + t.Errorf("unable to unmarshal steering msg: %v", err) + } + + if msg.GetSteering() != expectedSteering{ + t.Errorf("invalid steering value: %f, wants %f", msg.GetSteering(), expectedSteering) + } + if msg.Confidence != 1.0 { + t.Errorf("invalid steering confidence: %f, wants %f", msg.Confidence, 1.0) + } +} + +func checkThrottle(t *testing.T, byteMsg []byte, rawLine string) { + var input map[string]interface{} + err := json.Unmarshal([]byte(rawLine), &input) + if err != nil { + t.Fatalf("unable to parse input data '%v': %v", rawLine, err) + } + throttle := input["throttle"].(float64) + expectedThrottle := float32(throttle) + + var msg events.SteeringMessage + err = proto.Unmarshal(byteMsg, &msg) + if err != nil { + t.Errorf("unable to unmarshal throttle msg: %v", err) + } + + if msg.GetSteering() != expectedThrottle { + t.Errorf("invalid throttle value: %f, wants %f", msg.GetSteering(), expectedThrottle) + } + if msg.Confidence != 1.0 { + t.Errorf("invalid throttle confidence: %f, wants %f", msg.Confidence, 1.0) + } +} + +type SimulatorMock struct { + ln net.Listener + muConn sync.Mutex + conn net.Conn + writer *bufio.Writer + newConnection chan net.Conn + logger *log.Entry +} + +func (c *SimulatorMock) EmitMsg(p string) (err error) { + c.muConn.Lock() + defer c.muConn.Unlock() + _, err = c.writer.WriteString(p + "\n") + if err != nil { + c.logger.Errorf("unable to write response: %v", err) + } + if err == io.EOF { + c.logger.Info("Connection closed") + return err + } + err = c.writer.Flush() + return err +} + +func (c *SimulatorMock) WaitConnection() { + c.muConn.Lock() + defer c.muConn.Unlock() + c.logger.Debug("simulator waiting connection") + if c.conn != nil { + return + } + c.logger.Debug("new connection") + conn := <-c.newConnection + + c.conn = conn + c.writer = bufio.NewWriter(conn) +} + +func (c *SimulatorMock) Start() error { + c.logger = log.WithField("simulator", "mock") + c.newConnection = make(chan net.Conn) + ln, err := net.Listen("tcp", "127.0.0.1:") + c.ln = ln + if err != nil { + return fmt.Errorf("unable to listen on port: %v", err) + } + go func() { + for { + conn, err := c.ln.Accept() + if err != nil && err == io.EOF { + c.logger.Errorf("connection close: %v", err) + break + } + if c.newConnection == nil { + break + } + c.newConnection <- conn + } + }() + return nil +} + +func (c *SimulatorMock) Addr() string { + return c.ln.Addr().String() +} + +func (c *SimulatorMock) Close() error { + c.logger.Debug("close mock server") + + if c == nil { + return nil + } + close(c.newConnection) + c.newConnection = nil + err := c.ln.Close() + if err != nil { + return fmt.Errorf("unable to close mock server: %v", err) + } + return nil +} diff --git a/camera/testdata/msg.json b/pkg/gateway/testdata/msg.json similarity index 62% rename from camera/testdata/msg.json rename to pkg/gateway/testdata/msg.json index aeca6c5..837247d 100644 --- a/camera/testdata/msg.json +++ b/pkg/gateway/testdata/msg.json @@ -1,9 +1,9 @@ -{"msg_type":"telemetry","steering_angle":0,"throttle":0,"speed":0.2596469,"image":"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","hit":"none","pos_x":50.00034,"pos_y":0.7937839,"pos_z":49.99669,"time":1201.61,"cte":0.0006424509} -{"msg_type":"telemetry","steering_angle":0,"throttle":0,"speed":0.1318146,"image":"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","hit":"none","pos_x":50.00065,"pos_y":0.7065881,"pos_z":49.99732,"time":1201.943,"cte":0.000949396} -{"msg_type":"telemetry","steering_angle":0,"throttle":0,"speed":0.1463221,"image":"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","hit":"none","pos_x":50.00129,"pos_y":0.7099024,"pos_z":50.00373,"time":1201.987,"cte":0.001561815} -{"msg_type":"telemetry","steering_angle":0,"throttle":0,"speed":0.08767843,"image":"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","hit":"none","pos_x":50.00005,"pos_y":0.7565171,"pos_z":49.99987,"time":1202.32,"cte":0.0003422312} -{"msg_type":"telemetry","steering_angle":0,"throttle":0,"speed":0.08365767,"image":"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","hit":"none","pos_x":49.99987,"pos_y":0.7560045,"pos_z":49.99776,"time":1202.351,"cte":0.0001621614} -{"msg_type":"telemetry","steering_angle":0,"throttle":0,"speed":0.06313626,"image":"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","hit":"none","pos_x":50.00092,"pos_y":0.7309952,"pos_z":49.99902,"time":1202.685,"cte":0.001214714} +{"msg_type":"telemetry","steering_angle":0.1,"throttle":0.3,"speed":0.2596469,"image":"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","hit":"none","pos_x":50.00034,"pos_y":0.7937839,"pos_z":49.99669,"time":1201.61,"cte":0.0006424509} +{"msg_type":"telemetry","steering_angle":0,"throttle":0.2,"speed":0.1318146,"image":"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","hit":"none","pos_x":50.00065,"pos_y":0.7065881,"pos_z":49.99732,"time":1201.943,"cte":0.000949396} +{"msg_type":"telemetry","steering_angle":-0.2,"throttle":1,"speed":0.1463221,"image":"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","hit":"none","pos_x":50.00129,"pos_y":0.7099024,"pos_z":50.00373,"time":1201.987,"cte":0.001561815} +{"msg_type":"telemetry","steering_angle":0.5,"throttle":0,"speed":0.08767843,"image":"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","hit":"none","pos_x":50.00005,"pos_y":0.7565171,"pos_z":49.99987,"time":1202.32,"cte":0.0003422312} +{"msg_type":"telemetry","steering_angle":0,"throttle":-0.5,"speed":0.08365767,"image":"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","hit":"none","pos_x":49.99987,"pos_y":0.7560045,"pos_z":49.99776,"time":1202.351,"cte":0.0001621614} +{"msg_type":"telemetry","steering_angle":0,"throttle":-1,"speed":0.06313626,"image":"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","hit":"none","pos_x":50.00092,"pos_y":0.7309952,"pos_z":49.99902,"time":1202.685,"cte":0.001214714} {"msg_type":"telemetry","steering_angle":0,"throttle":0,"speed":0.05198338,"image":"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","hit":"none","pos_x":50.00116,"pos_y":0.7310358,"pos_z":50.00174,"time":1202.715,"cte":0.001438592} {"msg_type":"telemetry","steering_angle":0,"throttle":0,"speed":0.04512238,"image":"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","hit":"none","pos_x":50.00043,"pos_y":0.7432075,"pos_z":50.0009,"time":1203.048,"cte":0.0007165282} {"msg_type":"telemetry","steering_angle":0,"throttle":0,"speed":0.03730256,"image":"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","hit":"none","pos_x":50.00028,"pos_y":0.7436392,"pos_z":49.99911,"time":1203.081,"cte":0.0005697492} diff --git a/simulator/simulator.go.go b/pkg/simulator/simulator.go.go similarity index 100% rename from simulator/simulator.go.go rename to pkg/simulator/simulator.go.go