fix(chargepilot): consumption models learn from town driving

Bumps EVHardware to the per-kilometre power fit and the gauge-step
charge segmentation. The local model test now builds steady kilometres,
since sampleCount counts kilometre windows rather than 5 s samples.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: malys

CHANGELOG.md

@@ -49,6 +49,11 @@ All notable changes follow [Keep a Changelog](https://keepachangelog.com/en/1.1.
 
 ### Fixed
 
+- **The consumption models learn from town driving.** EVHardware now fits the power model on
+  one point per kilometre instead of per 5 s sample, so stop-and-go trips train it, and the
+  charge model cuts segments at the SWI68 gauge's 0.1 % step instead of waiting for 2 %. Twelve
+  kilometres at two speeds are enough for the speed comparison and the energy breakdown to
+  answer from a model.
 - **Finished-trip eco advice no longer drops persisted samples.** Trip tracks keep the first
   telemetry frame after each five-second boundary, commonly around 5.3 seconds apart. Replay used
   the stricter five-second live gap and discarded those intervals; it now uses the stored-track

EVHardware

@@ -7,6 +7,7 @@ import com.evsuite.hardware.telemetry.StoredTrip
 import com.evsuite.hardware.telemetry.TripSample
 import java.nio.file.Files
 import kotlin.math.abs
+import kotlin.math.ceil
 import org.junit.Assert.assertEquals
 import org.junit.Test
 
@@ -19,56 +20,63 @@ class LocalEnergyModelTest {
     fun `new bounded history replaces model and failed fit keeps last good model`() {
         val directory = Files.createTempDirectory("chargepilot-local-model").toFile()
         try {
-            val firstTrip = trip(startedAtMs = 1L, sampleCount = 60)
+            val firstTrip = trip(startedAtMs = 1L, kilometres = 12)
             val first = checkNotNull(
                 LocalEnergyModel.loadOrTrain(directory, listOf(firstTrip), evidence)
             )
-            assertEquals(60, first.sampleCount)
+            // One sample per kilometre window: twelve is the least a model is trained from.
+            assertEquals(12, first.sampleCount)
 
-            val secondTrip = trip(startedAtMs = 2L, sampleCount = 80)
+            val secondTrip = trip(startedAtMs = 2L, kilometres = 18)
             val refreshed = checkNotNull(
                 LocalEnergyModel.loadOrTrain(
                     directory,
                     listOf(secondTrip, firstTrip),
                     evidence,
                 )
             )
-            assertEquals(140, refreshed.sampleCount)
+            assertEquals(30, refreshed.sampleCount)
 
             val fallback = checkNotNull(
                 LocalEnergyModel.loadOrTrain(directory, emptyList(), evidence)
             )
-            assertEquals(140, fallback.sampleCount)
+            assertEquals(30, fallback.sampleCount)
         } finally {
             directory.deleteRecursively()
         }
     }
 
-    private fun trip(startedAtMs: Long, sampleCount: Int): StoredTrip {
-        val samples = List(sampleCount) { index ->
-            val speed = 30.0 + index % 6 * 10.0
-            val temperature = if ((index / 6) % 2 == 0) 10.0 else 20.0
+    /** [kilometres] steady kilometres, six speeds and two temperatures, a hole after each. */
+    private fun trip(startedAtMs: Long, kilometres: Int): StoredTrip {
+        var atMs = startedAtMs
+        val samples = (0 until kilometres).flatMap { km ->
+            val speed = 30.0 + km % 6 * 10.0
+            val temperature = if ((km / 6) % 2 == 0) 10.0 else 20.0
             val consumption = 10.0 + 0.0005 * speed * speed +
                 0.1 * abs(temperature - 20.0)
-            TripSample(
-                atMs = startedAtMs + index * 5_000L,
-                speedKmh = speed.toFloat(),
-                batteryPowerKw = (consumption * speed / 100.0).toFloat(),
-                socPercent = null,
-                outsideTempCelsius = temperature.toFloat(),
-                cabinTempCelsius = null,
-                batteryTempCelsius = null,
-                climatePowerOn = null,
-                climateAcOn = null,
-                climateFanLevel = null,
-            )
+            // One interval past the kilometre, so rounding cannot leave the window short.
+            val count = ceil(3_600.0 / (5.0 * speed)).toInt() + 2
+            List(count) { index ->
+                TripSample(
+                    atMs = atMs + index * 5_000L,
+                    speedKmh = speed.toFloat(),
+                    batteryPowerKw = (consumption * speed / 100.0).toFloat(),
+                    socPercent = null,
+                    outsideTempCelsius = temperature.toFloat(),
+                    cabinTempCelsius = null,
+                    batteryTempCelsius = null,
+                    climatePowerOn = null,
+                    climateAcOn = null,
+                    climateFanLevel = null,
+                )
+            }.also { atMs += count * 5_000L + 600_000L }
         }
         return StoredTrip(
             summary = EnergyTripSummary(
                 startedAtMs = startedAtMs,
-                endedAtMs = startedAtMs + sampleCount * 5_000L,
-                durationMs = sampleCount * 5_000L,
-                distanceKm = 10.0,
+                endedAtMs = atMs,
+                durationMs = atMs - startedAtMs,
+                distanceKm = kilometres.toDouble(),
                 startSocPercent = 80f,
                 endSocPercent = 78f,
                 consumedKwh = 2.0,