feat(processor): implement CustomSteeringProcessor

* SpeedZoneProcessor
 * SteeringProcessor

cmd/rc-throttle/rc-throttle.go

@@ -3,7 +3,9 @@ package main
 import (
 	"flag"
 	"github.com/cyrilix/robocar-base/cli"
+	"github.com/cyrilix/robocar-throttle/pkg/brake"
 	"github.com/cyrilix/robocar-throttle/pkg/throttle"
+	"github.com/cyrilix/robocar-throttle/pkg/types"
 	"go.uber.org/zap"
 	"log"
 	"os"
@@ -11,14 +13,21 @@ import (
 
 const (
 	DefaultClientId    = "robocar-throttle"
-	DefaultThrottleMin = 0.3
+	DefaultThrottleMin = 0.1
 )
 
 func main() {
 	var mqttBroker, username, password, clientId string
-	var throttleTopic, driveModeTopic, rcThrottleTopic, steeringTopic string
+	var throttleTopic, driveModeTopic, rcThrottleTopic, steeringTopic, throttleFeedbackTopic, speedZoneTopic string
 	var minThrottle, maxThrottle float64
 	var publishPilotFrequency int
+	var brakeConfig string
+	var enableBrake bool
+	var enableSpeedZone bool
+	var enableCustomSteeringProcessor bool
+	var configFileSteeringProcessor string
+	var slowZoneThrottle, normalZoneThrottle, fastZoneThrottle float64
+	var moderateSteering, fullSteering float64
 
 	err := cli.SetFloat64DefaultValueFromEnv(&minThrottle, "THROTTLE_MIN", DefaultThrottleMin)
 	if err != nil {
@@ -38,11 +47,26 @@ func main() {
 	flag.StringVar(&driveModeTopic, "mqtt-topic-drive-mode", os.Getenv("MQTT_TOPIC_DRIVE_MODE"), "Mqtt topic that contains DriveMode value, use MQTT_TOPIC_DRIVE_MODE if args not set")
 	flag.StringVar(&rcThrottleTopic, "mqtt-topic-rc-throttle", os.Getenv("MQTT_TOPIC_RC_THROTTLE"), "Mqtt topic that contains RC Throttle value, use MQTT_TOPIC_RC_THROTTLE if args not set")
 	flag.StringVar(&steeringTopic, "mqtt-topic-steering", os.Getenv("MQTT_TOPIC_STEERING"), "Mqtt topic that contains steering value, use MQTT_TOPIC_STEERING if args not set")
+	flag.StringVar(&throttleFeedbackTopic, "mqtt-topic-throttle-feedback", os.Getenv("MQTT_TOPIC_THROTTLE_FEEDBACK"), "Mqtt topic where to publish throttle feedback, use MQTT_TOPIC_THROTTLE_FEEDBACK if args not set")
+	flag.StringVar(&speedZoneTopic, "mqtt-topic-speed-zone", os.Getenv("MQTT_TOPIC_SPEED_ZONE"), "Mqtt topic where to subscribe speed zone events, use MQTT_TOPIC_SPEED_ZONE if args not set")
 
 	flag.Float64Var(&minThrottle, "throttle-min", minThrottle, "Minimum throttle value, use THROTTLE_MIN if args not set")
 	flag.Float64Var(&maxThrottle, "throttle-max", maxThrottle, "Minimum throttle value, use THROTTLE_MAX if args not set")
 	flag.IntVar(&publishPilotFrequency, "update-pwm-frequency", 2, "Number of throttle event to publish when pilot mode is enabled")
 
+	flag.BoolVar(&enableBrake, "enable-brake-feature", false, "Enable brake to slow car on throttle changes")
+	flag.StringVar(&brakeConfig, "brake-configuration", "", "Json file to use to configure brake adaptation when --enable-brake is `true`")
+
+	flag.BoolVar(&enableCustomSteeringProcessor, "enable-custom-steering-processor", false, "Enable custom steering processor to estimate throttle")
+	flag.StringVar(&configFileSteeringProcessor, "custom-steering-processor-config", "", "Path to json config to parameter custom steering processor")
+
+	flag.BoolVar(&enableSpeedZone, "enable-speed-zone", false, "Enable speed zone information to estimate throttle")
+	flag.Float64Var(&slowZoneThrottle, "slow-zone-throttle", 0.11, "Throttle target for slow speed zone")
+	flag.Float64Var(&normalZoneThrottle, "normal-zone-throttle", 0.12, "Throttle target for normal speed zone")
+	flag.Float64Var(&fastZoneThrottle, "fast-zone-throttle", 0.13, "Throttle target for fast speed zone")
+	flag.Float64Var(&moderateSteering, "moderate-steering", 0.3, "Steering above is considered as moderate")
+	flag.Float64Var(&fullSteering, "full-steering", 0.8, "Steering above is considered as full")
+
 	logLevel := zap.LevelFlag("log", zap.InfoLevel, "log level")
 
 	flag.Parse()
@@ -64,13 +88,63 @@ func main() {
 	}()
 	zap.ReplaceGlobals(lgr)
 
+	zap.S().Infof("Topic throttle                 : %s", throttleTopic)
+	zap.S().Infof("Topic rc-throttle              : %s", rcThrottleTopic)
+	zap.S().Infof("Topic throttle feedback        : %s", throttleFeedbackTopic)
+	zap.S().Infof("Topic steering                 : %s", steeringTopic)
+	zap.S().Infof("Topic drive mode               : %s", driveModeTopic)
+	zap.S().Infof("Topic speed zone               : %s", speedZoneTopic)
+	zap.S().Infof("Min throttle                   : %v", minThrottle)
+	zap.S().Infof("Max throttle                   : %v", maxThrottle)
+	zap.S().Infof("Publish frequency              : %vHz", publishPilotFrequency)
+	zap.S().Infof("Brake enabled                  : %v", enableBrake)
+	zap.S().Infof("CustomSteeringProcessor enabled: %v", enableCustomSteeringProcessor)
+	zap.S().Infof("SpeedZone enabled              : %v", enableSpeedZone)
+	zap.S().Infof("SpeedZone slow throttle        : %v", slowZoneThrottle)
+	zap.S().Infof("SpeedZone normal throttle      : %v", normalZoneThrottle)
+	zap.S().Infof("SpeedZone fast throttle        : %v", fastZoneThrottle)
+	zap.S().Infof("Steering moderate              : %v", moderateSteering)
+	zap.S().Infof("Steering full                  : %v", fullSteering)
+
 	client, err := cli.Connect(mqttBroker, username, password, clientId)
 	if err != nil {
 		zap.S().Fatalf("unable to connect to mqtt bus: %v", err)
 	}
 	defer client.Disconnect(50)
 
-	p := throttle.New(client, throttleTopic, driveModeTopic, rcThrottleTopic, steeringTopic, float32(minThrottle), float32(maxThrottle), 2)
+	var brakeCtrl brake.Controller
+	if enableBrake {
+		brakeCtrl = brake.NewCustomControllerWithJsonConfig(brakeConfig)
+	} else {
+		brakeCtrl = &brake.DisabledController{}
+	}
+
+	if enableSpeedZone && enableCustomSteeringProcessor {
+		zap.S().Panicf("invalid flag, speedZone and customSteering processor can't be enabled at the same time")
+	}
+	var throttleProcessor throttle.Processor
+	if enableSpeedZone {
+		throttleProcessor = throttle.NewSpeedZoneProcessor(
+			types.Throttle(slowZoneThrottle),
+			types.Throttle(normalZoneThrottle),
+			types.Throttle(fastZoneThrottle),
+			moderateSteering,
+			fullSteering,
+		)
+	} else if enableCustomSteeringProcessor {
+		cfg, err := throttle.NewConfigFromJson(configFileSteeringProcessor)
+		if err != nil {
+			zap.S().Fatalf("unable to load config '%v': %v", configFileSteeringProcessor, err)
+		}
+		throttleProcessor = throttle.NewCustomSteeringProcessor(cfg)
+	} else {
+		throttleProcessor = throttle.NewSteeringProcessor(types.Throttle(minThrottle), types.Throttle(maxThrottle))
+	}
+
+	p := throttle.New(client, throttleTopic, driveModeTopic, rcThrottleTopic, steeringTopic, throttleFeedbackTopic,
+		speedZoneTopic, types.Throttle(maxThrottle), 2,
+		throttle.WithThrottleProcessor(throttleProcessor),
+		throttle.WithBrakeController(brakeCtrl))
 	defer p.Stop()
 
 	cli.HandleExit(p)

go.mod

@@ -4,7 +4,7 @@ go 1.19
 
 require (
 	github.com/cyrilix/robocar-base v0.1.7
-	github.com/cyrilix/robocar-protobuf/go v1.1.0
+	github.com/cyrilix/robocar-protobuf/go v1.3.0
 	github.com/eclipse/paho.mqtt.golang v1.4.1
 	go.uber.org/zap v1.23.0
 	google.golang.org/protobuf v1.28.1

go.sum

@@ -1,8 +1,8 @@
 github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8=
 github.com/cyrilix/robocar-base v0.1.7 h1:EVzZ0KjigSFpke5f3A/PybEH3WFUEIrYSc3z/dhOZ48=
 github.com/cyrilix/robocar-base v0.1.7/go.mod h1:4E11HQSNy2NT8e7MW188y6ST9C0RzarKyn7sK/3V/Lk=
-github.com/cyrilix/robocar-protobuf/go v1.1.0 h1:txIjGnnCF3UzedpsWu+sL7nMA+pNjSnX6HZlAmuReH4=
+github.com/cyrilix/robocar-protobuf/go v1.3.0 h1:vLsoLQeIfXPnrJ+xYrPy/R/swjYiMBBR7wT2ILdLcQA=
-github.com/cyrilix/robocar-protobuf/go v1.1.0/go.mod h1:Y3AE28K5V7EZxMXp/6A8RhkRz15VOfFy4CjST35FbtQ=
+github.com/cyrilix/robocar-protobuf/go v1.3.0/go.mod h1:Y3AE28K5V7EZxMXp/6A8RhkRz15VOfFy4CjST35FbtQ=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

pkg/brake/config.go

@@ -0,0 +1,54 @@
+package brake
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cyrilix/robocar-throttle/pkg/types"
+	"os"
+)
+
+var (
+	defaultBrakeConfig = Config{
+		DeltaSteps: []float32{0.05, 0.3, 0.5},
+		Data:       []types.Throttle{-0.1, -0.5, -1.},
+	}
+)
+
+func NewConfig() *Config {
+	return &defaultBrakeConfig
+}
+
+func NewConfigFromJson(fileName string) (*Config, error) {
+	content, err := os.ReadFile(fileName)
+	if err != nil {
+		return nil, fmt.Errorf("unable to read content from %s file: %w", fileName, err)
+	}
+	var ft Config
+	err = json.Unmarshal(content, &ft)
+	if err != nil {
+		return nil, fmt.Errorf("unable to unmarshal json content from %s file: %w", fileName, err)
+	}
+	return &ft, nil
+}
+
+type Config struct {
+	DeltaSteps []float32        `json:"delta_steps"`
+	Data       []types.Throttle `json:"data"`
+}
+
+func (tc *Config) ValueOf(currentThrottle, targetThrottle types.Throttle) types.Throttle {
+	delta := float32(currentThrottle - targetThrottle)
+
+	if delta < tc.DeltaSteps[0] {
+		return targetThrottle
+	}
+	if delta >= tc.DeltaSteps[len(tc.DeltaSteps)-1] {
+		return tc.Data[len(tc.Data)-1]
+	}
+	for idx, step := range tc.DeltaSteps {
+		if delta < step {
+			return tc.Data[idx-1]
+		}
+	}
+	return tc.Data[len(tc.Data)-1]
+}

pkg/brake/config_test.go

@@ -0,0 +1,132 @@
+package brake
+
+import (
+	"github.com/cyrilix/robocar-throttle/pkg/types"
+	"reflect"
+	"testing"
+)
+
+func TestNewConfigFromJson(t *testing.T) {
+	type args struct {
+		fileName string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    *Config
+		wantErr bool
+	}{
+		{
+			name: "default config",
+			args: args{
+				fileName: "test_data/config.json",
+			},
+			want: &defaultBrakeConfig,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := NewConfigFromJson(tt.args.fileName)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("NewConfigFromJson() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(*got, *tt.want) {
+				t.Errorf("NewConfigFromJson() got = %v, want %v", got, tt.want)
+			}
+			if !reflect.DeepEqual(got.DeltaSteps, tt.want.DeltaSteps) {
+				t.Errorf("NewConfigFromJson(), bad DeltaSteps: got = %v, want %v", got.DeltaSteps, tt.want.DeltaSteps)
+			}
+		})
+	}
+}
+
+func TestConfig_ValueOf(t *testing.T) {
+	type fields struct {
+		DeltaSteps []float32
+		MinValue   int
+		Data       []types.Throttle
+	}
+	type args struct {
+		currentThrottle, targetThrottle types.Throttle
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   types.Throttle
+	}{
+		{
+			name: "delta > 0",
+			fields: fields{
+				DeltaSteps: defaultBrakeConfig.DeltaSteps,
+				Data:       defaultBrakeConfig.Data,
+			},
+			args: args{
+				currentThrottle: 0.5,
+				targetThrottle:  0.8,
+			},
+			want: 0.8,
+		},
+		{
+			name: "no delta",
+			fields: fields{
+				DeltaSteps: defaultBrakeConfig.DeltaSteps,
+				Data:       defaultBrakeConfig.Data,
+			},
+			args: args{
+				currentThrottle: 0.5,
+				targetThrottle:  0.5,
+			},
+			want: 0.5,
+		},
+		{
+			name: "delta very low (< 1st step)",
+			fields: fields{
+				DeltaSteps: defaultBrakeConfig.DeltaSteps,
+				Data:       defaultBrakeConfig.Data,
+			},
+			args: args{
+				currentThrottle: 0.5,
+				targetThrottle:  0.495,
+			},
+			want: 0.495,
+		},
+		{
+			name: "low delta ( 1st step < delta < 2nd step )",
+			fields: fields{
+				DeltaSteps: defaultBrakeConfig.DeltaSteps,
+				Data:       defaultBrakeConfig.Data,
+			},
+			args: args{
+				currentThrottle: 0.5,
+				targetThrottle:  0.38,
+			},
+			want: -0.1,
+		},
+		{
+			name: "high delta",
+			fields: fields{
+				DeltaSteps: defaultBrakeConfig.DeltaSteps,
+				Data:       defaultBrakeConfig.Data,
+			},
+			args: args{
+				currentThrottle: 0.8,
+				targetThrottle:  0.3,
+			},
+			want: -1.,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			f := &Config{
+				DeltaSteps: tt.fields.DeltaSteps,
+				Data:       tt.fields.Data,
+			}
+			got := f.ValueOf(tt.args.currentThrottle, tt.args.targetThrottle)
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("ValueOf() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

pkg/brake/controller.go

@@ -0,0 +1,55 @@
+package brake
+
+import (
+	"github.com/cyrilix/robocar-throttle/pkg/types"
+	"go.uber.org/zap"
+	"sync"
+)
+
+type Controller interface {
+	SetRealThrottle(t types.Throttle)
+	AdjustThrottle(targetThrottle types.Throttle) types.Throttle
+}
+
+func NewCustomController() *CustomController {
+	return &CustomController{cfg: NewConfig()}
+}
+
+func NewCustomControllerWithJsonConfig(filename string) *CustomController {
+	config, err := NewConfigFromJson(filename)
+	if err != nil {
+		zap.S().Panicf("unable to init brake controller with json config '%s': %v", filename, err)
+	}
+	return &CustomController{cfg: config}
+}
+
+type CustomController struct {
+	muRealThrottle sync.RWMutex
+	realThrottle   types.Throttle
+	cfg            *Config
+}
+
+func (b *CustomController) SetRealThrottle(t types.Throttle) {
+	b.muRealThrottle.Lock()
+	defer b.muRealThrottle.Unlock()
+	b.realThrottle = t
+}
+
+func (b *CustomController) GetRealThrottle() types.Throttle {
+	b.muRealThrottle.RLock()
+	defer b.muRealThrottle.RUnlock()
+	res := b.realThrottle
+	return res
+}
+
+func (b *CustomController) AdjustThrottle(targetThrottle types.Throttle) types.Throttle {
+	return b.cfg.ValueOf(b.GetRealThrottle(), targetThrottle)
+}
+
+type DisabledController struct{}
+
+func (d *DisabledController) SetRealThrottle(_ types.Throttle) {}
+
+func (d *DisabledController) AdjustThrottle(targetThrottle types.Throttle) types.Throttle {
+	return targetThrottle
+}

pkg/brake/controller_test.go

@@ -0,0 +1,92 @@
+package brake
+
+import (
+	"github.com/cyrilix/robocar-throttle/pkg/types"
+	"testing"
+)
+
+func TestController_AdjustThrottle(t *testing.T) {
+	type fields struct {
+		realThrottle types.Throttle
+	}
+	type args struct {
+		targetThrottle types.Throttle
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   types.Throttle
+	}{
+		{
+			name:   "target same as current throttle",
+			fields: fields{realThrottle: 0.2},
+			args:   args{targetThrottle: 0.2},
+			want:   0.2,
+		},
+		{
+			name:   "target > as current throttle",
+			fields: fields{realThrottle: 0.2},
+			args:   args{targetThrottle: 0.3},
+			want:   0.3,
+		},
+		{
+			name:   "target >> as current throttle",
+			fields: fields{realThrottle: 0.2},
+			args:   args{targetThrottle: 0.5},
+			want:   0.5,
+		},
+		{
+			name:   "target < as current throttle",
+			fields: fields{realThrottle: 0.8},
+			args:   args{targetThrottle: 0.7},
+			want:   -0.1,
+		},
+		{
+			name:   "target << as current throttle",
+			fields: fields{realThrottle: 0.8},
+			args:   args{targetThrottle: 0.5},
+			want:   -0.5,
+		},
+		{
+			name:   "target <<< as current throttle",
+			fields: fields{realThrottle: 0.8},
+			args:   args{targetThrottle: 0.2},
+			want:   -1.,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			b := &CustomController{cfg: NewConfig()}
+			b.SetRealThrottle(tt.fields.realThrottle)
+			if got := b.AdjustThrottle(tt.args.targetThrottle); got != tt.want {
+				t.Errorf("AdjustThrottle() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestDisabledController_AdjustThrottle(t *testing.T) {
+	type args struct {
+		targetThrottle types.Throttle
+	}
+	tests := []struct {
+		name string
+		args args
+		want types.Throttle
+	}{
+		{
+			name: "doesn't modify value",
+			args: args{targetThrottle: 0.5},
+			want: 0.5,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &DisabledController{}
+			if got := d.AdjustThrottle(tt.args.targetThrottle); got != tt.want {
+				t.Errorf("AdjustThrottle() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

pkg/brake/test_data/config.json

@@ -0,0 +1,4 @@
+{
+  "delta_steps": [ 0.05, 0.3, 0.5 ],
+  "data": [ -0.1, -0.5, -1.0 ]
+}

pkg/throttle/controller.go

@@ -3,6 +3,8 @@ package throttle
 import (
 	"github.com/cyrilix/robocar-base/service"
 	"github.com/cyrilix/robocar-protobuf/go/events"
+	"github.com/cyrilix/robocar-throttle/pkg/brake"
+	"github.com/cyrilix/robocar-throttle/pkg/types"
 	mqtt "github.com/eclipse/paho.mqtt.golang"
 	"go.uber.org/zap"
 	"google.golang.org/protobuf/proto"
@@ -10,36 +12,61 @@ import (
 	"time"
 )
 
-func New(client mqtt.Client, throttleTopic, driveModeTopic, rcThrottleTopic, steeringTopic string, minValue, maxValue float32, publishPilotFrequency int) *Controller {
+func New(client mqtt.Client, throttleTopic, driveModeTopic, rcThrottleTopic, steeringTopic, throttleFeedbackTopic,
-	return &Controller{
+	speedZoneTopic string,
+	maxValue types.Throttle, publishPilotFrequency int, opts ...Option) *Controller {
+	c := &Controller{
 		client:                client,
 		throttleTopic:         throttleTopic,
 		driveModeTopic:        driveModeTopic,
 		rcThrottleTopic:       rcThrottleTopic,
 		steeringTopic:         steeringTopic,
+		throttleFeedbackTopic: throttleFeedbackTopic,
+		speedZoneTopic:        speedZoneTopic,
 		maxThrottle:           maxValue,
 		driveMode:             events.DriveMode_USER,
 		publishPilotFrequency: publishPilotFrequency,
-		steeringProcessor:     &SteeringProcessor{minThrottle: minValue, maxThrottle: maxValue},
+		processor:             &SteeringProcessor{minThrottle: 0.1, maxThrottle: maxValue},
+		brakeCtrl:             &brake.DisabledController{},
 	}
+	for _, o := range opts {
+		o(c)
+	}
+	return c
+}
 
+type Option func(c *Controller)
+
+func WithBrakeController(bc brake.Controller) Option {
+	return func(c *Controller) {
+		c.brakeCtrl = bc
+	}
+}
+
+func WithThrottleProcessor(p Processor) Option {
+	return func(c *Controller) {
+		c.processor = p
+	}
 }
 
 type Controller struct {
-	client            mqtt.Client
+	client        mqtt.Client
-	throttleTopic     string
+	throttleTopic string
-	maxThrottle       float32
+	maxThrottle   types.Throttle
-	steeringProcessor *SteeringProcessor
+	processor     Processor
 
 	muDriveMode sync.RWMutex
 	driveMode   events.DriveMode
 
 	muSteering sync.RWMutex
-	steering   float32
+	steering   types.Steering
 
-	cancel                                         chan interface{}
+	brakeCtrl brake.Controller
-	publishPilotFrequency                          int
+
-	driveModeTopic, rcThrottleTopic, steeringTopic string
+	cancel                                                                chan interface{}
+	publishPilotFrequency                                                 int
+	driveModeTopic, rcThrottleTopic, steeringTopic, throttleFeedbackTopic string
+	speedZoneTopic                                                        string
 }
 
 func (c *Controller) Start() error {
@@ -68,8 +95,10 @@ func (c *Controller) onPublishPilotValue() {
 		return
 	}
 
+	throttleFromSteering := c.processor.Process(c.readSteering())
+
 	throttleMsg := events.ThrottleMessage{
-		Throttle:   c.steeringProcessor.Process(c.readSteering()),
+		Throttle:   float32(c.brakeCtrl.AdjustThrottle(throttleFromSteering)),
 		Confidence: 1.0,
 	}
 	payload, err := proto.Marshal(&throttleMsg)
@@ -82,7 +111,7 @@ func (c *Controller) onPublishPilotValue() {
 
 }
 
-func (c *Controller) readSteering() float32 {
+func (c *Controller) readSteering() types.Steering {
 	c.muSteering.RLock()
 	defer c.muSteering.RUnlock()
 	return c.steering
@@ -90,14 +119,25 @@ func (c *Controller) readSteering() float32 {
 
 func (c *Controller) Stop() {
 	close(c.cancel)
-	service.StopService("throttle", c.client, c.driveModeTopic, c.rcThrottleTopic, c.steeringTopic)
+	service.StopService("throttle", c.client, c.driveModeTopic, c.rcThrottleTopic, c.steeringTopic,
+		c.throttleFeedbackTopic, c.speedZoneTopic)
+}
+
+func (c *Controller) onThrottleFeedback(_ mqtt.Client, message mqtt.Message) {
+	var msg events.ThrottleMessage
+	err := proto.Unmarshal(message.Payload(), &msg)
+	if err != nil {
+		zap.S().Errorf("unable to unmarshal protobuf %T message: %v", &msg, err)
+		return
+	}
+	c.brakeCtrl.SetRealThrottle(types.Throttle(msg.GetThrottle()))
 }
 
 func (c *Controller) onDriveMode(_ mqtt.Client, message mqtt.Message) {
 	var msg events.DriveModeMessage
 	err := proto.Unmarshal(message.Payload(), &msg)
 	if err != nil {
-		zap.S().Errorf("unable to unmarshal protobuf %T message: %v", msg, err)
+		zap.S().Errorf("unable to unmarshal protobuf %T message: %v", &msg, err)
 		return
 	}
 
@@ -119,9 +159,9 @@ func (c *Controller) onRCThrottle(_ mqtt.Client, message mqtt.Message) {
 			return
 		}
 		zap.S().Debugf("publish new throttle value from rc: %v", throttleMsg.GetThrottle())
-		if throttleMsg.GetThrottle() > c.maxThrottle {
+		if types.Throttle(throttleMsg.GetThrottle()) > c.maxThrottle {
 			zap.S().Debugf("throttle upper that max value allowed, patch value from %v to %v", throttleMsg.GetThrottle(), c.maxThrottle)
-			throttleMsg.Throttle = c.maxThrottle
+			throttleMsg.Throttle = float32(c.maxThrottle)
 			payloadPatched, err := proto.Marshal(&throttleMsg)
 			if err != nil {
 				zap.S().Errorf("unable to marshall throttle msg: %v", err)
@@ -144,7 +184,18 @@ func (c *Controller) onSteering(_ mqtt.Client, message mqtt.Message) {
 	}
 	c.muSteering.Lock()
 	defer c.muSteering.Unlock()
-	c.steering = steeringMsg.GetSteering()
+	c.steering = types.Steering(steeringMsg.GetSteering())
+}
+
+func (c *Controller) onSpeedZone(_ mqtt.Client, message mqtt.Message) {
+	var szMsg events.SpeedZoneMessage
+	payload := message.Payload()
+	err := proto.Unmarshal(payload, &szMsg)
+	if err != nil {
+		zap.S().Errorf("unable to unmarshal speedZone message, skip value: %v", err)
+		return
+	}
+	c.processor.SetSpeedZone(szMsg.GetSpeedZone())
 }
 
 var registerCallbacks = func(p *Controller) error {
@@ -162,6 +213,14 @@ var registerCallbacks = func(p *Controller) error {
 	if err != nil {
 		return err
 	}
+	err = service.RegisterCallback(p.client, p.throttleFeedbackTopic, p.onThrottleFeedback)
+	if err != nil {
+		return err
+	}
+	err = service.RegisterCallback(p.client, p.speedZoneTopic, p.onSpeedZone)
+	if err != nil {
+		return err
+	}
 	return nil
 }
 

pkg/throttle/controller_test.go

@@ -3,6 +3,8 @@ package throttle
 import (
 	"github.com/cyrilix/robocar-base/testtools"
 	"github.com/cyrilix/robocar-protobuf/go/events"
+	"github.com/cyrilix/robocar-throttle/pkg/brake"
+	"github.com/cyrilix/robocar-throttle/pkg/types"
 	mqtt "github.com/eclipse/paho.mqtt.golang"
 	"google.golang.org/protobuf/proto"
 	"sync"
@@ -33,14 +35,14 @@ func TestDefaultThrottle(t *testing.T) {
 	driveModeTopic := "topic/driveMode"
 	rcThrottleTopic := "topic/rcThrottle"
 	steeringTopic := "topic/rcThrottle"
+	throttleFeedbackTopic := "topic/feedback/throttle"
+	speedZoneTopic := "topic/speedZone"
 
-	minValue := float32(0.56)
+	p := New(nil, throttleTopic, driveModeTopic, rcThrottleTopic, steeringTopic, throttleFeedbackTopic, speedZoneTopic, 1., 200)
 
-	p := New(nil, throttleTopic, driveModeTopic, rcThrottleTopic, steeringTopic, minValue, 1., 200)
+	cases := []*struct {
-
-	cases := []struct {
 		name             string
-		maxThrottle      float32
+		maxThrottle      types.Throttle
 		driveMode        events.DriveModeMessage
 		rcThrottle       events.ThrottleMessage
 		expectedThrottle events.ThrottleMessage
@@ -113,16 +115,20 @@ func TestController_Start(t *testing.T) {
 	steeringTopic := "topic/steering"
 	driveModeTopic := "topic/driveMode"
 	rcThrottleTopic := "topic/rcThrottle"
+	throttleFeedbackTopic := "topic/feedback/throttle"
+	speedZoneTopic := "topic/speedZone"
 
 	type fields struct {
 		driveMode             events.DriveMode
-		min, max              float32
+		min, max              types.Throttle
 		publishPilotFrequency int
+		brakeCtl              brake.Controller
 	}
 	type msgEvents struct {
-		driveMode  *events.DriveModeMessage
+		driveMode        *events.DriveModeMessage
-		steering   *events.SteeringMessage
+		steering         *events.SteeringMessage
-		rcThrottle *events.ThrottleMessage
+		rcThrottle       *events.ThrottleMessage
+		throttleFeedback *events.ThrottleMessage
 	}
 
 	tests := []struct {
@@ -139,11 +145,13 @@ func TestController_Start(t *testing.T) {
 				max:                   0.8,
 				min:                   0.3,
 				publishPilotFrequency: publishPilotFrequency,
+				brakeCtl:              &brake.DisabledController{},
 			},
 			msgEvents: msgEvents{
-				driveMode:  &events.DriveModeMessage{DriveMode: events.DriveMode_USER},
+				driveMode:        &events.DriveModeMessage{DriveMode: events.DriveMode_USER},
-				steering:   &events.SteeringMessage{Steering: 0.0, Confidence: 1.0},
+				steering:         &events.SteeringMessage{Steering: 0.0, Confidence: 1.0},
-				rcThrottle: &events.ThrottleMessage{Throttle: 0.4, Confidence: 1.0},
+				rcThrottle:       &events.ThrottleMessage{Throttle: 0.4, Confidence: 1.0},
+				throttleFeedback: &events.ThrottleMessage{Throttle: 0.4, Confidence: 1.0},
 			},
 			want: &events.ThrottleMessage{Throttle: 0.4, Confidence: 1.0},
 		},
@@ -154,11 +162,13 @@ func TestController_Start(t *testing.T) {
 				max:                   0.8,
 				min:                   0.3,
 				publishPilotFrequency: publishPilotFrequency,
+				brakeCtl:              &brake.DisabledController{},
 			},
 			msgEvents: msgEvents{
-				driveMode:  &events.DriveModeMessage{DriveMode: events.DriveMode_USER},
+				driveMode:        &events.DriveModeMessage{DriveMode: events.DriveMode_USER},
-				steering:   &events.SteeringMessage{Steering: 0.0, Confidence: 1.0},
+				steering:         &events.SteeringMessage{Steering: 0.0, Confidence: 1.0},
-				rcThrottle: &events.ThrottleMessage{Throttle: 0.9, Confidence: 1.0},
+				rcThrottle:       &events.ThrottleMessage{Throttle: 0.9, Confidence: 1.0},
+				throttleFeedback: &events.ThrottleMessage{Throttle: 0.8, Confidence: 1.0},
 			},
 			want: &events.ThrottleMessage{Throttle: 0.8, Confidence: 1.0},
 		},
@@ -169,11 +179,13 @@ func TestController_Start(t *testing.T) {
 				max:                   0.8,
 				min:                   0.3,
 				publishPilotFrequency: publishPilotFrequency,
+				brakeCtl:              &brake.DisabledController{},
 			},
 			msgEvents: msgEvents{
-				driveMode:  &events.DriveModeMessage{DriveMode: events.DriveMode_USER},
+				driveMode:        &events.DriveModeMessage{DriveMode: events.DriveMode_USER},
-				steering:   &events.SteeringMessage{Steering: 0.0, Confidence: 1.0},
+				steering:         &events.SteeringMessage{Steering: 0.0, Confidence: 1.0},
-				rcThrottle: &events.ThrottleMessage{Throttle: 0.1, Confidence: 1.0},
+				rcThrottle:       &events.ThrottleMessage{Throttle: 0.1, Confidence: 1.0},
+				throttleFeedback: &events.ThrottleMessage{Throttle: 0.4, Confidence: 1.0},
 			},
 			want: &events.ThrottleMessage{Throttle: 0.1, Confidence: 1.0},
 		},
@@ -184,11 +196,13 @@ func TestController_Start(t *testing.T) {
 				max:                   0.8,
 				min:                   0.3,
 				publishPilotFrequency: publishPilotFrequency,
+				brakeCtl:              &brake.DisabledController{},
 			},
 			msgEvents: msgEvents{
-				driveMode:  &events.DriveModeMessage{DriveMode: events.DriveMode_PILOT},
+				driveMode:        &events.DriveModeMessage{DriveMode: events.DriveMode_PILOT},
-				steering:   &events.SteeringMessage{Steering: 0.0, Confidence: 1.0},
+				steering:         &events.SteeringMessage{Steering: 0.0, Confidence: 1.0},
-				rcThrottle: &events.ThrottleMessage{Throttle: 0.5, Confidence: 1.0},
+				rcThrottle:       &events.ThrottleMessage{Throttle: 0.5, Confidence: 1.0},
+				throttleFeedback: &events.ThrottleMessage{Throttle: 0.4, Confidence: 1.0},
 			},
 			want: &events.ThrottleMessage{Throttle: 0.8, Confidence: 1.0},
 		},
@@ -199,11 +213,13 @@ func TestController_Start(t *testing.T) {
 				max:                   0.8,
 				min:                   0.3,
 				publishPilotFrequency: publishPilotFrequency,
+				brakeCtl:              &brake.DisabledController{},
 			},
 			msgEvents: msgEvents{
-				driveMode:  &events.DriveModeMessage{DriveMode: events.DriveMode_PILOT},
+				driveMode:        &events.DriveModeMessage{DriveMode: events.DriveMode_PILOT},
-				steering:   &events.SteeringMessage{Steering: -1.0, Confidence: 1.0},
+				steering:         &events.SteeringMessage{Steering: -1.0, Confidence: 1.0},
-				rcThrottle: &events.ThrottleMessage{Throttle: 0.3, Confidence: 1.0},
+				rcThrottle:       &events.ThrottleMessage{Throttle: 0.3, Confidence: 1.0},
+				throttleFeedback: &events.ThrottleMessage{Throttle: 0.4, Confidence: 1.0},
 			},
 			want: &events.ThrottleMessage{Throttle: 0.3, Confidence: 1.0},
 		},
@@ -214,22 +230,46 @@ func TestController_Start(t *testing.T) {
 				max:                   0.8,
 				min:                   0.3,
 				publishPilotFrequency: publishPilotFrequency,
+				brakeCtl:              &brake.DisabledController{},
 			},
 			msgEvents: msgEvents{
-				driveMode:  &events.DriveModeMessage{DriveMode: events.DriveMode_PILOT},
+				driveMode:        &events.DriveModeMessage{DriveMode: events.DriveMode_PILOT},
-				steering:   &events.SteeringMessage{Steering: 1.0, Confidence: 1.0},
+				steering:         &events.SteeringMessage{Steering: 1.0, Confidence: 1.0},
-				rcThrottle: &events.ThrottleMessage{Throttle: 0.3, Confidence: 1.0},
+				rcThrottle:       &events.ThrottleMessage{Throttle: 0.3, Confidence: 1.0},
+				throttleFeedback: &events.ThrottleMessage{Throttle: 0.4, Confidence: 1.0},
 			},
 			want: &events.ThrottleMessage{Throttle: 0.3, Confidence: 1.0},
 		},
+		{
+			name: "On pilot drive mode, should brake on brutal change",
+			fields: fields{
+				driveMode:             events.DriveMode_PILOT,
+				max:                   1.0,
+				min:                   0.3,
+				publishPilotFrequency: publishPilotFrequency,
+				brakeCtl:              brake.NewCustomController(),
+			},
+			msgEvents: msgEvents{
+				driveMode:        &events.DriveModeMessage{DriveMode: events.DriveMode_PILOT},
+				steering:         &events.SteeringMessage{Steering: -1.0, Confidence: 1.0},
+				rcThrottle:       &events.ThrottleMessage{Throttle: 0.3, Confidence: 1.0},
+				throttleFeedback: &events.ThrottleMessage{Throttle: 1.0, Confidence: 1.0},
+			},
+			want: &events.ThrottleMessage{Throttle: -1.0, Confidence: 1.0},
+		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			c := New(nil,
-				throttleTopic, driveModeTopic, rcThrottleTopic, steeringTopic,
+				throttleTopic, driveModeTopic, rcThrottleTopic, steeringTopic, throttleFeedbackTopic,
-				tt.fields.min, tt.fields.max,
+				speedZoneTopic, tt.fields.max,
 				tt.fields.publishPilotFrequency,
+				WithThrottleProcessor(&SteeringProcessor{
+					minThrottle: tt.fields.min,
+					maxThrottle: tt.fields.max,
+				}),
+				WithBrakeController(tt.fields.brakeCtl),
 			)
 
 			go c.Start()
@@ -241,6 +281,7 @@ func TestController_Start(t *testing.T) {
 			c.onDriveMode(nil, testtools.NewFakeMessageFromProtobuf(driveModeTopic, tt.msgEvents.driveMode))
 			c.onRCThrottle(nil, testtools.NewFakeMessageFromProtobuf(rcThrottleTopic, tt.msgEvents.rcThrottle))
 			c.onSteering(nil, testtools.NewFakeMessageFromProtobuf(steeringTopic, tt.msgEvents.steering))
+			c.onThrottleFeedback(nil, testtools.NewFakeMessageFromProtobuf(throttleFeedbackTopic, tt.msgEvents.throttleFeedback))
 			waitPublish.Wait()
 
 			var msg events.ThrottleMessage

pkg/throttle/processor.go

@@ -1,13 +1,179 @@
 package throttle
 
-import "math"
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cyrilix/robocar-protobuf/go/events"
+	"github.com/cyrilix/robocar-throttle/pkg/types"
+	"math"
+	"os"
+	"sync"
+)
+
+type Processor interface {
+	// Process compute throttle from steering value
+	Process(steering types.Steering) types.Throttle
+
+	SetSpeedZone(sz events.SpeedZone)
+}
+
+func NewSteeringProcessor(minThrottle, maxThrottle types.Throttle) *SteeringProcessor {
+	return &SteeringProcessor{
+		minThrottle: minThrottle,
+		maxThrottle: maxThrottle,
+	}
+}
 
 type SteeringProcessor struct {
-	minThrottle, maxThrottle float32
+	minThrottle, maxThrottle types.Throttle
+}
+
+func (sp *SteeringProcessor) SetSpeedZone(_ events.SpeedZone) {
+	return
 }
 
 // Process compute throttle from steering value
-func (sp *SteeringProcessor) Process(steering float32) float32 {
+func (sp *SteeringProcessor) Process(steering types.Steering) types.Throttle {
 	absSteering := math.Abs(float64(steering))
-	return sp.minThrottle + float32(float64(sp.maxThrottle-sp.minThrottle)*(1-absSteering))
+	return sp.minThrottle + types.Throttle(float64(sp.maxThrottle-sp.minThrottle)*(1-absSteering))
+}
+
+func NewSpeedZoneProcessor(slowThrottle, normalThrottle, fastThrottle types.Throttle,
+	moderateSteering, fullSteering float64) *SpeedZoneProcessor {
+	return &SpeedZoneProcessor{
+		muSz:             sync.Mutex{},
+		speedZone:        events.SpeedZone_UNKNOWN,
+		slowThrottle:     slowThrottle,
+		normalThrottle:   normalThrottle,
+		fastThrottle:     fastThrottle,
+		moderateSteering: moderateSteering,
+		fullSteering:     fullSteering,
+	}
+}
+
+type SpeedZoneProcessor struct {
+	muSz                                       sync.Mutex
+	speedZone                                  events.SpeedZone
+	slowThrottle, normalThrottle, fastThrottle types.Throttle
+	moderateSteering, fullSteering             float64
+}
+
+func (sp *SpeedZoneProcessor) SpeedZone() events.SpeedZone {
+	sp.muSz.Lock()
+	defer sp.muSz.Unlock()
+	return sp.speedZone
+}
+
+func (sp *SpeedZoneProcessor) SetSpeedZone(sz events.SpeedZone) {
+	sp.muSz.Lock()
+	defer sp.muSz.Unlock()
+	sp.speedZone = sz
+}
+
+// Process compute throttle from steering value
+func (sp *SpeedZoneProcessor) Process(steering types.Steering) types.Throttle {
+	st := math.Abs(float64(steering))
+
+	switch sp.SpeedZone() {
+	case events.SpeedZone_FAST:
+		if st >= sp.fullSteering {
+			return sp.slowThrottle
+		} else if st >= sp.moderateSteering {
+			return sp.normalThrottle
+		}
+		return sp.fastThrottle
+	case events.SpeedZone_NORMAL:
+		if st > sp.fullSteering {
+			return sp.slowThrottle
+		}
+		return sp.normalThrottle
+	case events.SpeedZone_SLOW:
+		return sp.slowThrottle
+	}
+	return sp.slowThrottle
+}
+
+func NewCustomSteeringProcessor(cfg *Config) *CustomSteeringProcessor {
+	return &CustomSteeringProcessor{
+		cfg: cfg,
+	}
+}
+
+type CustomSteeringProcessor struct {
+	cfg *Config
+}
+
+func (cp *CustomSteeringProcessor) Process(steering types.Steering) types.Throttle {
+	return cp.cfg.ValueOf(steering)
+}
+
+func (cp *CustomSteeringProcessor) SetSpeedZone(_ events.SpeedZone) {
+	return
+}
+
+var emptyConfig = Config{
+	SteeringValues: []types.Steering{},
+	ThrottleSteps:  []types.Throttle{},
+}
+
+func NewConfigFromJson(fileName string) (*Config, error) {
+	content, err := os.ReadFile(fileName)
+	if err != nil {
+		return nil, fmt.Errorf("unable to read content from %s file: %w", fileName, err)
+	}
+	var ft Config
+	err = json.Unmarshal(content, &ft)
+	if err != nil {
+		return &emptyConfig, fmt.Errorf("unable to unmarshal json content from %s file: %w", fileName, err)
+	}
+	if len(ft.SteeringValues) == 0 {
+		return &emptyConfig, fmt.Errorf("invalid configuration, none steering value'")
+	}
+	if len(ft.SteeringValues) != len(ft.ThrottleSteps) {
+		return &emptyConfig, fmt.Errorf("invalid config, steering value number must be equals "+
+			"to throttle value number: %v/%v", len(ft.SteeringValues), len(ft.ThrottleSteps))
+	}
+	lastT := types.Throttle(1.)
+	for _, t := range ft.ThrottleSteps {
+		if t < 0. || t > 1. {
+			return &emptyConfig, fmt.Errorf("invalid throttle value: 0.0 < %v <= 1.0", t)
+		}
+		if t >= lastT {
+			return &emptyConfig, fmt.Errorf("invalid throttle value, all values must be decreasing: %v <= %v", lastT, t)
+		}
+		lastT = t
+	}
+	lastS := types.Steering(-0.001)
+	for _, s := range ft.SteeringValues {
+		if s < 0. || s > 1. {
+			return &emptyConfig, fmt.Errorf("invalid steering value: 0.0 < %v <= 1.0", s)
+		}
+		if s <= lastS {
+			return &emptyConfig, fmt.Errorf("invalid steering value, all values must be increasing: %v <= %v", lastS, s)
+		}
+		lastS = s
+	}
+	return &ft, nil
+}
+
+type Config struct {
+	SteeringValues []types.Steering `json:"steering_values"`
+	ThrottleSteps  []types.Throttle `json:"throttle_steps"`
+}
+
+func (tc *Config) ValueOf(s types.Steering) types.Throttle {
+	st := s
+	if s < 0. {
+		st = s * -1
+	}
+	if st < tc.SteeringValues[0] {
+		return tc.ThrottleSteps[0]
+	}
+
+	for i, steeringStep := range tc.SteeringValues {
+		if st < steeringStep {
+			return tc.ThrottleSteps[i-1]
+		}
+	}
+	return tc.ThrottleSteps[len(tc.ThrottleSteps)-1]
 }

pkg/throttle/processor_test.go

@@ -1,20 +1,27 @@
 package throttle
 
-import "testing"
+import (
+	"github.com/cyrilix/robocar-protobuf/go/events"
+	"github.com/cyrilix/robocar-throttle/pkg/types"
+	"os"
+	"path"
+	"reflect"
+	"testing"
+)
 
 func TestSteeringProcessor_Process(t *testing.T) {
 	type fields struct {
-		minThrottle float32
+		minThrottle types.Throttle
-		maxThrottle float32
+		maxThrottle types.Throttle
 	}
 	type args struct {
-		steering float32
+		steering types.Steering
 	}
 	tests := []struct {
 		name   string
 		fields fields
 		args   args
-		want   float32
+		want   types.Throttle
 	}{
 		{
 			name: "steering straight",
@@ -84,3 +91,324 @@ func TestSteeringProcessor_Process(t *testing.T) {
 		})
 	}
 }
+
+func TestSpeedZoneProcessor_Process(t *testing.T) {
+	type fields struct {
+		slowThrottle   types.Throttle
+		normalThrottle types.Throttle
+		fastThrottle   types.Throttle
+		speedZone      events.SpeedZone
+	}
+	type args struct {
+		steering types.Steering
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   types.Throttle
+	}{
+		{
+			name:   "steering straight, undefined zone",
+			fields: fields{slowThrottle: 0.2, normalThrottle: 0.5, fastThrottle: 0.8, speedZone: events.SpeedZone_SLOW},
+			args:   args{steering: 0.},
+			want:   0.2,
+		},
+		{
+			name:   "steering straight, slow zone",
+			fields: fields{slowThrottle: 0.2, normalThrottle: 0.5, fastThrottle: 0.8, speedZone: events.SpeedZone_SLOW},
+			args:   args{steering: 0.},
+			want:   0.2,
+		},
+		{
+			name:   "moderate left, slow speed",
+			fields: fields{slowThrottle: 0.2, normalThrottle: 0.5, fastThrottle: 0.8, speedZone: events.SpeedZone_SLOW},
+			args:   args{steering: -0.5},
+			want:   0.2,
+		},
+		{
+			name:   "moderate right, slow speed",
+			fields: fields{slowThrottle: 0.2, normalThrottle: 0.5, fastThrottle: 0.8, speedZone: events.SpeedZone_SLOW},
+			args:   args{steering: 0.5},
+			want:   0.2,
+		},
+		{
+			name:   "full left, slow speed",
+			fields: fields{slowThrottle: 0.2, normalThrottle: 0.5, fastThrottle: 0.8, speedZone: events.SpeedZone_SLOW},
+			args:   args{steering: -0.95},
+			want:   0.2,
+		},
+		{
+			name:   "full right, slow speed",
+			fields: fields{slowThrottle: 0.2, normalThrottle: 0.5, fastThrottle: 0.8, speedZone: events.SpeedZone_SLOW},
+			args:   args{steering: 0.95},
+			want:   0.2,
+		},
+		{
+			name:   "steering straight, normal zone",
+			fields: fields{slowThrottle: 0.2, normalThrottle: 0.5, fastThrottle: 0.8, speedZone: events.SpeedZone_NORMAL},
+			args:   args{steering: 0.},
+			want:   0.5,
+		},
+		{
+			name:   "moderate left, normal speed",
+			fields: fields{slowThrottle: 0.2, normalThrottle: 0.5, fastThrottle: 0.8, speedZone: events.SpeedZone_NORMAL},
+			args:   args{steering: -0.5},
+			want:   0.5,
+		},
+		{
+			name:   "moderate right, normal speed",
+			fields: fields{slowThrottle: 0.2, normalThrottle: 0.5, fastThrottle: 0.8, speedZone: events.SpeedZone_NORMAL},
+			args:   args{steering: 0.5},
+			want:   0.5,
+		},
+		{
+			name:   "full left, normal speed",
+			fields: fields{slowThrottle: 0.2, normalThrottle: 0.5, fastThrottle: 0.8, speedZone: events.SpeedZone_NORMAL},
+			args:   args{steering: -0.95},
+			want:   0.2,
+		},
+		{
+			name:   "full right, normal speed",
+			fields: fields{slowThrottle: 0.2, normalThrottle: 0.5, fastThrottle: 0.8, speedZone: events.SpeedZone_NORMAL},
+			args:   args{steering: 0.95},
+			want:   0.2,
+		},
+		{
+			name:   "steering straight, fast zone",
+			fields: fields{slowThrottle: 0.2, normalThrottle: 0.5, fastThrottle: 0.8, speedZone: events.SpeedZone_FAST},
+			args:   args{steering: 0.},
+			want:   0.8,
+		},
+		{
+			name:   "moderate left, fast speed",
+			fields: fields{slowThrottle: 0.2, normalThrottle: 0.5, fastThrottle: 0.8, speedZone: events.SpeedZone_FAST},
+			args:   args{steering: -0.5},
+			want:   0.5,
+		},
+		{
+			name:   "moderate right, fast speed",
+			fields: fields{slowThrottle: 0.2, normalThrottle: 0.5, fastThrottle: 0.8, speedZone: events.SpeedZone_FAST},
+			args:   args{steering: 0.5},
+			want:   0.5,
+		},
+		{
+			name:   "full left, fast speed",
+			fields: fields{slowThrottle: 0.2, normalThrottle: 0.5, fastThrottle: 0.8, speedZone: events.SpeedZone_FAST},
+			args:   args{steering: -0.95},
+			want:   0.2,
+		},
+		{
+			name:   "full right, fast speed",
+			fields: fields{slowThrottle: 0.2, normalThrottle: 0.5, fastThrottle: 0.8, speedZone: events.SpeedZone_FAST},
+			args:   args{steering: 0.95},
+			want:   0.2,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sp := &SpeedZoneProcessor{
+				slowThrottle:     tt.fields.slowThrottle,
+				normalThrottle:   tt.fields.normalThrottle,
+				fastThrottle:     tt.fields.fastThrottle,
+				moderateSteering: 0.4,
+				fullSteering:     0.8,
+			}
+			sp.SetSpeedZone(tt.fields.speedZone)
+			if got := sp.Process(tt.args.steering); got != tt.want {
+				t.Errorf("Process() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestConfig_ValueOf(t *testing.T) {
+	type fields struct {
+		SteeringValue []types.Steering
+		Data          []types.Throttle
+	}
+	type args struct {
+		s types.Steering
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   types.Throttle
+	}{
+		{
+			name:   "Nil steering",
+			fields: fields{[]types.Steering{0.0, 0.5, 1.0}, []types.Throttle{0.9, 0.6, 0.1}},
+			args:   args{0.0},
+			want:   0.9,
+		},
+		{
+			name:   "Nil steering < min config",
+			fields: fields{[]types.Steering{0.2, 0.5, 1.0}, []types.Throttle{0.9, 0.6, 0.3}},
+			args:   args{0.1},
+			want:   0.9,
+		},
+		{
+			name:   "No nil steering",
+			fields: fields{[]types.Steering{0.0, 0.5, 1.0}, []types.Throttle{0.9, 0.6, 0.1}},
+			args:   args{0.2},
+			want:   0.9,
+		},
+		{
+			name:   "Intermediate steering",
+			fields: fields{[]types.Steering{0.0, 0.5, 1.0}, []types.Throttle{0.9, 0.6, 0.1}},
+			args:   args{0.5},
+			want:   0.6,
+		},
+		{
+			name:   "Max steering",
+			fields: fields{[]types.Steering{0.0, 0.5, 1.0}, []types.Throttle{0.9, 0.6, 0.1}},
+			args:   args{1.0},
+			want:   0.1,
+		},
+		{
+			name:   "Over steering",
+			fields: fields{[]types.Steering{0.0, 0.5, 1.0}, []types.Throttle{0.9, 0.6, 0.1}},
+			args:   args{1.1},
+			want:   0.1,
+		},
+		{
+			name:   "Negative steering < min config",
+			fields: fields{[]types.Steering{0.2, 0.5, 1.0}, []types.Throttle{0.9, 0.6, 0.3}},
+			args:   args{-0.1},
+			want:   0.9,
+		},
+		{
+			name:   "Negative steering",
+			fields: fields{[]types.Steering{0.0, 0.5, 1.0}, []types.Throttle{0.9, 0.6, 0.1}},
+			args:   args{-0.2},
+			want:   0.9,
+		},
+		{
+			name:   "Negative Intermediate steering",
+			fields: fields{[]types.Steering{0.0, 0.5, 1.0}, []types.Throttle{0.9, 0.6, 0.1}},
+			args:   args{-0.5},
+			want:   0.6,
+		},
+		{
+			name:   "Minimum steering",
+			fields: fields{[]types.Steering{0.0, 0.5, 1.0}, []types.Throttle{0.9, 0.6, 0.1}},
+			args:   args{-1.0},
+			want:   0.1,
+		},
+		{
+			name:   "Negative Over steering",
+			fields: fields{[]types.Steering{0.0, 0.5, 1.0}, []types.Throttle{0.9, 0.6, 0.1}},
+			args:   args{-1.1},
+			want:   0.1,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tc := &Config{
+				SteeringValues: tt.fields.SteeringValue,
+				ThrottleSteps:  tt.fields.Data,
+			}
+			if got := tc.ValueOf(tt.args.s); got != tt.want {
+				t.Errorf("ValueOf() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestNewConfigFromJson(t *testing.T) {
+	type args struct {
+		configContent string
+	}
+
+	tests := []struct {
+		name    string
+		args    args
+		want    *Config
+		wantErr bool
+	}{
+		{
+			name: "default",
+			args: args{
+				configContent: `{
+	"steering_values": [0.0, 0.5, 1.0],
+	"throttle_steps": [0.9, 0.6, 0.1]
+}
+`,
+			},
+			want: &Config{
+				SteeringValues: []types.Steering{0., 0.5, 1.},
+				ThrottleSteps:  []types.Throttle{0.9, 0.6, 0.1},
+			},
+		},
+		{
+			name: "invalid config",
+			args: args{
+				configContent: `{ "steering_values" }`,
+			},
+			want:    &emptyConfig,
+			wantErr: true,
+		},
+		{
+			name: "empty config",
+			args: args{
+				configContent: `{
+	"steering_values": [],
+	"throttle_steps": []
+}`,
+			},
+			want:    &emptyConfig,
+			wantErr: true,
+		},
+		{
+			name: "incoherent config",
+			args: args{
+				configContent: `{
+	"steering_values": [0.0, 0.5, 1.0],
+	"throttle_steps": [0.9, 0.1]
+}`,
+			},
+			want:    &emptyConfig,
+			wantErr: true,
+		},
+		{
+			name: "steering in bad order",
+			args: args{
+				configContent: `{
+	"steering_values": [0.0, 0.6, 0.5],
+	"throttle_steps": [0.9, 0.5, 0.1]
+}`,
+			},
+			want:    &emptyConfig,
+			wantErr: true,
+		},
+		{
+			name: "throttle in bad order",
+			args: args{
+				configContent: `{
+	"steering_values": [0.0, 0.5, 0.9],
+	"throttle_steps": [0.4, 0.5, 0.1]
+}`,
+			},
+			want:    &emptyConfig,
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			configName := path.Join(t.TempDir(), "config.json")
+			err := os.WriteFile(configName, []byte(tt.args.configContent), 0644)
+			if err != nil {
+				t.Errorf("unable to create test config: %v", err)
+			}
+			got, err := NewConfigFromJson(configName)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("NewConfigFromJson() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("NewConfigFromJson() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

pkg/types/types.go

@@ -0,0 +1,5 @@
+package types
+
+type Throttle float32
+
+type Steering float32

vendor/github.com/cyrilix/robocar-protobuf/go/events/events.pb.go

@@ -21,6 +21,58 @@ const (
 	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
 )
 
+type SpeedZone int32
+
+const (
+	SpeedZone_UNKNOWN SpeedZone = 0
+	SpeedZone_SLOW    SpeedZone = 1
+	SpeedZone_NORMAL  SpeedZone = 2
+	SpeedZone_FAST    SpeedZone = 3
+)
+
+// Enum value maps for SpeedZone.
+var (
+	SpeedZone_name = map[int32]string{
+		0: "UNKNOWN",
+		1: "SLOW",
+		2: "NORMAL",
+		3: "FAST",
+	}
+	SpeedZone_value = map[string]int32{
+		"UNKNOWN": 0,
+		"SLOW":    1,
+		"NORMAL":  2,
+		"FAST":    3,
+	}
+)
+
+func (x SpeedZone) Enum() *SpeedZone {
+	p := new(SpeedZone)
+	*p = x
+	return p
+}
+
+func (x SpeedZone) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (SpeedZone) Descriptor() protoreflect.EnumDescriptor {
+	return file_events_events_proto_enumTypes[0].Descriptor()
+}
+
+func (SpeedZone) Type() protoreflect.EnumType {
+	return &file_events_events_proto_enumTypes[0]
+}
+
+func (x SpeedZone) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use SpeedZone.Descriptor instead.
+func (SpeedZone) EnumDescriptor() ([]byte, []int) {
+	return file_events_events_proto_rawDescGZIP(), []int{0}
+}
+
 type DriveMode int32
 
 const (
@@ -54,11 +106,11 @@ func (x DriveMode) String() string {
 }
 
 func (DriveMode) Descriptor() protoreflect.EnumDescriptor {
-	return file_events_events_proto_enumTypes[0].Descriptor()
+	return file_events_events_proto_enumTypes[1].Descriptor()
 }
 
 func (DriveMode) Type() protoreflect.EnumType {
-	return &file_events_events_proto_enumTypes[0]
+	return &file_events_events_proto_enumTypes[1]
 }
 
 func (x DriveMode) Number() protoreflect.EnumNumber {
@@ -67,7 +119,7 @@ func (x DriveMode) Number() protoreflect.EnumNumber {
 
 // Deprecated: Use DriveMode.Descriptor instead.
 func (DriveMode) EnumDescriptor() ([]byte, []int) {
-	return file_events_events_proto_rawDescGZIP(), []int{0}
+	return file_events_events_proto_rawDescGZIP(), []int{1}
 }
 
 type TypeObject int32
@@ -106,11 +158,11 @@ func (x TypeObject) String() string {
 }
 
 func (TypeObject) Descriptor() protoreflect.EnumDescriptor {
-	return file_events_events_proto_enumTypes[1].Descriptor()
+	return file_events_events_proto_enumTypes[2].Descriptor()
 }
 
 func (TypeObject) Type() protoreflect.EnumType {
-	return &file_events_events_proto_enumTypes[1]
+	return &file_events_events_proto_enumTypes[2]
 }
 
 func (x TypeObject) Number() protoreflect.EnumNumber {
@@ -119,7 +171,7 @@ func (x TypeObject) Number() protoreflect.EnumNumber {
 
 // Deprecated: Use TypeObject.Descriptor instead.
 func (TypeObject) EnumDescriptor() ([]byte, []int) {
-	return file_events_events_proto_rawDescGZIP(), []int{1}
+	return file_events_events_proto_rawDescGZIP(), []int{2}
 }
 
 type FrameRef struct {
@@ -366,6 +418,69 @@ func (x *ThrottleMessage) GetFrameRef() *FrameRef {
 	return nil
 }
 
+type SpeedZoneMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	SpeedZone  SpeedZone `protobuf:"varint,1,opt,name=speed_zone,json=speedZone,proto3,enum=robocar.events.SpeedZone" json:"speed_zone,omitempty"`
+	Confidence float32   `protobuf:"fixed32,2,opt,name=confidence,proto3" json:"confidence,omitempty"`
+	FrameRef   *FrameRef `protobuf:"bytes,3,opt,name=frame_ref,json=frameRef,proto3" json:"frame_ref,omitempty"`
+}
+
+func (x *SpeedZoneMessage) Reset() {
+	*x = SpeedZoneMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_events_events_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *SpeedZoneMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SpeedZoneMessage) ProtoMessage() {}
+
+func (x *SpeedZoneMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_events_events_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use SpeedZoneMessage.ProtoReflect.Descriptor instead.
+func (*SpeedZoneMessage) Descriptor() ([]byte, []int) {
+	return file_events_events_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *SpeedZoneMessage) GetSpeedZone() SpeedZone {
+	if x != nil {
+		return x.SpeedZone
+	}
+	return SpeedZone_UNKNOWN
+}
+
+func (x *SpeedZoneMessage) GetConfidence() float32 {
+	if x != nil {
+		return x.Confidence
+	}
+	return 0
+}
+
+func (x *SpeedZoneMessage) GetFrameRef() *FrameRef {
+	if x != nil {
+		return x.FrameRef
+	}
+	return nil
+}
+
 type DriveModeMessage struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -377,7 +492,7 @@ type DriveModeMessage struct {
 func (x *DriveModeMessage) Reset() {
 	*x = DriveModeMessage{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_events_events_proto_msgTypes[4]
+		mi := &file_events_events_proto_msgTypes[5]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -390,7 +505,7 @@ func (x *DriveModeMessage) String() string {
 func (*DriveModeMessage) ProtoMessage() {}
 
 func (x *DriveModeMessage) ProtoReflect() protoreflect.Message {
-	mi := &file_events_events_proto_msgTypes[4]
+	mi := &file_events_events_proto_msgTypes[5]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -403,7 +518,7 @@ func (x *DriveModeMessage) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use DriveModeMessage.ProtoReflect.Descriptor instead.
 func (*DriveModeMessage) Descriptor() ([]byte, []int) {
-	return file_events_events_proto_rawDescGZIP(), []int{4}
+	return file_events_events_proto_rawDescGZIP(), []int{5}
 }
 
 func (x *DriveModeMessage) GetDriveMode() DriveMode {
@@ -425,7 +540,7 @@ type ObjectsMessage struct {
 func (x *ObjectsMessage) Reset() {
 	*x = ObjectsMessage{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_events_events_proto_msgTypes[5]
+		mi := &file_events_events_proto_msgTypes[6]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -438,7 +553,7 @@ func (x *ObjectsMessage) String() string {
 func (*ObjectsMessage) ProtoMessage() {}
 
 func (x *ObjectsMessage) ProtoReflect() protoreflect.Message {
-	mi := &file_events_events_proto_msgTypes[5]
+	mi := &file_events_events_proto_msgTypes[6]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -451,7 +566,7 @@ func (x *ObjectsMessage) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ObjectsMessage.ProtoReflect.Descriptor instead.
 func (*ObjectsMessage) Descriptor() ([]byte, []int) {
-	return file_events_events_proto_rawDescGZIP(), []int{5}
+	return file_events_events_proto_rawDescGZIP(), []int{6}
 }
 
 func (x *ObjectsMessage) GetObjects() []*Object {
@@ -485,7 +600,7 @@ type Object struct {
 func (x *Object) Reset() {
 	*x = Object{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_events_events_proto_msgTypes[6]
+		mi := &file_events_events_proto_msgTypes[7]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -498,7 +613,7 @@ func (x *Object) String() string {
 func (*Object) ProtoMessage() {}
 
 func (x *Object) ProtoReflect() protoreflect.Message {
-	mi := &file_events_events_proto_msgTypes[6]
+	mi := &file_events_events_proto_msgTypes[7]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -511,7 +626,7 @@ func (x *Object) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use Object.ProtoReflect.Descriptor instead.
 func (*Object) Descriptor() ([]byte, []int) {
-	return file_events_events_proto_rawDescGZIP(), []int{6}
+	return file_events_events_proto_rawDescGZIP(), []int{7}
 }
 
 func (x *Object) GetType() TypeObject {
@@ -567,7 +682,7 @@ type SwitchRecordMessage struct {
 func (x *SwitchRecordMessage) Reset() {
 	*x = SwitchRecordMessage{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_events_events_proto_msgTypes[7]
+		mi := &file_events_events_proto_msgTypes[8]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -580,7 +695,7 @@ func (x *SwitchRecordMessage) String() string {
 func (*SwitchRecordMessage) ProtoMessage() {}
 
 func (x *SwitchRecordMessage) ProtoReflect() protoreflect.Message {
-	mi := &file_events_events_proto_msgTypes[7]
+	mi := &file_events_events_proto_msgTypes[8]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -593,7 +708,7 @@ func (x *SwitchRecordMessage) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SwitchRecordMessage.ProtoReflect.Descriptor instead.
 func (*SwitchRecordMessage) Descriptor() ([]byte, []int) {
-	return file_events_events_proto_rawDescGZIP(), []int{7}
+	return file_events_events_proto_rawDescGZIP(), []int{8}
 }
 
 func (x *SwitchRecordMessage) GetEnabled() bool {
@@ -617,7 +732,7 @@ type RoadMessage struct {
 func (x *RoadMessage) Reset() {
 	*x = RoadMessage{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_events_events_proto_msgTypes[8]
+		mi := &file_events_events_proto_msgTypes[9]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -630,7 +745,7 @@ func (x *RoadMessage) String() string {
 func (*RoadMessage) ProtoMessage() {}
 
 func (x *RoadMessage) ProtoReflect() protoreflect.Message {
-	mi := &file_events_events_proto_msgTypes[8]
+	mi := &file_events_events_proto_msgTypes[9]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -643,7 +758,7 @@ func (x *RoadMessage) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use RoadMessage.ProtoReflect.Descriptor instead.
 func (*RoadMessage) Descriptor() ([]byte, []int) {
-	return file_events_events_proto_rawDescGZIP(), []int{8}
+	return file_events_events_proto_rawDescGZIP(), []int{9}
 }
 
 func (x *RoadMessage) GetContour() []*Point {
@@ -679,7 +794,7 @@ type Point struct {
 func (x *Point) Reset() {
 	*x = Point{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_events_events_proto_msgTypes[9]
+		mi := &file_events_events_proto_msgTypes[10]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -692,7 +807,7 @@ func (x *Point) String() string {
 func (*Point) ProtoMessage() {}
 
 func (x *Point) ProtoReflect() protoreflect.Message {
-	mi := &file_events_events_proto_msgTypes[9]
+	mi := &file_events_events_proto_msgTypes[10]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -705,7 +820,7 @@ func (x *Point) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use Point.ProtoReflect.Descriptor instead.
 func (*Point) Descriptor() ([]byte, []int) {
-	return file_events_events_proto_rawDescGZIP(), []int{9}
+	return file_events_events_proto_rawDescGZIP(), []int{10}
 }
 
 func (x *Point) GetX() int32 {
@@ -737,7 +852,7 @@ type Ellipse struct {
 func (x *Ellipse) Reset() {
 	*x = Ellipse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_events_events_proto_msgTypes[10]
+		mi := &file_events_events_proto_msgTypes[11]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -750,7 +865,7 @@ func (x *Ellipse) String() string {
 func (*Ellipse) ProtoMessage() {}
 
 func (x *Ellipse) ProtoReflect() protoreflect.Message {
-	mi := &file_events_events_proto_msgTypes[10]
+	mi := &file_events_events_proto_msgTypes[11]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -763,7 +878,7 @@ func (x *Ellipse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use Ellipse.ProtoReflect.Descriptor instead.
 func (*Ellipse) Descriptor() ([]byte, []int) {
-	return file_events_events_proto_rawDescGZIP(), []int{10}
+	return file_events_events_proto_rawDescGZIP(), []int{11}
 }
 
 func (x *Ellipse) GetCenter() *Point {
@@ -807,15 +922,17 @@ type RecordMessage struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Frame     *FrameMessage    `protobuf:"bytes,1,opt,name=frame,proto3" json:"frame,omitempty"`
+	Frame             *FrameMessage     `protobuf:"bytes,1,opt,name=frame,proto3" json:"frame,omitempty"`
-	Steering  *SteeringMessage `protobuf:"bytes,2,opt,name=steering,proto3" json:"steering,omitempty"`
+	Steering          *SteeringMessage  `protobuf:"bytes,2,opt,name=steering,proto3" json:"steering,omitempty"`
-	RecordSet string           `protobuf:"bytes,3,opt,name=recordSet,proto3" json:"recordSet,omitempty"` // Record set name
+	AutopilotSteering *SteeringMessage  `protobuf:"bytes,4,opt,name=autopilot_steering,json=autopilotSteering,proto3" json:"autopilot_steering,omitempty"`
+	DriveMode         *DriveModeMessage `protobuf:"bytes,5,opt,name=drive_mode,json=driveMode,proto3" json:"drive_mode,omitempty"`
+	RecordSet         string            `protobuf:"bytes,3,opt,name=recordSet,proto3" json:"recordSet,omitempty"` // Record set name
 }
 
 func (x *RecordMessage) Reset() {
 	*x = RecordMessage{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_events_events_proto_msgTypes[11]
+		mi := &file_events_events_proto_msgTypes[12]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -828,7 +945,7 @@ func (x *RecordMessage) String() string {
 func (*RecordMessage) ProtoMessage() {}
 
 func (x *RecordMessage) ProtoReflect() protoreflect.Message {
-	mi := &file_events_events_proto_msgTypes[11]
+	mi := &file_events_events_proto_msgTypes[12]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -841,7 +958,7 @@ func (x *RecordMessage) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use RecordMessage.ProtoReflect.Descriptor instead.
 func (*RecordMessage) Descriptor() ([]byte, []int) {
-	return file_events_events_proto_rawDescGZIP(), []int{11}
+	return file_events_events_proto_rawDescGZIP(), []int{12}
 }
 
 func (x *RecordMessage) GetFrame() *FrameMessage {
@@ -858,6 +975,20 @@ func (x *RecordMessage) GetSteering() *SteeringMessage {
 	return nil
 }
 
+func (x *RecordMessage) GetAutopilotSteering() *SteeringMessage {
+	if x != nil {
+		return x.AutopilotSteering
+	}
+	return nil
+}
+
+func (x *RecordMessage) GetDriveMode() *DriveModeMessage {
+	if x != nil {
+		return x.DriveMode
+	}
+	return nil
+}
+
 func (x *RecordMessage) GetRecordSet() string {
 	if x != nil {
 		return x.RecordSet
@@ -901,73 +1032,96 @@ var file_events_events_proto_rawDesc = []byte{
 	0x65, 0x5f, 0x72, 0x65, 0x66, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x72, 0x6f,
 	0x62, 0x6f, 0x63, 0x61, 0x72, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x46, 0x72, 0x61,
 	0x6d, 0x65, 0x52, 0x65, 0x66, 0x52, 0x08, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x66, 0x22,
-	0x4c, 0x0a, 0x10, 0x44, 0x72, 0x69, 0x76, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x73, 0x73,
+	0xa3, 0x01, 0x0a, 0x10, 0x53, 0x70, 0x65, 0x65, 0x64, 0x5a, 0x6f, 0x6e, 0x65, 0x4d, 0x65, 0x73,
-	0x61, 0x67, 0x65, 0x12, 0x38, 0x0a, 0x0a, 0x64, 0x72, 0x69, 0x76, 0x65, 0x5f, 0x6d, 0x6f, 0x64,
+	0x73, 0x61, 0x67, 0x65, 0x12, 0x38, 0x0a, 0x0a, 0x73, 0x70, 0x65, 0x65, 0x64, 0x5f, 0x7a, 0x6f,
-	0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x19, 0x2e, 0x72, 0x6f, 0x62, 0x6f, 0x63, 0x61,
+	0x6e, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x19, 0x2e, 0x72, 0x6f, 0x62, 0x6f, 0x63,
-	0x72, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x44, 0x72, 0x69, 0x76, 0x65, 0x4d, 0x6f,
+	0x61, 0x72, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x53, 0x70, 0x65, 0x65, 0x64, 0x5a,
-	0x64, 0x65, 0x52, 0x09, 0x64, 0x72, 0x69, 0x76, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x22, 0x79, 0x0a,
+	0x6f, 0x6e, 0x65, 0x52, 0x09, 0x73, 0x70, 0x65, 0x65, 0x64, 0x5a, 0x6f, 0x6e, 0x65, 0x12, 0x1e,
-	0x0e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12,
+	0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01,
-	0x30, 0x0a, 0x07, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b,
+	0x28, 0x02, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x35,
-	0x32, 0x16, 0x2e, 0x72, 0x6f, 0x62, 0x6f, 0x63, 0x61, 0x72, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74,
+	0x0a, 0x09, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x5f, 0x72, 0x65, 0x66, 0x18, 0x03, 0x20, 0x01, 0x28,
-	0x73, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x07, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74,
+	0x0b, 0x32, 0x18, 0x2e, 0x72, 0x6f, 0x62, 0x6f, 0x63, 0x61, 0x72, 0x2e, 0x65, 0x76, 0x65, 0x6e,
-	0x73, 0x12, 0x35, 0x0a, 0x09, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x5f, 0x72, 0x65, 0x66, 0x18, 0x02,
+	0x74, 0x73, 0x2e, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x66, 0x52, 0x08, 0x66, 0x72, 0x61,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x72, 0x6f, 0x62, 0x6f, 0x63, 0x61, 0x72, 0x2e, 0x65,
+	0x6d, 0x65, 0x52, 0x65, 0x66, 0x22, 0x4c, 0x0a, 0x10, 0x44, 0x72, 0x69, 0x76, 0x65, 0x4d, 0x6f,
-	0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x66, 0x52, 0x08,
+	0x64, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x38, 0x0a, 0x0a, 0x64, 0x72, 0x69,
-	0x66, 0x72, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x66, 0x22, 0xac, 0x01, 0x0a, 0x06, 0x4f, 0x62, 0x6a,
+	0x76, 0x65, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x19, 0x2e,
-	0x65, 0x63, 0x74, 0x12, 0x2e, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x72, 0x6f, 0x62, 0x6f, 0x63, 0x61, 0x72, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x44,
-	0x0e, 0x32, 0x1a, 0x2e, 0x72, 0x6f, 0x62, 0x6f, 0x63, 0x61, 0x72, 0x2e, 0x65, 0x76, 0x65, 0x6e,
+	0x72, 0x69, 0x76, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x52, 0x09, 0x64, 0x72, 0x69, 0x76, 0x65, 0x4d,
-	0x74, 0x73, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x04, 0x74,
+	0x6f, 0x64, 0x65, 0x22, 0x79, 0x0a, 0x0e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x4d, 0x65,
-	0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6c, 0x65, 0x66, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x07, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73,
-	0x02, 0x52, 0x04, 0x6c, 0x65, 0x66, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x74, 0x6f, 0x70, 0x18, 0x03,
+	0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x72, 0x6f, 0x62, 0x6f, 0x63, 0x61, 0x72,
-	0x20, 0x01, 0x28, 0x02, 0x52, 0x03, 0x74, 0x6f, 0x70, 0x12, 0x14, 0x0a, 0x05, 0x72, 0x69, 0x67,
+	0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x07,
-	0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x02, 0x52, 0x05, 0x72, 0x69, 0x67, 0x68, 0x74, 0x12,
+	0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x35, 0x0a, 0x09, 0x66, 0x72, 0x61, 0x6d, 0x65,
-	0x16, 0x0a, 0x06, 0x62, 0x6f, 0x74, 0x74, 0x6f, 0x6d, 0x18, 0x05, 0x20, 0x01, 0x28, 0x02, 0x52,
+	0x5f, 0x72, 0x65, 0x66, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x72, 0x6f, 0x62,
-	0x06, 0x62, 0x6f, 0x74, 0x74, 0x6f, 0x6d, 0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x66, 0x69,
+	0x6f, 0x63, 0x61, 0x72, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x46, 0x72, 0x61, 0x6d,
-	0x64, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x63, 0x6f, 0x6e,
+	0x65, 0x52, 0x65, 0x66, 0x52, 0x08, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x66, 0x22, 0xac,
-	0x66, 0x69, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x22, 0x2f, 0x0a, 0x13, 0x53, 0x77, 0x69, 0x74, 0x63,
+	0x01, 0x0a, 0x06, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x2e, 0x0a, 0x04, 0x74, 0x79, 0x70,
-	0x68, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x18,
+	0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x72, 0x6f, 0x62, 0x6f, 0x63, 0x61,
-	0x0a, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x72, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x4f, 0x62, 0x6a,
-	0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x22, 0xa8, 0x01, 0x0a, 0x0b, 0x52, 0x6f, 0x61,
+	0x65, 0x63, 0x74, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6c, 0x65, 0x66,
-	0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x2f, 0x0a, 0x07, 0x63, 0x6f, 0x6e, 0x74,
+	0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x02, 0x52, 0x04, 0x6c, 0x65, 0x66, 0x74, 0x12, 0x10, 0x0a,
-	0x6f, 0x75, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x72, 0x6f, 0x62, 0x6f,
+	0x03, 0x74, 0x6f, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x02, 0x52, 0x03, 0x74, 0x6f, 0x70, 0x12,
-	0x63, 0x61, 0x72, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x50, 0x6f, 0x69, 0x6e, 0x74,
+	0x14, 0x0a, 0x05, 0x72, 0x69, 0x67, 0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x02, 0x52, 0x05,
-	0x52, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x6f, 0x75, 0x72, 0x12, 0x31, 0x0a, 0x07, 0x65, 0x6c, 0x6c,
+	0x72, 0x69, 0x67, 0x68, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x62, 0x6f, 0x74, 0x74, 0x6f, 0x6d, 0x18,
-	0x69, 0x70, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x72, 0x6f, 0x62,
+	0x05, 0x20, 0x01, 0x28, 0x02, 0x52, 0x06, 0x62, 0x6f, 0x74, 0x74, 0x6f, 0x6d, 0x12, 0x1e, 0x0a,
-	0x6f, 0x63, 0x61, 0x72, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x45, 0x6c, 0x6c, 0x69,
+	0x0a, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28,
-	0x70, 0x73, 0x65, 0x52, 0x07, 0x65, 0x6c, 0x6c, 0x69, 0x70, 0x73, 0x65, 0x12, 0x35, 0x0a, 0x09,
+	0x02, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x22, 0x2f, 0x0a,
-	0x66, 0x72, 0x61, 0x6d, 0x65, 0x5f, 0x72, 0x65, 0x66, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x13, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x4d, 0x65, 0x73,
-	0x18, 0x2e, 0x72, 0x6f, 0x62, 0x6f, 0x63, 0x61, 0x72, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18,
-	0x2e, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x66, 0x52, 0x08, 0x66, 0x72, 0x61, 0x6d, 0x65,
+	0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x22, 0xa8,
-	0x52, 0x65, 0x66, 0x22, 0x23, 0x0a, 0x05, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x0c, 0x0a, 0x01,
+	0x01, 0x0a, 0x0b, 0x52, 0x6f, 0x61, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x2f,
-	0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x78, 0x12, 0x0c, 0x0a, 0x01, 0x79, 0x18,
+	0x0a, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x6f, 0x75, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
-	0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x79, 0x22, 0x9c, 0x01, 0x0a, 0x07, 0x45, 0x6c, 0x6c,
+	0x15, 0x2e, 0x72, 0x6f, 0x62, 0x6f, 0x63, 0x61, 0x72, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73,
-	0x69, 0x70, 0x73, 0x65, 0x12, 0x2d, 0x0a, 0x06, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x18, 0x01,
+	0x2e, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x6f, 0x75, 0x72, 0x12,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x72, 0x6f, 0x62, 0x6f, 0x63, 0x61, 0x72, 0x2e, 0x65,
+	0x31, 0x0a, 0x07, 0x65, 0x6c, 0x6c, 0x69, 0x70, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
-	0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x06, 0x63, 0x65, 0x6e,
+	0x32, 0x17, 0x2e, 0x72, 0x6f, 0x62, 0x6f, 0x63, 0x61, 0x72, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74,
-	0x74, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x77, 0x69, 0x64, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01,
+	0x73, 0x2e, 0x45, 0x6c, 0x6c, 0x69, 0x70, 0x73, 0x65, 0x52, 0x07, 0x65, 0x6c, 0x6c, 0x69, 0x70,
-	0x28, 0x05, 0x52, 0x05, 0x77, 0x69, 0x64, 0x74, 0x68, 0x12, 0x16, 0x0a, 0x06, 0x68, 0x65, 0x69,
+	0x73, 0x65, 0x12, 0x35, 0x0a, 0x09, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x5f, 0x72, 0x65, 0x66, 0x18,
-	0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68,
+	0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x72, 0x6f, 0x62, 0x6f, 0x63, 0x61, 0x72, 0x2e,
-	0x74, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x6e, 0x67, 0x6c, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x02,
+	0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x66, 0x52,
-	0x52, 0x05, 0x61, 0x6e, 0x67, 0x6c, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x66, 0x69,
+	0x08, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x66, 0x22, 0x23, 0x0a, 0x05, 0x50, 0x6f, 0x69,
-	0x64, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x63, 0x6f, 0x6e,
+	0x6e, 0x74, 0x12, 0x0c, 0x0a, 0x01, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x78,
-	0x66, 0x69, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x22, 0x9e, 0x01, 0x0a, 0x0d, 0x52, 0x65, 0x63, 0x6f,
+	0x12, 0x0c, 0x0a, 0x01, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x79, 0x22, 0x9c,
-	0x72, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x32, 0x0a, 0x05, 0x66, 0x72, 0x61,
+	0x01, 0x0a, 0x07, 0x45, 0x6c, 0x6c, 0x69, 0x70, 0x73, 0x65, 0x12, 0x2d, 0x0a, 0x06, 0x63, 0x65,
-	0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x72, 0x6f, 0x62, 0x6f, 0x63,
+	0x6e, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x72, 0x6f, 0x62,
-	0x61, 0x72, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x4d,
+	0x6f, 0x63, 0x61, 0x72, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x50, 0x6f, 0x69, 0x6e,
-	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x05, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x12, 0x3b, 0x0a,
+	0x74, 0x52, 0x06, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x77, 0x69, 0x64,
-	0x08, 0x73, 0x74, 0x65, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x77, 0x69, 0x64, 0x74, 0x68, 0x12,
-	0x1f, 0x2e, 0x72, 0x6f, 0x62, 0x6f, 0x63, 0x61, 0x72, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73,
+	0x16, 0x0a, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52,
-	0x2e, 0x53, 0x74, 0x65, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x6e, 0x67, 0x6c, 0x65,
-	0x52, 0x08, 0x73, 0x74, 0x65, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x1c, 0x0a, 0x09, 0x72, 0x65,
+	0x18, 0x04, 0x20, 0x01, 0x28, 0x02, 0x52, 0x05, 0x61, 0x6e, 0x67, 0x6c, 0x65, 0x12, 0x1e, 0x0a,
-	0x63, 0x6f, 0x72, 0x64, 0x53, 0x65, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x72,
+	0x0a, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28,
-	0x65, 0x63, 0x6f, 0x72, 0x64, 0x53, 0x65, 0x74, 0x2a, 0x2d, 0x0a, 0x09, 0x44, 0x72, 0x69, 0x76,
+	0x02, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x22, 0xaf, 0x02,
-	0x65, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44,
+	0x0a, 0x0d, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12,
-	0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x55, 0x53, 0x45, 0x52, 0x10, 0x01, 0x12, 0x09, 0x0a, 0x05,
+	0x32, 0x0a, 0x05, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c,
-	0x50, 0x49, 0x4c, 0x4f, 0x54, 0x10, 0x02, 0x2a, 0x32, 0x0a, 0x0a, 0x54, 0x79, 0x70, 0x65, 0x4f,
+	0x2e, 0x72, 0x6f, 0x62, 0x6f, 0x63, 0x61, 0x72, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e,
-	0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x07, 0x0a, 0x03, 0x41, 0x4e, 0x59, 0x10, 0x00, 0x12, 0x07,
+	0x46, 0x72, 0x61, 0x6d, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x05, 0x66, 0x72,
-	0x0a, 0x03, 0x43, 0x41, 0x52, 0x10, 0x01, 0x12, 0x08, 0x0a, 0x04, 0x42, 0x55, 0x4d, 0x50, 0x10,
+	0x61, 0x6d, 0x65, 0x12, 0x3b, 0x0a, 0x08, 0x73, 0x74, 0x65, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x18,
-	0x02, 0x12, 0x08, 0x0a, 0x04, 0x50, 0x4c, 0x4f, 0x54, 0x10, 0x03, 0x42, 0x0a, 0x5a, 0x08, 0x2e,
+	0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x6f, 0x62, 0x6f, 0x63, 0x61, 0x72, 0x2e,
-	0x2f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x53, 0x74, 0x65, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x08, 0x73, 0x74, 0x65, 0x65, 0x72, 0x69, 0x6e, 0x67,
+	0x12, 0x4e, 0x0a, 0x12, 0x61, 0x75, 0x74, 0x6f, 0x70, 0x69, 0x6c, 0x6f, 0x74, 0x5f, 0x73, 0x74,
+	0x65, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72,
+	0x6f, 0x62, 0x6f, 0x63, 0x61, 0x72, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x53, 0x74,
+	0x65, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x11, 0x61,
+	0x75, 0x74, 0x6f, 0x70, 0x69, 0x6c, 0x6f, 0x74, 0x53, 0x74, 0x65, 0x65, 0x72, 0x69, 0x6e, 0x67,
+	0x12, 0x3f, 0x0a, 0x0a, 0x64, 0x72, 0x69, 0x76, 0x65, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x6f, 0x62, 0x6f, 0x63, 0x61, 0x72, 0x2e, 0x65,
+	0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x44, 0x72, 0x69, 0x76, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x09, 0x64, 0x72, 0x69, 0x76, 0x65, 0x4d, 0x6f, 0x64,
+	0x65, 0x12, 0x1c, 0x0a, 0x09, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x53, 0x65, 0x74, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x53, 0x65, 0x74, 0x2a,
+	0x38, 0x0a, 0x09, 0x53, 0x70, 0x65, 0x65, 0x64, 0x5a, 0x6f, 0x6e, 0x65, 0x12, 0x0b, 0x0a, 0x07,
+	0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x53, 0x4c, 0x4f,
+	0x57, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x4e, 0x4f, 0x52, 0x4d, 0x41, 0x4c, 0x10, 0x02, 0x12,
+	0x08, 0x0a, 0x04, 0x46, 0x41, 0x53, 0x54, 0x10, 0x03, 0x2a, 0x2d, 0x0a, 0x09, 0x44, 0x72, 0x69,
+	0x76, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49,
+	0x44, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x55, 0x53, 0x45, 0x52, 0x10, 0x01, 0x12, 0x09, 0x0a,
+	0x05, 0x50, 0x49, 0x4c, 0x4f, 0x54, 0x10, 0x02, 0x2a, 0x32, 0x0a, 0x0a, 0x54, 0x79, 0x70, 0x65,
+	0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x07, 0x0a, 0x03, 0x41, 0x4e, 0x59, 0x10, 0x00, 0x12,
+	0x07, 0x0a, 0x03, 0x43, 0x41, 0x52, 0x10, 0x01, 0x12, 0x08, 0x0a, 0x04, 0x42, 0x55, 0x4d, 0x50,
+	0x10, 0x02, 0x12, 0x08, 0x0a, 0x04, 0x50, 0x4c, 0x4f, 0x54, 0x10, 0x03, 0x42, 0x0a, 0x5a, 0x08,
+	0x2e, 0x2f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -982,45 +1136,51 @@ func file_events_events_proto_rawDescGZIP() []byte {
 	return file_events_events_proto_rawDescData
 }
 
-var file_events_events_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
+var file_events_events_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
-var file_events_events_proto_msgTypes = make([]protoimpl.MessageInfo, 12)
+var file_events_events_proto_msgTypes = make([]protoimpl.MessageInfo, 13)
 var file_events_events_proto_goTypes = []interface{}{
-	(DriveMode)(0),              // 0: robocar.events.DriveMode
+	(SpeedZone)(0),              // 0: robocar.events.SpeedZone
-	(TypeObject)(0),             // 1: robocar.events.TypeObject
+	(DriveMode)(0),              // 1: robocar.events.DriveMode
-	(*FrameRef)(nil),            // 2: robocar.events.FrameRef
+	(TypeObject)(0),             // 2: robocar.events.TypeObject
-	(*FrameMessage)(nil),        // 3: robocar.events.FrameMessage
+	(*FrameRef)(nil),            // 3: robocar.events.FrameRef
-	(*SteeringMessage)(nil),     // 4: robocar.events.SteeringMessage
+	(*FrameMessage)(nil),        // 4: robocar.events.FrameMessage
-	(*ThrottleMessage)(nil),     // 5: robocar.events.ThrottleMessage
+	(*SteeringMessage)(nil),     // 5: robocar.events.SteeringMessage
-	(*DriveModeMessage)(nil),    // 6: robocar.events.DriveModeMessage
+	(*ThrottleMessage)(nil),     // 6: robocar.events.ThrottleMessage
-	(*ObjectsMessage)(nil),      // 7: robocar.events.ObjectsMessage
+	(*SpeedZoneMessage)(nil),    // 7: robocar.events.SpeedZoneMessage
-	(*Object)(nil),              // 8: robocar.events.Object
+	(*DriveModeMessage)(nil),    // 8: robocar.events.DriveModeMessage
-	(*SwitchRecordMessage)(nil), // 9: robocar.events.SwitchRecordMessage
+	(*ObjectsMessage)(nil),      // 9: robocar.events.ObjectsMessage
-	(*RoadMessage)(nil),         // 10: robocar.events.RoadMessage
+	(*Object)(nil),              // 10: robocar.events.Object
-	(*Point)(nil),               // 11: robocar.events.Point
+	(*SwitchRecordMessage)(nil), // 11: robocar.events.SwitchRecordMessage
-	(*Ellipse)(nil),             // 12: robocar.events.Ellipse
+	(*RoadMessage)(nil),         // 12: robocar.events.RoadMessage
-	(*RecordMessage)(nil),       // 13: robocar.events.RecordMessage
+	(*Point)(nil),               // 13: robocar.events.Point
-	(*timestamp.Timestamp)(nil), // 14: google.protobuf.Timestamp
+	(*Ellipse)(nil),             // 14: robocar.events.Ellipse
+	(*RecordMessage)(nil),       // 15: robocar.events.RecordMessage
+	(*timestamp.Timestamp)(nil), // 16: google.protobuf.Timestamp
 }
 var file_events_events_proto_depIdxs = []int32{
-	14, // 0: robocar.events.FrameRef.created_at:type_name -> google.protobuf.Timestamp
+	16, // 0: robocar.events.FrameRef.created_at:type_name -> google.protobuf.Timestamp
-	2,  // 1: robocar.events.FrameMessage.id:type_name -> robocar.events.FrameRef
+	3,  // 1: robocar.events.FrameMessage.id:type_name -> robocar.events.FrameRef
-	2,  // 2: robocar.events.SteeringMessage.frame_ref:type_name -> robocar.events.FrameRef
+	3,  // 2: robocar.events.SteeringMessage.frame_ref:type_name -> robocar.events.FrameRef
-	2,  // 3: robocar.events.ThrottleMessage.frame_ref:type_name -> robocar.events.FrameRef
+	3,  // 3: robocar.events.ThrottleMessage.frame_ref:type_name -> robocar.events.FrameRef
-	0,  // 4: robocar.events.DriveModeMessage.drive_mode:type_name -> robocar.events.DriveMode
+	0,  // 4: robocar.events.SpeedZoneMessage.speed_zone:type_name -> robocar.events.SpeedZone
-	8,  // 5: robocar.events.ObjectsMessage.objects:type_name -> robocar.events.Object
+	3,  // 5: robocar.events.SpeedZoneMessage.frame_ref:type_name -> robocar.events.FrameRef
-	2,  // 6: robocar.events.ObjectsMessage.frame_ref:type_name -> robocar.events.FrameRef
+	1,  // 6: robocar.events.DriveModeMessage.drive_mode:type_name -> robocar.events.DriveMode
-	1,  // 7: robocar.events.Object.type:type_name -> robocar.events.TypeObject
+	10, // 7: robocar.events.ObjectsMessage.objects:type_name -> robocar.events.Object
-	11, // 8: robocar.events.RoadMessage.contour:type_name -> robocar.events.Point
+	3,  // 8: robocar.events.ObjectsMessage.frame_ref:type_name -> robocar.events.FrameRef
-	12, // 9: robocar.events.RoadMessage.ellipse:type_name -> robocar.events.Ellipse
+	2,  // 9: robocar.events.Object.type:type_name -> robocar.events.TypeObject
-	2,  // 10: robocar.events.RoadMessage.frame_ref:type_name -> robocar.events.FrameRef
+	13, // 10: robocar.events.RoadMessage.contour:type_name -> robocar.events.Point
-	11, // 11: robocar.events.Ellipse.center:type_name -> robocar.events.Point
+	14, // 11: robocar.events.RoadMessage.ellipse:type_name -> robocar.events.Ellipse
-	3,  // 12: robocar.events.RecordMessage.frame:type_name -> robocar.events.FrameMessage
+	3,  // 12: robocar.events.RoadMessage.frame_ref:type_name -> robocar.events.FrameRef
-	4,  // 13: robocar.events.RecordMessage.steering:type_name -> robocar.events.SteeringMessage
+	13, // 13: robocar.events.Ellipse.center:type_name -> robocar.events.Point
-	14, // [14:14] is the sub-list for method output_type
+	4,  // 14: robocar.events.RecordMessage.frame:type_name -> robocar.events.FrameMessage
-	14, // [14:14] is the sub-list for method input_type
+	5,  // 15: robocar.events.RecordMessage.steering:type_name -> robocar.events.SteeringMessage
-	14, // [14:14] is the sub-list for extension type_name
+	5,  // 16: robocar.events.RecordMessage.autopilot_steering:type_name -> robocar.events.SteeringMessage
-	14, // [14:14] is the sub-list for extension extendee
+	8,  // 17: robocar.events.RecordMessage.drive_mode:type_name -> robocar.events.DriveModeMessage
-	0,  // [0:14] is the sub-list for field type_name
+	18, // [18:18] is the sub-list for method output_type
+	18, // [18:18] is the sub-list for method input_type
+	18, // [18:18] is the sub-list for extension type_name
+	18, // [18:18] is the sub-list for extension extendee
+	0,  // [0:18] is the sub-list for field type_name
 }
 
 func init() { file_events_events_proto_init() }
@@ -1078,7 +1238,7 @@ func file_events_events_proto_init() {
 			}
 		}
 		file_events_events_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DriveModeMessage); i {
+			switch v := v.(*SpeedZoneMessage); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1090,7 +1250,7 @@ func file_events_events_proto_init() {
 			}
 		}
 		file_events_events_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ObjectsMessage); i {
+			switch v := v.(*DriveModeMessage); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1102,7 +1262,7 @@ func file_events_events_proto_init() {
 			}
 		}
 		file_events_events_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Object); i {
+			switch v := v.(*ObjectsMessage); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1114,7 +1274,7 @@ func file_events_events_proto_init() {
 			}
 		}
 		file_events_events_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SwitchRecordMessage); i {
+			switch v := v.(*Object); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1126,7 +1286,7 @@ func file_events_events_proto_init() {
 			}
 		}
 		file_events_events_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*RoadMessage); i {
+			switch v := v.(*SwitchRecordMessage); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1138,7 +1298,7 @@ func file_events_events_proto_init() {
 			}
 		}
 		file_events_events_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Point); i {
+			switch v := v.(*RoadMessage); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1150,7 +1310,7 @@ func file_events_events_proto_init() {
 			}
 		}
 		file_events_events_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Ellipse); i {
+			switch v := v.(*Point); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1162,6 +1322,18 @@ func file_events_events_proto_init() {
 			}
 		}
 		file_events_events_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Ellipse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_events_events_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*RecordMessage); i {
 			case 0:
 				return &v.state
@@ -1179,8 +1351,8 @@ func file_events_events_proto_init() {
 		File: protoimpl.DescBuilder{
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_events_events_proto_rawDesc,
-			NumEnums:      2,
+			NumEnums:      3,
-			NumMessages:   12,
+			NumMessages:   13,
 			NumExtensions: 0,
 			NumServices:   0,
 		},

vendor/modules.txt

@@ -3,7 +3,7 @@
 github.com/cyrilix/robocar-base/cli
 github.com/cyrilix/robocar-base/service
 github.com/cyrilix/robocar-base/testtools
-# github.com/cyrilix/robocar-protobuf/go v1.1.0
+# github.com/cyrilix/robocar-protobuf/go v1.3.0
 ## explicit; go 1.18
 github.com/cyrilix/robocar-protobuf/go/events
 # github.com/eclipse/paho.mqtt.golang v1.4.1