fix: compute duty with raw value in order to increase precision

build-docker.sh

@@ -27,7 +27,7 @@ image_build(){
 
   printf "\n\nBuild go binary %s\n\n" "${BINARY}.${binary_suffix}"
   mkdir -p build
-  CGO_ENABLED=0 GOOS=${GOOS} GOARCH=${GOARCH} GOARM=${GOARM} go build -mod vendor -a ${GOTAGS} -o "build/${BINARY}.${binary_suffix}" ./cmd/${BINARY}/
+  CGO_ENABLED=0 GOOS=${GOOS} GOARCH=${GOARCH} GOARM=${GOARM} go build -mod vendor ${GOTAGS} -o "build/${BINARY}.${binary_suffix}" ./cmd/${BINARY}/
 
   buildah --os "$GOOS" --arch "$GOARCH" $VARIANT  --name "$containerName" from gcr.io/distroless/static
   buildah config --user 1234 "$containerName"

cmd/rc-pca9685/rc-pca9685.go

@@ -22,8 +22,6 @@ const (
 
 	SteeringLeftPWM  = 1004
 	SteeringRightPWM = 1986
-
-	DefaultFrequency = 60 * physic.Hertz
 )
 
 var (
@@ -66,7 +64,7 @@ func main() {
 		zap.S().Warnf("unable to init steeringRightPWM arg: %v", err)
 	}
 
-	var updatePWMFrequency int
+	var updatePWMFrequency, pwmFreq int
 	if err := cli.SetIntDefaultValueFromEnv(&updatePWMFrequency, "UPDATE_PWM_FREQUENCY", 25); err != nil {
 		zap.S().Warnf("unable to init updatePWMFrequency arg: %v", err)
 	}
@@ -81,6 +79,7 @@ func main() {
 	flag.IntVar(&steeringLeftPWM, "steering-left-pwm", steeringLeftPWM, "Right left value for steering PWM, STEERING_LEFT_PWM env if args not set")
 	flag.IntVar(&steeringRightPWM, "steering-right-pwm", steeringRightPWM, "Right right value for steering PWM, STEERING_RIGHT_PWM env if args not set")
 	flag.IntVar(&steeringCenterPWM, "steering-center-pwm", steeringCenterPWM, "Center value for steering PWM, STEERING_CENTER_PWM env if args not set")
+	flag.IntVar(&pwmFreq, "pwm-freq", 60, "PWM frequency in Hz")
 	flag.IntVar(&updatePWMFrequency, "update-pwm-frequency", updatePWMFrequency, "Number of update values per seconds, UPDATE_PWM_FREQUENCY env if args not set")
 
 	logLevel := zap.LevelFlag("log", zap.InfoLevel, "log level")
@@ -109,7 +108,7 @@ func main() {
 	}
 	defer client.Disconnect(50)
 
-	freq := DefaultFrequency
+	freq := physic.Frequency(pwmFreq) * physic.Hertz
 
 	zap.S().Infof("throttle channel  : %v", throttleChannel)
 	zap.S().Infof("throttle frequency: %v", freq)
@@ -130,6 +129,7 @@ func main() {
 		throttleChannel,
 		actuator.PWM(throttleMinPWM), actuator.PWM(throttleMaxPWM), actuator.PWM(throttleStoppedPWM),
 		freq,
+		zap.S().With("actuator", "throttle"),
 	)
 	if err != nil {
 		zap.S().Panicf("unable to init throttle controller: %v", err)
@@ -140,6 +140,7 @@ func main() {
 		steeringChannel,
 		actuator.PWM(steeringLeftPWM), actuator.PWM(steeringRightPWM), actuator.PWM(steeringCenterPWM),
 		freq,
+		zap.S().With("actuator", "steering"),
 	)
 	if err != nil {
 		zap.S().Panicf("unable to init steering controller: %v", err)

pkg/actuator/pca9685.go

@@ -36,7 +36,7 @@ func NewDevice(freq physic.Frequency) *pca9685.Dev {
 	if err != nil {
 		zap.S().Fatalf("unable to NewDevice pca9685 bus: %v", err)
 	}
-	zap.S().Infof("set pwm frequency to %d", 60)
+	zap.S().Infof("set pwm frequency to %v", freq)
 	err = device.SetPwmFreq(freq)
 	if err != nil {
 		zap.S().Panicf("unable to set pwm frequency: %v", err)
@@ -45,27 +45,32 @@ func NewDevice(freq physic.Frequency) *pca9685.Dev {
 	return device
 }
 
-func convertToDuty(percent float32, freq physic.Frequency, centerPWM, minPWM, maxPWM PWM) (gpio.Duty, error) {
+func (c *Pca9685Controller) convertToDuty(percent float32) (gpio.Duty, error) {
 	// map absolute angle to angle that vehicle can implement.
-	pw := int(centerPWM)
+	pw := int(c.neutralPWM)
 	if percent > 0 {
-		pw = util.MapRange(float64(percent), 0, MaxPercent, float64(centerPWM), float64(maxPWM))
+		pw = util.MapRange(float64(percent), 0, MaxPercent, float64(c.neutralPWM), float64(c.maxPWM))
 	} else if percent < 0 {
-		pw = util.MapRange(float64(percent), MinPercent, 0, float64(minPWM), float64(centerPWM))
+		pw = util.MapRange(float64(percent), MinPercent, 0, float64(c.minPWM), float64(c.neutralPWM))
 	}
-	zap.S().Debugf("convert value %v to pw: %v", percent, pw)
+	c.logr.Debugf("convert value %v to pw: %v", percent, pw)
 
-	per := freq.Period().Microseconds()
+	per := c.freq.Period().Microseconds()
 
 	draw := float64(pw) / float64(per)
-	d, err := gpio.ParseDuty(fmt.Sprintf("%.f%%", draw*100))
-	if err != nil {
-		return 0, fmt.Errorf("unable to parse duty, probably bad compute: %w", err)
-	}
-	return d, nil
+	return gpio.Duty(int32(draw * float64(gpio.DutyMax))), nil
+	/*
+		d, err := gpio.ParseDuty(strconv.Itoa(int(dd)))
+		// d, err := gpio.ParseDuty(fmt.Sprintf("%.f%%", draw*100))
+		if err != nil {
+			return 0, fmt.Errorf("unable to parse duty, probably bad compute: %w", err)
+		}
+		return d, nil
+	*/
 }
 
 type Pca9685Controller struct {
+	logr                       *zap.SugaredLogger
 	pin                        gpio.PinIO
 	minPWM, maxPWM, neutralPWM PWM
 	freq                       physic.Frequency
@@ -76,6 +81,8 @@ func (c *Pca9685Controller) Close() error {
 }
 
 func (c *Pca9685Controller) SetDuty(d gpio.Duty) error {
+	c.logr.Debugf("set duty %v -> %d (12bits value: %d)", d.String(), d, d>>12)
+
 	err := c.pin.PWM(d, c.freq)
 	if err != nil {
 		return fmt.Errorf("unable to set pwm value: %v", err)
@@ -85,7 +92,7 @@ func (c *Pca9685Controller) SetDuty(d gpio.Duty) error {
 
 // SetPercentValue Set percent value
 func (c *Pca9685Controller) SetPercentValue(p float32) error {
-	d, err := convertToDuty(p, c.freq, c.neutralPWM, c.minPWM, c.maxPWM)
+	d, err := c.convertToDuty(p)
 	if err != nil {
 		return fmt.Errorf("unable to compute Duty value for steering: %w", err)
 	}
@@ -96,7 +103,7 @@ func (c *Pca9685Controller) SetPercentValue(p float32) error {
 	return nil
 }
 
-func NewPca9685Controller(device *pca9685.Dev, channel int, minPWM, maxPWM, neutralPWM PWM, freq physic.Frequency) (*Pca9685Controller, error) {
+func NewPca9685Controller(device *pca9685.Dev, channel int, minPWM, maxPWM, neutralPWM PWM, freq physic.Frequency, logr *zap.SugaredLogger) (*Pca9685Controller, error) {
 	p, err := device.CreatePin(channel)
 	if err != nil {
 		return nil, fmt.Errorf("unable to create pin for channel %v: %w", channel, err)
@@ -107,6 +114,7 @@ func NewPca9685Controller(device *pca9685.Dev, channel int, minPWM, maxPWM, neut
 		maxPWM:     maxPWM,
 		neutralPWM: neutralPWM,
 		freq:       freq,
+		logr:       logr,
 	}
 	return &s, nil
 }

pkg/actuator/pca9685_test.go

@@ -64,8 +64,16 @@ func Test_convertToDuty(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			c := Pca9685Controller{
+				logr:       zap.S(),
+				pin:        nil,
+				minPWM:     tt.args.leftPWM,
+				maxPWM:     tt.args.rightPWM,
+				neutralPWM: tt.args.centerPWM,
+				freq:       tt.args.freq,
+			}
 
-			if got, err := convertToDuty(tt.args.percent, tt.args.freq, tt.args.centerPWM, tt.args.leftPWM, tt.args.rightPWM); got.String() != tt.want {
+			if got, err := c.convertToDuty(tt.args.percent); got.String() != tt.want {
 				if tt.wantErr && err == nil {
 					t.Errorf("an error is expected")
 					return