@@ -8,6 +8,19 @@ All notable changes to this project are documented here. Format follows
 
 ### Fixed
 
+- **`PERF_VEHICLE_SPEED` already reports km/h on SWI68, and was being converted a second time.**
+  AAOS specifies the property in metres per second, so every read was multiplied by 3.6 — and
+  every distance integrated from it was scaled by the same factor. A 2.4 km drive was recorded
+  as 8.46 km and, on a second run, 7.69 km: 124 and 129 km/h average over four minutes of town
+  driving. Divided by 3.6 the same trips read 2.35 km at 34 km/h, which is the drive that
+  happened. `VehicleSpeedScale` makes the conversion evidence-gated per generation like every
+  other firmware-dependent read here. SWI68 is listed on the 2026-09-04 bundle from
+  SWI68-29958-1300R67; every other generation keeps the specified conversion, unproven but wrong
+  in the conservative direction, since a speed read too high makes `VehicleWriteGate` refuse
+  more often rather than less.
+
+### Fixed
+
 - **Repeated vehicle states no longer flood the diagnostic log.** The ignition condition
   arrives about ten times a second and the gear is read once a second; both were logged every
   time, so a 400-line retained log held under a minute of history and anything older had already
 
@@ -368,14 +368,17 @@ object EVHardware {
     /**
      * Vehicle speed in km/h, or null if it cannot be read (CPM not ready,
      * property non supportsde, exception). [VehicleWriteGate] traite null comme un refus.
+     *
+     * The property's unit varies by generation — see [VehicleSpeedScale].
      */
     fun getVehicleSpeedKmh(): Float? {
-        val mps = getFloatPropertyCPM(PROP_VEHICLE_SPEED, AREA_GLOBAL)
+        val raw = getFloatPropertyCPM(PROP_VEHICLE_SPEED, AREA_GLOBAL)
             ?: getFloatPropertyCPM(PROP_VEHICLE_SPEED, 0)
             ?: return null
-        // PERF_VEHICLE_SPEED is signed (negative in reverse): it is the speed
-        // absolue qui compte pour savoir si le vehicle bouge.
-        return kotlin.math.abs(mps) * 3.6f
+        // The unit is firmware-dependent, not what AAOS specifies: SWI68 already reports
+        // km/h. [VehicleSpeedScale] carries the evidence and takes the magnitude, since the
+        // property is signed in reverse and every consumer asks whether the car is moving.
+        return VehicleSpeedScale.toKmh(raw, FirmwareInfo.getGeneration())
     }
 
     /**
 
@@ -0,0 +1,44 @@
+package com.evsuite.hardware
+
+import kotlin.math.abs
+
+/**
+ * What `PERF_VEHICLE_SPEED` is actually in, per firmware generation.
+ *
+ * AAOS defines the property as metres per second, so every read was multiplied by 3.6. On
+ * SWI68 that is wrong: the property already reports km/h, and multiplying a second time
+ * scaled every derived distance by the same factor. A 2.4 km drive was recorded twice as
+ * 8.46 km and 7.69 km — 124 and 129 km/h average over four minutes of town driving — and
+ * dividing by 3.6 gives 2.35 km at 34 km/h, which is the drive that happened.
+ *
+ * The conversion is therefore evidence-gated like every other firmware-dependent read here.
+ * A generation is listed only once a vehicle has shown it, and an unlisted generation keeps
+ * the specified conversion: unproven, but wrong in the conservative direction, because a
+ * speed read too high makes [VehicleWriteGate] refuse more often rather than less.
+ */
+object VehicleSpeedScale {
+
+    /** Metres per second to km/h, for generations that really do report the specified unit. */
+    private const val MPS_TO_KMH = 3.6f
+
+    /**
+     * Generations proven on a vehicle to report km/h directly from `PERF_VEHICLE_SPEED`.
+     *
+     * SWI68: bundle of 2026-09-04, firmware SWI68-29958-1300R67. Two recorded trips over a
+     * route of known length, both over by the same 3.5x, with the adapter odometer as the
+     * independent reference. Add a generation here only with the same kind of evidence.
+     */
+    private val REPORTS_KMH = setOf(FirmwareInfo.Gen.SWI68)
+
+    /** True when this generation needs no conversion at all. */
+    fun reportsKmh(generation: FirmwareInfo.Gen): Boolean = generation in REPORTS_KMH
+
+    /**
+     * The raw property value as km/h.
+     *
+     * The property is signed — negative in reverse — and every consumer here asks whether the
+     * car is moving, so the magnitude is what comes back.
+     */
+    fun toKmh(raw: Float, generation: FirmwareInfo.Gen): Float =
+        if (reportsKmh(generation)) abs(raw) else abs(raw) * MPS_TO_KMH
+}
@@ -0,0 +1,46 @@
+package com.evsuite.hardware
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class VehicleSpeedScaleTest {
+
+    @Test fun `SWI68 reports km per hour and is not converted again`() {
+        assertTrue(VehicleSpeedScale.reportsKmh(FirmwareInfo.Gen.SWI68))
+        assertEquals(34.4f, VehicleSpeedScale.toKmh(34.4f, FirmwareInfo.Gen.SWI68), 0.001f)
+    }
+
+    @Test fun `an unproven generation keeps the specified conversion`() {
+        FirmwareInfo.Gen.entries
+            .filterNot { it == FirmwareInfo.Gen.SWI68 }
+            .forEach { generation ->
+                assertFalse("$generation is not proven", VehicleSpeedScale.reportsKmh(generation))
+                assertEquals(
+                    "$generation must keep the AAOS conversion",
+                    36.0f,
+                    VehicleSpeedScale.toKmh(10.0f, generation),
+                    0.001f,
+                )
+            }
+    }
+
+    @Test fun `reverse is a speed, not a negative one`() {
+        assertEquals(12.0f, VehicleSpeedScale.toKmh(-12.0f, FirmwareInfo.Gen.SWI68), 0.001f)
+        assertEquals(36.0f, VehicleSpeedScale.toKmh(-10.0f, FirmwareInfo.Gen.SWI69), 0.001f)
+    }
+
+    @Test fun `the drive that proved it now integrates to the route it followed`() {
+        // The recorded trip: 245836 ms at a steady 34.4 km/h reads as 2.35 km, not 8.46 km.
+        val hours = 245_836L / 3_600_000.0
+        val kmh = VehicleSpeedScale.toKmh(34.4f, FirmwareInfo.Gen.SWI68)
+        assertEquals(2.35, kmh * hours, 0.02)
+    }
+
+    @Test fun `standstill stays standstill in every generation`() {
+        FirmwareInfo.Gen.entries.forEach {
+            assertEquals(0.0f, VehicleSpeedScale.toKmh(0.0f, it), 0.0f)
+        }
+    }
+}