pidctl: add support for float64

Author: ucirello

controller.go

@@ -67,7 +67,7 @@ func (p *Controller) init() {
 	})
 }
 
-// Accumulate updates the controller with the given process value since the last
+// Compute updates the controller with the given process value since the last
 // update. It returns the new output that should be used by the device to reach
 // the desired set point. Internally it assumes the duration between calls is
 // constant.

controller_float64.go

@@ -0,0 +1,82 @@
+/*
+Copyright 2024 github.com/ucirello and cirello.io
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package pidctl
+
+import (
+	"math/big"
+	"time"
+)
+
+// ControllerFloat64 implements a PID controller using float64 for inputs and
+// outputs.
+type ControllerFloat64 struct {
+	controller Controller
+}
+
+// NewControllerFloat64 creates a new PID controller using float64 for inputs
+// and outputs.
+func NewControllerFloat64(p, i, d, setpoint float64) *ControllerFloat64 {
+	c := &ControllerFloat64{
+		controller: Controller{
+			P:        ratFloat64(p),
+			I:        ratFloat64(i),
+			D:        ratFloat64(d),
+			Setpoint: ratFloat64(setpoint),
+		},
+	}
+	c.controller.init()
+	return c
+}
+
+// SetSetpoint changes the desired setpoint of the controller.
+func (c *ControllerFloat64) SetSetpoint(setpoint float64) *ControllerFloat64 {
+	c.controller.Setpoint = ratFloat64(setpoint)
+	return c
+}
+
+// SetMin changes the minimum output value of the controller.
+func (c *ControllerFloat64) SetMin(min float64) *ControllerFloat64 {
+	c.controller.Min = ratFloat64(min)
+	return c
+}
+
+// SetMax changes the maxium output value of the controller.
+func (c *ControllerFloat64) SetMax(max float64) *ControllerFloat64 {
+	c.controller.Max = ratFloat64(max)
+	return c
+}
+
+// Compute updates the controller with the given process value since the last
+// update. It returns the new output that should be used by the device to reach
+// the desired set point. Internally it assumes the duration between calls is
+// constant.
+func (c *ControllerFloat64) Compute(pv float64) float64 {
+	v, _ := c.controller.Compute(ratFloat64(pv)).Float64()
+	return v
+}
+
+// Accumulate updates the controller with the given process value and duration
+// since the last update. It returns the new output that should be used by the
+// device to reach the desired set point.
+func (c *ControllerFloat64) Accumulate(pv float64, deltaTime time.Duration) float64 {
+	v, _ := c.controller.Accumulate(ratFloat64(pv), deltaTime).Float64()
+	return v
+}
+
+func ratFloat64(i float64) *big.Rat {
+	return new(big.Rat).SetFloat64(i)
+}

controller_float64_test.go

@@ -0,0 +1,73 @@
+/*
+Copyright 2024 github.com/ucirello and cirello.io
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package pidctl
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"testing"
+	"text/tabwriter"
+)
+
+func TestControllerFloat64(t *testing.T) {
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			defer func() {
+				r := recover()
+				switch {
+				case r == nil:
+				case test.expectPanic && fmt.Sprintf("%T", r) == "*pidctl.MinMaxError":
+					t.Log("trapped:", r)
+				default:
+					panic(r)
+				}
+			}()
+			c := NewControllerFloat64(test.p, test.i, test.d, 0)
+
+			if test.min != 0 || test.max != 0 {
+				c.SetMin(test.min)
+				c.SetMax(test.max)
+			}
+
+			var buf bytes.Buffer
+			log := tabwriter.NewWriter(&buf, 8, 0, 1, ' ', 0)
+			fmt.Fprint(log, "\tcycle\tgot\texpected\tsetpoint\tinput\toutput\n")
+			for i, u := range test.steps {
+				if u.setpoint != 0 {
+					c.SetSetpoint(u.setpoint)
+				}
+				got := c.Accumulate(u.input, test.stepDuration)
+				roundedGot, roundedExpected := fmt.Sprintf("%0.3f", got), fmt.Sprintf("%0.3f", u.output)
+				msg := ""
+				if roundedGot != roundedExpected {
+					msg = "error"
+					t.Fail()
+				}
+				fmt.Fprintf(log, "%s\t%d\t%v\t%v\t%v\t%v\t%v\n", msg, i, roundedGot, roundedExpected, u.setpoint, u.input, u.output)
+			}
+			log.Flush()
+			scanner := bufio.NewScanner(&buf)
+			for scanner.Scan() {
+				t.Log(scanner.Text())
+			}
+			if err := scanner.Err(); err != nil {
+				panic(fmt.Sprint("reading table output:", err))
+			}
+		})
+	}
+}

controller_test.go

@@ -20,7 +20,6 @@ import (
 	"bufio"
 	"bytes"
 	"fmt"
-	"math/big"
 	"testing"
 	"text/tabwriter"
 	"time"
@@ -221,7 +220,3 @@ func TestController(t *testing.T) {
 		})
 	}
 }
-
-func ratFloat64(i float64) *big.Rat {
-	return new(big.Rat).SetFloat64(i)
-}

example_test.go

@@ -71,3 +71,46 @@ func Example() {
 	// 14s speed: 58.00 throttle: 4.00 (desired: 3.15)
 	// 15s speed: 60.00 throttle: 3.00 (desired: 2.75)
 }
+
+// A car whose PID controller is going to act to try to stabilize its
+// speed to the given setpoint (float64 version).
+func Example_float64() {
+	car := pidctl.NewControllerFloat64(
+		1.0/5, 1.0/100, 1.0/15,
+		60).          // target speed: 60 mph
+		SetMin(-0.5). // min acceleration rate: 0.5 mps
+		SetMax(5)     // max acceleration rate: 5 mps
+	speed := float64(20) // the car starts in motion. 20mph
+	const travel = 15 * time.Second
+	for i := time.Second; i <= travel; i += time.Second {
+		desiredThrottle := car.Compute(speed)
+		actualThrottle := math.Ceil(desiredThrottle)
+		fmt.Printf("%s speed: %.2f throttle: %.2f (desired: %.2f)\n", i, speed, actualThrottle, desiredThrottle)
+		speed += actualThrottle
+		switch i % 5 {
+		case 0:
+			// head wind starts strong: 2mps
+			speed -= 2
+		case 1:
+			// head wind ends weak: 1mps
+			speed -= 1
+		}
+	}
+
+	// Output:
+	// 1s speed: 20.00 throttle: 5.00 (desired: 5.00)
+	// 2s speed: 23.00 throttle: 5.00 (desired: 5.00)
+	// 3s speed: 26.00 throttle: 5.00 (desired: 5.00)
+	// 4s speed: 29.00 throttle: 5.00 (desired: 5.00)
+	// 5s speed: 32.00 throttle: 5.00 (desired: 5.00)
+	// 6s speed: 35.00 throttle: 5.00 (desired: 5.00)
+	// 7s speed: 38.00 throttle: 5.00 (desired: 5.00)
+	// 8s speed: 41.00 throttle: 5.00 (desired: 5.00)
+	// 9s speed: 44.00 throttle: 5.00 (desired: 5.00)
+	// 10s speed: 47.00 throttle: 5.00 (desired: 5.00)
+	// 11s speed: 50.00 throttle: 5.00 (desired: 4.55)
+	// 12s speed: 53.00 throttle: 5.00 (desired: 4.02)
+	// 13s speed: 56.00 throttle: 4.00 (desired: 3.46)
+	// 14s speed: 58.00 throttle: 4.00 (desired: 3.15)
+	// 15s speed: 60.00 throttle: 3.00 (desired: 2.75)
+}