hems/fnn: add failsafeConsumptionActivePowerLimit and failsafeDurationMinimum support

hems/fnn/fnn.go

@@ -23,14 +23,16 @@
 // NewFromConfig creates an FNN HEMS from generic config.
 func NewFromConfig(ctx context.Context, other map[string]any, site site.API) (*Fnn, error) {
 	cc := struct {
-		MaxPower        float64 // TODO deprecated
-		MaxDimPower     float64
-		MaxCurtailPower float64
-		W3              *plugin.Config
-		S1              *plugin.Config
-		S2              *plugin.Config
-		W4              *plugin.Config
-		Interval        time.Duration
+		MaxPower                            float64 // TODO deprecated
+		MaxDimPower                         float64
+		MaxCurtailPower                     float64
+		W3                                  *plugin.Config
+		S1                                  *plugin.Config
+		S2                                  *plugin.Config
+		W4                                  *plugin.Config
+		Interval                            time.Duration
+		FailsafeConsumptionActivePowerLimit float64
+		FailsafeDurationMinimum             time.Duration
 	}{
 		Interval: 10 * time.Second,
 	}
@@ -69,25 +71,27 @@
 		maxCurtailPower = cc.MaxPower
 	}
 
-	return NewFnn(site, math.Abs(cc.MaxDimPower), maxCurtailPower, w3G, s1G, s2G, w4G, cc.Interval)
+	return NewFnn(site, math.Abs(cc.MaxDimPower), maxCurtailPower, w3G, s1G, s2G, w4G, cc.Interval, math.Abs(cc.FailsafeConsumptionActivePowerLimit), cc.FailsafeDurationMinimum)
 }
 
-func NewFnn(site site.API, maxDimPower, maxCurtailPower float64, w3G, s1G, s2G, w4G func() (bool, error), interval time.Duration) (*Fnn, error) {
+func NewFnn(site site.API, maxDimPower, maxCurtailPower float64, w3G, s1G, s2G, w4G func() (bool, error), interval time.Duration, failsafeConsumptionLimit float64, failsafeDurationMinimum time.Duration) (*Fnn, error) {
 	if w4G != nil && maxDimPower == 0 {
 		return nil, errors.New("cannot have w4 without power limit")
 	}
 
 	c := &Fnn{
-		log:               util.NewLogger("fnn"),
-		site:              site,
-		maxDimPower:       maxDimPower,
-		maxCurtailPower:   maxCurtailPower,
-		s1:                s1G,
-		s2:                s2G,
-		w3:                w3G,
-		w4:                w4G,
-		productionPercent: 100,
-		interval:          interval,
+		log:                     util.NewLogger("fnn"),
+		site:                    site,
+		maxDimPower:             maxDimPower,
+		maxCurtailPower:         maxCurtailPower,
+		s1:                      s1G,
+		s2:                      s2G,
+		w3:                      w3G,
+		w4:                      w4G,
+		productionPercent:       100,
+		interval:                interval,
+		failsafeConsumptionLimit:  failsafeConsumptionLimit,
+		failsafeDurationMinimum:   failsafeDurationMinimum,
 	}
 
 	// read the relays once synchronously so limits are valid as soon as NewFnn returns
@@ -121,6 +125,11 @@
 	productionPercent int // allowed feed-in percent (0..100), 100 = uncurtailed
 
 	interval time.Duration
+
+	failsafeConsumptionLimit float64
+	failsafeDurationMinimum  time.Duration
+	failsafeActive           bool
+	failsafeEnteredAt        time.Time
 }
 
 func (c *Fnn) SetUpdated(f func()) {
@@ -183,14 +192,42 @@
 
 // runDim evaluates the dimming rule and applies the dim limit.
 // No-op if dim input is not configured.
+// On read error, enters failsafe mode and applies failsafeConsumptionLimit if configured.
+// Failsafe remains active for at least failsafeDurationMinimum after the first error.
 func (c *Fnn) runDim() error {
 	if c.w4 == nil {
 		return nil
 	}
 
 	active, err := c.w4()
 	if err != nil {
-		return err
+		if c.failsafeConsumptionLimit <= 0 {
+			return err
+		}
+		c.mu.Lock()
+		if !c.failsafeActive {
+			c.log.WARN.Println("w4 read error, entering failsafe mode")
+			c.failsafeActive = true
+			c.failsafeEnteredAt = time.Now()
+		}
+		c.mu.Unlock()
+		return c.setConsumptionLimit(c.failsafeConsumptionLimit)
+	}
+
+	c.mu.Lock()
+	inFailsafe := false
+	if c.failsafeActive {
+		if time.Since(c.failsafeEnteredAt) >= c.failsafeDurationMinimum {
+			c.log.DEBUG.Println("leaving failsafe mode")
+			c.failsafeActive = false
+		} else {
+			inFailsafe = true
+		}
+	}
+	c.mu.Unlock()
+
+	if inFailsafe {
+		return nil
 	}
 
 	limit := 0.0

hems/fnn/fnn_test.go

@@ -1,11 +1,14 @@
 package fnn
 
 import (
+	"errors"
 	"testing"
+	"time"
 
 	"github.com/evcc-io/evcc/core/site"
 	"github.com/evcc-io/evcc/hems/hems"
 	"github.com/evcc-io/evcc/server/db"
+	"github.com/evcc-io/evcc/util"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -21,12 +24,16 @@ func boolG(v bool) func() (bool, error) {
 	return func() (bool, error) { return v, nil }
 }
 
+func errG() func() (bool, error) {
+	return func() (bool, error) { return false, errors.New("read error") }
+}
+
 // TestCurtailmentNotConfigured verifies that without W3 no curtailment
 // statement is made, while dimming via W4 remains available.
 func TestCurtailmentNotConfigured(t *testing.T) {
 	require.NoError(t, db.NewInstance("sqlite", ":memory:"))
 
-	fnn, err := NewFnn(&stubSite{}, 1e3, 1e3, nil, nil, nil, boolG(true), 0)
+	fnn, err := NewFnn(&stubSite{}, 1e3, 1e3, nil, nil, nil, boolG(true), 0, 0, 0)
 	require.NoError(t, err)
 
 	assert.Nil(t, fnn.CurtailedPercent())
@@ -40,7 +47,7 @@ func TestCurtailmentNotConfigured(t *testing.T) {
 // TestDimmingNotConfigured verifies that without W4 no dimming statement is
 // made, while curtailment via W3 remains available.
 func TestDimmingNotConfigured(t *testing.T) {
-	fnn, err := NewFnn(&stubSite{}, 0, 1e3, boolG(false), nil, nil, nil, 0)
+	fnn, err := NewFnn(&stubSite{}, 0, 1e3, boolG(false), nil, nil, nil, 0, 0, 0)
 	require.NoError(t, err)
 
 	assert.Nil(t, fnn.MaxConsumptionPower())
@@ -49,3 +56,88 @@ func TestDimmingNotConfigured(t *testing.T) {
 	assert.NotNil(t, fnn.CurtailedPercent())
 	assert.NotNil(t, hems.Curtailed(fnn))
 }
+
+// TestDecodeConfig verifies that failsafe config keys are accepted and decoded.
+func TestDecodeConfig(t *testing.T) {
+	require.NoError(t, db.NewInstance("sqlite", ":memory:"))
+	_ = util.NewLogger("fnn")
+
+	other := map[string]any{
+		"maxDimPower":                         4200,
+		"failsafeConsumptionActivePowerLimit": 4200,
+		"failsafeDurationMinimum":             "30m",
+		"w4": map[string]any{
+			"source": "const",
+			"value":  false,
+		},
+	}
+
+	f, err := NewFromConfig(t.Context(), other, &stubSite{})
+	require.NoError(t, err)
+	assert.Equal(t, 4200.0, f.failsafeConsumptionLimit)
+	assert.Equal(t, 30*time.Minute, f.failsafeDurationMinimum)
+}
+
+// TestFailsafeActivatesOnReadError verifies that a W4 read error triggers failsafe
+// mode and the configured failsafe consumption limit is applied.
+func TestFailsafeActivatesOnReadError(t *testing.T) {
+	require.NoError(t, db.NewInstance("sqlite", ":memory:"))
+
+	const failsafeLimit = 4200.0
+	fnn, err := NewFnn(&stubSite{}, failsafeLimit, 0, nil, nil, nil, errG(), 0, failsafeLimit, 0)
+	require.NoError(t, err)
+
+	// construction calls runDim once — failsafe should already be active
+	assert.True(t, fnn.failsafeActive)
+	require.NotNil(t, fnn.MaxConsumptionPower())
+	assert.Equal(t, failsafeLimit, *fnn.MaxConsumptionPower())
+}
+
+// TestFailsafeExitsAfterDuration verifies that failsafe is released once
+// failsafeDurationMinimum has elapsed and a successful read follows.
+func TestFailsafeExitsAfterDuration(t *testing.T) {
+	require.NoError(t, db.NewInstance("sqlite", ":memory:"))
+
+	const failsafeLimit = 4200.0
+	// duration of 0 means failsafe exits on next successful read
+	fnn, err := NewFnn(&stubSite{}, failsafeLimit, 0, nil, nil, nil, errG(), 0, failsafeLimit, 0)
+	require.NoError(t, err)
+	assert.True(t, fnn.failsafeActive)
+
+	// switch to successful read
+	fnn.w4 = boolG(false)
+	require.NoError(t, fnn.runDim())
+
+	assert.False(t, fnn.failsafeActive)
+	require.NotNil(t, fnn.MaxConsumptionPower())
+	assert.Equal(t, 0.0, *fnn.MaxConsumptionPower())
+}
+
+// TestFailsafeRemainsActiveDuringDuration verifies that failsafe stays active
+// while failsafeDurationMinimum has not yet elapsed, even when reads succeed.
+func TestFailsafeRemainsActiveDuringDuration(t *testing.T) {
+	require.NoError(t, db.NewInstance("sqlite", ":memory:"))
+
+	const failsafeLimit = 4200.0
+	fnn, err := NewFnn(&stubSite{}, failsafeLimit, 0, nil, nil, nil, errG(), 0, failsafeLimit, time.Hour)
+	require.NoError(t, err)
+	assert.True(t, fnn.failsafeActive)
+
+	// switch to successful read, but duration not yet elapsed
+	fnn.w4 = boolG(false)
+	require.NoError(t, fnn.runDim())
+
+	assert.True(t, fnn.failsafeActive)
+	require.NotNil(t, fnn.MaxConsumptionPower())
+	assert.Equal(t, failsafeLimit, *fnn.MaxConsumptionPower())
+}
+
+// TestFailsafeNotConfiguredPropagatesError verifies that without a configured
+// failsafe limit, a W4 read error is returned to the caller unchanged.
+func TestFailsafeNotConfiguredPropagatesError(t *testing.T) {
+	require.NoError(t, db.NewInstance("sqlite", ":memory:"))
+
+	// no failsafe limit: construction error because runDim is called in NewFnn
+	_, err := NewFnn(&stubSite{}, 1e3, 0, nil, nil, nil, errG(), 0, 0, 0)
+	assert.Error(t, err)
+}