WIP: Fix/linear pwm adjustment

fan2go.yaml

@@ -46,6 +46,13 @@ fans:
     # The curve ID (defined above) that should be used to determine the
     # speed of this fan
     curve: cpu_curve
+    # (Optional) The algorithm how the target speed, determined by the curve is approached.
+    # default: pid: uses the PID control algorithm with default tuning variables
+    # simple: together with pwmChangePerSecond, fan speeds will approach target value 
+    # with the given max speed. Default is 10
+    controlAlgorithm:
+      alg: simple
+      pwmChangePerSecond: 10
     # (Optional) Override for the lowest PWM value at which the
     # fan is able to maintain rotation if it was spinning previously.
     minPwm: 30

internal/backend.go

@@ -228,21 +228,28 @@ func initializeObjects(pers persistence.Persistence) map[fans.Fan]controller.Fan
 	for config, fan := range initializeFans(controllers) {
 		updateRate := configuration.CurrentConfig.ControllerAdjustmentTickRate
 
-		var pidLoop util.PidLoop
-		if config.ControlLoop != nil {
-			pidLoop = *util.NewPidLoop(
-				config.ControlLoop.P,
-				config.ControlLoop.I,
-				config.ControlLoop.D,
-			)
-		} else {
-			pidLoop = *util.NewPidLoop(
-				0.03,
-				0.002,
-				0.0005,
-			)
+		var pidLoop *util.PidLoop
+		var linearLoop *util.LinearLoop
+		if config.ControlAlgorithm.Alg == "pid" {
+
+			if config.ControlLoop != nil {
+				pidLoop = util.NewPidLoop(
+					config.ControlLoop.P,
+					config.ControlLoop.I,
+					config.ControlLoop.D,
+				)
+			} else {
+				pidLoop = util.NewPidLoop(
+					0.03,
+					0.002,
+					0.0005,
+				)
+			}
+		} else if config.ControlAlgorithm.Alg == "simple" {
+			linearLoop = util.NewLinearLoop(config.ControlAlgorithm.PwmChangePerSecond)
 		}
-		fanController := controller.NewFanController(pers, fan, pidLoop, updateRate)
+
+		fanController := controller.NewFanController(pers, fan, pidLoop, linearLoop, updateRate)
 		result[fan] = fanController
 	}
 

internal/configuration/config.go

@@ -95,7 +95,11 @@ func setDefaultValues() {
 	viper.SetDefault("ControllerAdjustmentTickRate", 200*time.Millisecond)
 
 	viper.SetDefault("sensors", []SensorConfig{})
-	viper.SetDefault("fans", []FanConfig{})
+	viper.SetDefault("fans", []FanConfig{
+		// the control algorithm is a string enum, so we have to set an explicit default,
+		// the rest are primitive types with a well-defined default value
+		{ControlAlgorithm: ControlAlgorithmConfig{Alg: "pid"}},
+	})
 }
 
 // DetectAndReadConfigFile detects the path of the first existing config file

internal/configuration/fans.go

@@ -8,13 +8,26 @@ type FanConfig struct {
 	// StartPwm defines the lowest PWM value where the fans are able to start spinning from a standstill
 	StartPwm *int `json:"startPwm,omitempty"`
 	// MaxPwm defines the highest PWM value that yields an RPM increase
-	MaxPwm      *int               `json:"maxPwm,omitempty"`
-	PwmMap      *map[int]int       `json:"pwmMap,omitempty"`
-	Curve       string             `json:"curve"`
-	HwMon       *HwMonFanConfig    `json:"hwMon,omitempty"`
-	File        *FileFanConfig     `json:"file,omitempty"`
-	Cmd         *CmdFanConfig      `json:"cmd,omitempty"`
-	ControlLoop *ControlLoopConfig `json:"controlLoop,omitempty"`
+	MaxPwm           *int                   `json:"maxPwm,omitempty"`
+	PwmMap           *map[int]int           `json:"pwmMap,omitempty"`
+	Curve            string                 `json:"curve"`
+	ControlAlgorithm ControlAlgorithmConfig `json:"controlAlgorithm,omitempty"`
+	HwMon            *HwMonFanConfig        `json:"hwMon,omitempty"`
+	File             *FileFanConfig         `json:"file,omitempty"`
+	Cmd              *CmdFanConfig          `json:"cmd,omitempty"`
+	ControlLoop      *ControlLoopConfig     `json:"controlLoop,omitempty"`
+}
+
+type ControlAlgorithm string
+
+const (
+	pid    ControlAlgorithm = "pid"
+	simple ControlAlgorithm = "simple"
+)
+
+type ControlAlgorithmConfig struct {
+	Alg                ControlAlgorithm `json:"alg,omitempty"`
+	PwmChangePerSecond int              `json:"pwmChangePerSecond,omitempty"`
 }
 
 type HwMonFanConfig struct {

internal/controller/controller.go

@@ -65,6 +65,8 @@ type PidFanController struct {
 	pwmMap map[int]int
 	// PID loop for the PWM control
 	pidLoop *util.PidLoop
+	// alternatively: linear loop for PWM control
+	linearLoop *util.LinearLoop
 
 	// offset applied to the actual minPwm of the fan to ensure "neverStops" constraint
 	minPwmOffset int
@@ -73,7 +75,8 @@ type PidFanController struct {
 func NewFanController(
 	persistence persistence.Persistence,
 	fan fans.Fan,
-	pidLoop util.PidLoop,
+	pidLoop *util.PidLoop,
+	linearLoop *util.LinearLoop,
 	updateRate time.Duration,
 ) FanController {
 	return &PidFanController{
@@ -83,7 +86,8 @@ func NewFanController(
 		updateRate:                  updateRate,
 		pwmValuesWithDistinctTarget: []int{},
 		pwmMap:                      map[int]int{},
-		pidLoop:                     &pidLoop,
+		pidLoop:                     pidLoop,
+		linearLoop:                  linearLoop,
 		minPwmOffset:                0,
 	}
 }
@@ -239,20 +243,35 @@ func (f *PidFanController) UpdateFanSpeed() error {
 	// calculate the direct optimal target speed
 	target := f.calculateTargetPwm()
 
-	// ask the PID controller how to proceed
-	pidChange := math.Ceil(f.pidLoop.Loop(float64(target), float64(lastSetPwm)))
+	// the target pwm, approaching the actual target smoothly
+	var stepTarget int
 
-	// the last value set on the pid controller target
-	pidControllerTarget := math.Ceil(f.pidLoop.Loop(float64(target), float64(lastSetPwm)))
-	pidControllerTarget = pidControllerTarget + pidChange
+	// default algorithm: use a pid controller alg to approach target
+	if fan.GetControlAlgorithm().Alg == "pid" {
+		// ask the PID controller how to proceed
+		pidChange := math.Ceil(f.pidLoop.Loop(float64(target), float64(lastSetPwm)))
 
-	// ensure we are within sane bounds
-	coerced := util.Coerce(float64(lastSetPwm)+pidControllerTarget, 0, 255)
-	roundedTarget := int(math.Round(coerced))
+		// the last value set on the pid controller target
+		pidControllerTarget := math.Ceil(f.pidLoop.Loop(float64(target), float64(lastSetPwm)))
+		pidControllerTarget = pidControllerTarget + pidChange
+
+		// ensure we are within sane bounds
+		coerced := util.Coerce(float64(lastSetPwm)+pidControllerTarget, 0, 255)
+		stepTarget = int(math.Round(coerced))
+
+		// optional simple value
+	} else if fan.GetControlAlgorithm().Alg == "simple" {
+		// ask the PID controller how to proceed
+		pwmChange := math.Ceil(f.pidLoop.Loop(float64(target), float64(lastSetPwm)))
+
+		// ensure we are within sane bounds
+		coerced := util.Coerce(float64(lastSetPwm)+pwmChange, 0, 255)
+		stepTarget = int(math.Round(coerced))
+	}
 
 	if target >= 0 {
 		_ = trySetManualPwm(f.fan)
-		err := f.setPwm(roundedTarget)
+		err := f.setPwm(stepTarget)
 		if err != nil {
 			ui.Error("Error setting %s: %v", fan.GetId(), err)
 		}
@@ -420,10 +439,11 @@ func (f *PidFanController) calculateTargetPwm() int {
 
 	// map the target value to the possible range of this fan
 	maxPwm := fan.GetMaxPwm()
-	minPwm := fan.GetMinPwm() + f.minPwmOffset
+	// minPwm := fan.GetMinPwm() + f.minPwmOffset
 
 	// TODO: this assumes a linear curve, but it might be something else
-	target = minPwm + int((float64(target)/fans.MaxPwmValue)*(float64(maxPwm)-float64(minPwm)))
+	// TODO: remove
+	// target = minPwm + int((float64(target)/fans.MaxPwmValue)*(float64(maxPwm)-float64(minPwm)))
 
 	if f.lastSetPwm != nil && f.pwmMap != nil {
 		lastSetPwm := *(f.lastSetPwm)

internal/curves/linear.go

@@ -1,10 +1,12 @@
 package curves
 
 import (
+	"math"
+
 	"github.com/markusressel/fan2go/internal/configuration"
 	"github.com/markusressel/fan2go/internal/sensors"
+	"github.com/markusressel/fan2go/internal/ui"
 	"github.com/markusressel/fan2go/internal/util"
-	"math"
 )
 
 type LinearSpeedCurve struct {
@@ -39,6 +41,7 @@ func (c *LinearSpeedCurve) Evaluate() (value int, err error) {
 		}
 	}
 
+	ui.Debug("Evaluating curve '%s'. Sensor '%s' temp '%.0f°'. Desired PWM: %d", c.Config.ID, sensor.GetId(), sensor.GetMovingAvg()/1000, value)
 	c.Value = value
 	return value, nil
 }

internal/fans/common.go

@@ -2,8 +2,9 @@ package fans
 
 import (
 	"fmt"
-	"github.com/markusressel/fan2go/internal/configuration"
 	"sort"
+
+	"github.com/markusressel/fan2go/internal/configuration"
 )
 
 const (
@@ -64,6 +65,8 @@ type Fan interface {
 	// GetCurveId returns the id of the speed curve associated with this fan
 	GetCurveId() string
 
+	GetControlAlgorithm() configuration.ControlAlgorithmConfig
+
 	// ShouldNeverStop indicated whether this fan should never stop rotating
 	ShouldNeverStop() bool
 

internal/fans/hwmon.go

@@ -137,6 +137,10 @@ func (fan *HwMonFan) GetCurveId() string {
 	return fan.Config.Curve
 }
 
+func (fan *HwMonFan) GetControlAlgorithm() configuration.ControlAlgorithmConfig {
+	return fan.Config.ControlAlgorithm
+}
+
 func (fan *HwMonFan) ShouldNeverStop() bool {
 	return fan.Config.NeverStop
 }

internal/util/linear_control.go

@@ -0,0 +1,42 @@
+package util
+
+import "time"
+
+// an alternative loop control to gracefully
+// approach the target in fan speed in a linear fashion by simply
+// changing the pwm speed at most by x amount per cycle
+
+type LinearLoop struct {
+	pwmChangePerSecond int
+	lastTime           time.Time
+}
+
+func NewLinearLoop(pwmChangePerSecond int) *LinearLoop {
+	return &LinearLoop{
+		pwmChangePerSecond: pwmChangePerSecond,
+		lastTime:           time.Now(),
+	}
+}
+
+func (l *LinearLoop) Loop(target float64, measured float64) float64 {
+	loopTime := time.Now()
+
+	dt := loopTime.Sub(l.lastTime).Seconds()
+
+	l.lastTime = loopTime
+
+	// the pwm adjustment depends on the direction and
+	// the time-based change speed limit.
+	maxPwmChangeThiStep := float64(l.pwmChangePerSecond) * dt
+	err := target - measured
+	// we can be above or below the target pwm value,
+	// so we substract or add at most the max pwm change,
+	// capped to having reached the target
+	if err > 0 {
+		// below desired speed, add pwms
+		return Coerce(maxPwmChangeThiStep, 0, err)
+	} else {
+		// above or at desired speed, subtract pwms
+		return Coerce(-maxPwmChangeThiStep, err, 0)
+	}
+}

internal/util/pid.go

@@ -1,6 +1,8 @@
 package util
 
-import "time"
+import (
+	"time"
+)
 
 type PidLoop struct {
 	// Proptional Constant
@@ -30,23 +32,27 @@ func NewPidLoop(p float64, i float64, d float64) *PidLoop {
 
 // Loop advances the pid loop
 func (p *PidLoop) Loop(target float64, measured float64) float64 {
-	output := 0.0
-	err := target - measured
+	// TODO: make user configurable
+	const maxPwmAdjustmentPerSecond float64 = 10.0
 
 	loopTime := time.Now()
+	var dt float64
 	if p.lastTime.IsZero() {
-		p.lastTime = loopTime
+		dt = 1
 	} else {
-		dt := loopTime.Sub(p.lastTime).Seconds()
-
-		proportional := err
-		p.integral = p.integral + err*dt
-		derivative := (err - p.error) / dt
-		output = p.p*proportional + p.i*p.integral + p.d*derivative
+		dt = loopTime.Sub(p.lastTime).Seconds()
 	}
-
-	p.error = err
 	p.lastTime = loopTime
 
-	return output
+	// the pwm adjustment depends on the direction and
+	// the time-based change speed limit.
+	maxPwmAdjustmentThiStep := maxPwmAdjustmentPerSecond * dt
+	err := target - measured
+	if err > 0 {
+		return Coerce(maxPwmAdjustmentThiStep, 0, err)
+	} else if err < 0 {
+		return Coerce(-maxPwmAdjustmentThiStep, err, 0)
+	} else {
+		return 0
+	}
 }