diff --git a/.changeset/easee-energy-from-power.md b/.changeset/easee-energy-from-power.md new file mode 100644 index 000000000..c8387fbac --- /dev/null +++ b/.changeset/easee-energy-from-power.md @@ -0,0 +1,5 @@ +--- +"ftw": patch +--- + +An Easee charger's energy now comes from measured power. Easee's session figure moves in steps of about 1 kWh and FTW rejected many of them, so History showed too little: 10 of 24.3 kWh on one charge. Past days keep their old totals. diff --git a/drivers/BUNDLED_SOURCE.json b/drivers/BUNDLED_SOURCE.json index 073081cdb..3331886b5 100644 --- a/drivers/BUNDLED_SOURCE.json +++ b/drivers/BUNDLED_SOURCE.json @@ -16,7 +16,7 @@ "from the signed channel. Run scripts/sync-bundled-drivers.sh to update." ], "repository": "srcfl/device-drivers", - "commit": "e07d27038e83e431cc01c1cd988ffcb1997355c0", + "commit": "1e4b5de7c055885481a8ba4a56476bd1bc1b7bbb", "source_dir": "drivers/lua", "drivers": [ "ambibox_v2x", "ctek", "ctek_hybrid", "ctek_v2", "deye", "easee_cloud", diff --git a/go/cmd/ftw/energy_history.go b/go/cmd/ftw/energy_history.go index a3831f129..9994c78b1 100644 --- a/go/cmd/ftw/energy_history.go +++ b/go/cmd/ftw/energy_history.go @@ -140,7 +140,7 @@ func buildEnergyObservations(st *state.Store, tel *telemetry.Store, ctrl tickPer } data := energyNumbers(r.Data) appendDirection(id, deviceID, state.AssetVehicleCharger, r.Driver, - state.FlowVehicleCharge, r.UpdatedAt.UnixMilli(), math.Max(r.RawW, 0), firstEnergyNumber(data, "session_wh", "total_charge_wh"), false) + state.FlowVehicleCharge, r.UpdatedAt.UnixMilli(), math.Max(r.RawW, 0), chargerEnergyCounter(r.Data, data), false) } for _, r := range tel.ReadingsByType(telemetry.DerV2X) { @@ -186,6 +186,19 @@ func energyNumbers(raw json.RawMessage) map[string]float64 { return out } +// chargerEnergyCounter is the counter to book a charger's energy from. A +// driver sets session_wh_coarse when its session figure moves in steps too +// large to say when the energy flowed; the record then integrates power. +func chargerEnergyCounter(raw json.RawMessage, values map[string]float64) *float64 { + var flags struct { + Coarse bool `json:"session_wh_coarse"` + } + if json.Unmarshal(raw, &flags) == nil && flags.Coarse { + return firstEnergyNumber(values, "total_charge_wh") + } + return firstEnergyNumber(values, "session_wh", "total_charge_wh") +} + func firstEnergyNumber(values map[string]float64, names ...string) *float64 { for _, name := range names { if value, ok := values[name]; ok { diff --git a/go/cmd/ftw/energy_history_test.go b/go/cmd/ftw/energy_history_test.go index 5a5b01bb4..e5a48a8d6 100644 --- a/go/cmd/ftw/energy_history_test.go +++ b/go/cmd/ftw/energy_history_test.go @@ -3,6 +3,8 @@ package main import ( "context" "encoding/json" + "fmt" + "math" "path/filepath" "sync" "testing" @@ -363,3 +365,68 @@ func testEnergyIdentity(st *state.Store) energyIdentityLookup { return state.Device{} } } + +func TestChargerEnergyCounter(t *testing.T) { + for _, c := range []struct { + name string + raw string + want *float64 + }{ + {"a session counter", `{"session_wh":800}`, ptrFloat(800)}, + {"a lifetime counter", `{"total_charge_wh":5000}`, ptrFloat(5000)}, + {"a coarse session counter is left out", `{"session_wh":800,"session_wh_coarse":true}`, nil}, + {"a real counter beside a coarse one stays", `{"session_wh":800,"session_wh_coarse":true,"total_charge_wh":5000}`, ptrFloat(5000)}, + {"the flag off changes nothing", `{"session_wh":800,"session_wh_coarse":false}`, ptrFloat(800)}, + {"no counter", `{}`, nil}, + } { + raw := json.RawMessage(c.raw) + got := chargerEnergyCounter(raw, energyNumbers(raw)) + if (got == nil) != (c.want == nil) || (got != nil && *got != *c.want) { + t.Errorf("%s: got %v", c.name, got) + } + } +} + +// 8 November 2026: a charger whose session counter moves in 1 kWh steps +// delivered 24 kWh, and readings seconds apart made the record reject most of +// the steps. With the counter left out it books the power. +func TestCoarseChargerIsBookedFromPower(t *testing.T) { + st, err := state.Open(filepath.Join(t.TempDir(), "state.db")) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = st.Close() }) + base := time.Date(2026, 11, 8, 2, 0, 0, 0, time.UTC).UnixMilli() + const stepMS, hourMS, chargeW = int64(2_000), int64(3_600_000), 10_000.0 + for at := int64(0); at <= hourMS; at += stepMS { + power := chargeW + counter := float64(at) / float64(hourMS) * chargeW + counter -= math.Mod(counter, 1000) // whole kWh, as Easee reports it + raw := json.RawMessage(fmt.Sprintf(`{"session_wh":%f,"session_wh_coarse":true}`, counter)) + if err := st.RecordTickWithEnergy(state.HistoryPoint{TsMs: base + at}, nil, []state.EnergyObservation{{ + AssetID: "charger", DeviceID: "charger", AssetKind: state.AssetVehicleCharger, Label: "charger", + Flow: state.FlowVehicleCharge, AtMs: base + at, PowerW: &power, + CounterWh: chargerEnergyCounter(raw, energyNumbers(raw)), + }}); err != nil { + t.Fatal(err) + } + } + points, _, err := st.LoadEnergyHistory(state.EnergyHistoryQuery{ + AssetID: "charger", SinceMS: base, UntilMS: base + hourMS + 60_000, BucketMS: 30 * 60_000, Limit: 1000, + }) + if err != nil { + t.Fatal(err) + } + total := 0.0 + for _, p := range points { + if p.Quality == "invalid" || p.Quality == "reset" { + t.Fatalf("a rejected reading: %+v", p) + } + total += p.EnergyWh + } + if math.Abs(total-10_000) > 1 { + t.Fatalf("booked %.0f Wh, want 10000", total) + } +} + +func ptrFloat(v float64) *float64 { return &v }