@@ -4,6 +4,19 @@ All notable changes to this project are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Fixed
+
+- Telemetry no longer stops while the car is charging. Charge detection relied solely on
+  the standard AAOS charge-port property, which this VHAL need not implement: a plugged-in
+  car reading "unplugged" was treated as parked and idle and throttled to one sample every
+  15 minutes, so ABRP never saw the SOC curve it needs to size a charging stop. The charge
+  rate and, failing that, a rising SOC on a parked car are now used as fallbacks.
+- `power` is now signed ABRP's way — positive leaving the battery, negative charging. The
+  vehicle's charge rate uses the opposite convention and was being forwarded unchanged, so
+  ABRP saw a fast-charging car as discharging.
+
 ## [2.0.0] - 2026-08-15
 
 ### ⚠️ Breaking — existing users must install once more
 
@@ -102,6 +102,8 @@ public class AbrpUploadService extends Service {
     private volatile Boolean lastParked = null;
     private volatile Boolean lastCharging = null;
     private volatile long lastUploadAttemptMs = 0L;
+    /** Charge detection state. Touched only from the scheduler thread, inside doUpload. */
+    private final ChargingSignal chargingSignal = new ChargingSignal();
     private volatile UploadSettings settings = UploadSettings.defaults();
     /** False while no GPS subscription is delivering — drives the watchdog re-arm. */
     private volatile boolean locationUpdatesActive = false;
@@ -279,24 +281,35 @@ private void doUpload() {
         // every generation. The old local vendor ID (0x15602511) was SWI68-only.
         Float extTemp = EVHardware.INSTANCE.getOutsideTempCelsius();
 
-        // Charge rate comes in mW (signed: +ve charging, -ve driving). ABRP wants kW.
-        Float chargeRate = carUp ? carAdapter.getFloatProperty(
+        // Charge rate comes in mW, signed the VHAL's way: +ve charging, -ve driving.
+        Float chargeRateRaw = carUp ? carAdapter.getFloatProperty(
                 CarPropertyAdapter.PROP_EV_INSTANTANEOUS_CHARGE_RATE,
                 CarPropertyAdapter.PROP_AREA_GLOBAL) : null;
-        Float powerKw = chargeRate == null ? null : chargeRate / 1_000_000f;
+        Float chargeRateKw = chargeRateRaw == null ? null : chargeRateRaw / 1_000_000f;
 
-        Boolean charging = carUp ? carAdapter.getBooleanProperty(
+        Boolean portConnected = carUp ? carAdapter.getBooleanProperty(
                 CarPropertyAdapter.PROP_EV_CHARGE_PORT_CONNECTED,
                 CarPropertyAdapter.PROP_AREA_GLOBAL) : null;
 
         // Park state via EVHardware: it resolves gear per generation (VPM / CarStateClient
         // / VehicleConditionManager depending on firmware). Null means unknown, not "moving".
         Boolean parked = EVHardware.INSTANCE.isVehicleInPark();
 
+        // The charge port property is standard AAOS and this VHAL need not implement it.
+        // Trusting it alone meant a plugged-in car that reads "unplugged" was treated as
+        // parked-and-idle and throttled to one sample every 15 minutes for the whole
+        // charge — see ChargingSignal for the fallbacks.
+        Boolean charging = chargingSignal.evaluate(
+                System.currentTimeMillis(), portConnected, chargeRateKw, parked, soc);
+
+        // ABRP signs power the other way round from the VHAL: positive is power leaving
+        // the battery (driving), negative is power going into it (charging).
+        Float powerKw = chargeRateKw == null ? null : -chargeRateKw;
+
         // DCFC heuristic: charging at AC speeds (3-22 kW) is type-2; above ~25 kW
         // it can only be DC fast. Undecidable if either input is missing.
-        Boolean dcfc = (charging == null || powerKw == null)
-                ? null : (charging && powerKw > 25f);
+        Boolean dcfc = (charging == null || chargeRateKw == null)
+                ? null : (charging && chargeRateKw > 25f);
 
         // Cabin temperature — try the standard HVAC property, may fail on this VHAL.
         Float cabinTemp = carUp ? carAdapter.getFloatProperty(
 
@@ -0,0 +1,77 @@
+package com.evsuite.abrp;
+
+/**
+ * Works out whether the car is charging from whichever signals the VHAL actually answers.
+ *
+ * {@code EV_CHARGE_PORT_CONNECTED} is a standard AAOS property and this vehicle's VHAL is
+ * not obliged to implement it. When it answers {@code false} on a plugged-in car, the
+ * cadence policy sees "parked and not charging" and backs off to
+ * {@link UploadCadence#PARKED_INTERVAL_MS} for the whole session — which is exactly when
+ * ABRP needs a tight SOC curve to size a charging stop. Two fallbacks close that hole:
+ *
+ *  1. the instantaneous charge rate, which is positive only while the pack takes energy;
+ *  2. a rising SOC on a parked car, which nothing but charging can produce.
+ *
+ * The SOC fallback is latched, because SOC only moves a whole percent every few minutes
+ * and a signal that flapped between ticks would flap {@code is_charging} in the payload
+ * too. The latch expires so a car left parked after a charge falls back to the idle
+ * cadence instead of polling all night.
+ *
+ * Stateful and NOT thread-safe: only the {@code abrp-upload} scheduler thread calls it.
+ */
+final class ChargingSignal {
+
+    /** Above this the pack is taking energy; below it the reading is noise around zero. */
+    static final float CHARGING_POWER_KW = 0.3f;
+
+    /**
+     * How long a SOC rise keeps counting as "charging". Long enough to cover the slowest
+     * realistic case — a 2 kW granny lead needs ~19 min per percent on a 64 kWh pack —
+     * and short enough that a finished charge returns to the idle cadence promptly.
+     */
+    static final long SOC_RISE_LATCH_MS = 1_800_000L;
+
+    private Integer lastSocPercent;
+    /** When SOC last rose while parked; 0 when there is no live rise to trust. */
+    private long socRoseAtMs;
+
+    /**
+     * @param nowMs          current time
+     * @param portConnected  charge port property, null when unreadable
+     * @param chargeRateKw   charge rate in kW as the VHAL signs it (+ve while charging),
+     *                       null when unreadable
+     * @param parked         null when the gear could not be read
+     * @param socPercent     null when the battery level could not be read
+     * @return TRUE / FALSE when the state can be established, null when nothing could be
+     *         read — null must keep counting as "unknown", never as "not charging"
+     */
+    Boolean evaluate(long nowMs, Boolean portConnected, Float chargeRateKw,
+                     Boolean parked, Integer socPercent) {
+        trackSoc(nowMs, parked, socPercent);
+
+        if (Boolean.TRUE.equals(portConnected)) return Boolean.TRUE;
+        if (chargeRateKw != null && chargeRateKw > CHARGING_POWER_KW) return Boolean.TRUE;
+        if (Boolean.TRUE.equals(parked)
+                && socRoseAtMs > 0L && nowMs - socRoseAtMs < SOC_RISE_LATCH_MS) {
+            return Boolean.TRUE;
+        }
+        // Nothing overrode the port: pass its reading through, including its null.
+        return portConnected;
+    }
+
+    private void trackSoc(long nowMs, Boolean parked, Integer socPercent) {
+        if (!Boolean.TRUE.equals(parked)) {
+            // Regen while driving also raises SOC. Keep the latch clear so parking right
+            // after a downhill run does not read as charging.
+            socRoseAtMs = 0L;
+            lastSocPercent = socPercent;
+            return;
+        }
+        if (socPercent == null) return;   // keep the previous reading to compare against
+        if (lastSocPercent != null) {
+            if (socPercent > lastSocPercent) socRoseAtMs = nowMs;
+            else if (socPercent < lastSocPercent) socRoseAtMs = 0L;   // draining, not charging
+        }
+        lastSocPercent = socPercent;
+    }
+}
@@ -0,0 +1,122 @@
+package com.evsuite.abrp;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+/**
+ * Charge detection. The reported regression was a charging car being read as
+ * "parked and not charging", which hands it to {@link UploadCadence#PARKED_INTERVAL_MS}
+ * and costs ABRP the SOC curve it needs to size a charging stop.
+ */
+public class ChargingSignalTest {
+
+    private static final long T0 = 1_700_000_000_000L;
+
+    private final ChargingSignal signal = new ChargingSignal();
+
+    // ---- Charge port property, when the VHAL answers it ----
+
+    @Test
+    public void aConnectedPortIsCharging() {
+        assertTrue(signal.evaluate(T0, true, null, true, 50));
+    }
+
+    @Test
+    public void anUnpluggedParkedCarIsNotCharging() {
+        assertFalse(signal.evaluate(T0, false, null, true, 50));
+    }
+
+    @Test
+    public void anUnreadablePortStaysUnknown() {
+        // Unknown must not collapse to "not charging": UploadCadence treats null as active.
+        assertNull(signal.evaluate(T0, null, null, true, 50));
+    }
+
+    // ---- Fallback 1: charge rate ----
+
+    @Test
+    public void aPositiveChargeRateOverridesAPortThatReadsUnplugged() {
+        assertTrue(signal.evaluate(T0, false, 7.4f, true, 50));
+    }
+
+    @Test
+    public void aNegativeChargeRateIsDriving() {
+        assertFalse(signal.evaluate(T0, false, -14.5f, false, 50));
+    }
+
+    @Test
+    public void noiseAroundZeroIsNotCharging() {
+        assertFalse(signal.evaluate(T0, false, 0.1f, true, 50));
+    }
+
+    // ---- Fallback 2: rising SOC on a parked car ----
+
+    @Test
+    public void aRisingSocOnAParkedCarIsCharging() {
+        // Neither charge property readable — the only evidence left is the battery filling.
+        assertNull(signal.evaluate(T0, null, null, true, 50));
+        assertTrue(signal.evaluate(T0 + 300_000, null, null, true, 51));
+    }
+
+    @Test
+    public void theSocRiseIsLatchedAcrossFlatTicks() {
+        // SOC moves a whole percent every few minutes; without the latch is_charging
+        // would flap between every pair of ticks.
+        signal.evaluate(T0, null, null, true, 50);
+        signal.evaluate(T0 + 300_000, null, null, true, 51);
+        assertTrue(signal.evaluate(T0 + 315_000, null, null, true, 51));
+        assertTrue(signal.evaluate(T0 + 1_500_000, null, null, true, 51));
+    }
+
+    @Test
+    public void theLatchExpiresSoAParkedCarGoesBackToIdle() {
+        signal.evaluate(T0, null, null, true, 50);
+        signal.evaluate(T0 + 300_000, null, null, true, 51);
+        assertNull(signal.evaluate(T0 + 300_000 + ChargingSignal.SOC_RISE_LATCH_MS,
+                null, null, true, 51));
+    }
+
+    @Test
+    public void aFallingSocDropsTheLatchImmediately() {
+        signal.evaluate(T0, null, null, true, 50);
+        assertTrue(signal.evaluate(T0 + 300_000, null, null, true, 51));
+        assertNull(signal.evaluate(T0 + 600_000, null, null, true, 50));
+    }
+
+    @Test
+    public void regenWhileDrivingDoesNotLatch() {
+        // SOC climbing on a downhill run, then the car parks: not a charging session.
+        signal.evaluate(T0, false, null, false, 50);
+        signal.evaluate(T0 + 60_000, false, null, false, 52);
+        assertFalse(signal.evaluate(T0 + 120_000, false, null, true, 52));
+    }
+
+    @Test
+    public void anUnreadableSocKeepsThePreviousReadingToCompareAgainst() {
+        signal.evaluate(T0, null, null, true, 50);
+        signal.evaluate(T0 + 15_000, null, null, true, null);   // one failed read
+        assertTrue(signal.evaluate(T0 + 30_000, null, null, true, 51));
+    }
+
+    // ---- The regression itself ----
+
+    @Test
+    public void aChargingCarIsNeverHandedToTheParkedCadence() {
+        // Charging at home with a VHAL that does not implement the charge port property:
+        // before the fix this was parked + FALSE, i.e. one upload every 15 minutes.
+        ChargingSignal s = new ChargingSignal();
+        UploadSettings settings = UploadSettings.defaults();
+
+        Boolean charging = s.evaluate(T0, false, null, true, 50);
+        assertEquals(UploadCadence.PARKED_INTERVAL_MS,
+                UploadCadence.intervalFor(true, charging, 50, settings));
+
+        charging = s.evaluate(T0 + 300_000, false, null, true, 51);
+        assertEquals(settings.intervalMs(),
+                UploadCadence.intervalFor(true, charging, 51, settings));
+    }
+}