Merge pull request #79 from basmeerman/work/plan-03

feat: OCPP robustness — LB exclusivity, FreeVend guard, settings validation, telemetry

Author: basmeerman

SmartEVSE-3/src/esp32.cpp

@@ -60,6 +60,8 @@ char RequiredEVCCID[32] = "";                                               // R
 #include <MicroOcppMongooseClient.h>
 #include <MicroOcpp/Core/Configuration.h>
 #include <MicroOcpp/Core/Context.h>
+#include "ocpp_logic.h"
+#include "ocpp_telemetry.h"
 #endif //ENABLE_OCPP
 
 #if SMARTEVSE_VERSION >= 40
@@ -354,6 +356,8 @@ extern uint8_t OcppTrackCPvoltage;
 extern MicroOcpp::MOcppMongooseClient *OcppWsClient;
 
 extern float OcppCurrentLimit;
+extern bool OcppWasStandalone;
+extern ocpp_telemetry_t OcppTelemetry;
 
 extern unsigned long OcppStopReadingSyncTime; // Stop value synchronization: delay StopTransaction by a few seconds so it reports an accurate energy reading
 
@@ -1151,6 +1155,18 @@ void mqttPublishData() {
 #if ENABLE_OCPP && defined(SMARTEVSE_VERSION) //run OCPP only on ESP32
         mqtt_pub_str(MQTT_SLOT_OCPP, "/OCPP", OcppMode ? "Enabled" : "Disabled", true, now_s);
         mqtt_pub_str(MQTT_SLOT_OCPP_CONNECTION, "/OCPPConnection", (OcppWsClient && OcppWsClient->isConnected()) ? "Connected" : "Disconnected", false, now_s);
+        mqtt_pub_str(MQTT_SLOT_OCPP_TX_ACTIVE, "/OCPPTxActive", OcppTelemetry.tx_active ? "true" : "false", false, now_s);
+        {
+            char ocpp_limit_buf[16];
+            if (OcppCurrentLimit >= 0.0f) {
+                snprintf(ocpp_limit_buf, sizeof(ocpp_limit_buf), "%.1f", (double)OcppCurrentLimit);
+            } else {
+                snprintf(ocpp_limit_buf, sizeof(ocpp_limit_buf), "none");
+            }
+            mqtt_pub_str(MQTT_SLOT_OCPP_CURRENT_LIMIT, "/OCPPCurrentLimit", ocpp_limit_buf, false, now_s);
+        }
+        mqtt_pub_str(MQTT_SLOT_OCPP_SMART_CHARGING, "/OCPPSmartCharging",
+            OcppTelemetry.lb_conflict ? "Conflict" : (!LoadBl ? "Active" : "Inactive"), false, now_s);
 #endif //ENABLE_OCPP
         { // LED color topics — build string in buffer
             char color_buf[16];
@@ -1697,6 +1713,8 @@ bool ocppLockingTxDefined() {
 
 void ocppInit() {
 
+    ocpp_telemetry_init(&OcppTelemetry);
+
     //load OCPP library modules: Mongoose WS adapter and Core OCPP library
 
     auto filesystem = MicroOcpp::makeDefaultFilesystemAdapter(
@@ -1814,6 +1832,9 @@ void ocppInit() {
         return nullptr;
     });
 
+    // Track LoadBl state at init time for runtime exclusivity checks
+    OcppWasStandalone = !LoadBl;
+
     // If SmartEVSE load balancer is turned off, then enable OCPP Smart Charging
     // This means after toggling LB, OCPP must be disabled and enabled for changes to become effective
     if (!LoadBl) {
@@ -1866,6 +1887,21 @@ void ocppInit() {
         OcppDefinedTxNotification = true;
         OcppTrackTxNotification = event;
         OcppLastTxNotification = millis();
+
+        // Update telemetry counters
+        if (event == MicroOcpp::TxNotification::StartTx) {
+            ocpp_telemetry_tx_started(&OcppTelemetry);
+        } else if (event == MicroOcpp::TxNotification::StopTx) {
+            ocpp_telemetry_tx_stopped(&OcppTelemetry);
+        } else if (event == MicroOcpp::TxNotification::Authorized ||
+                   event == MicroOcpp::TxNotification::RemoteStart) {
+            ocpp_telemetry_auth_accepted(&OcppTelemetry);
+        } else if (event == MicroOcpp::TxNotification::AuthorizationRejected ||
+                   event == MicroOcpp::TxNotification::DeAuthorized) {
+            ocpp_telemetry_auth_rejected(&OcppTelemetry);
+        } else if (event == MicroOcpp::TxNotification::AuthorizationTimeout) {
+            ocpp_telemetry_auth_timeout(&OcppTelemetry);
+        }
     });
 
     // Declare custom "ConfigureMaxCurrent" key
@@ -1908,6 +1944,7 @@ void ocppDeinit() {
     OcppTrackAccessBit = false;
     OcppTrackCPvoltage = PILOT_NOK;
     OcppCurrentLimit = -1.f;
+    OcppWasStandalone = false;
 
     mocpp_deinitialize();
 
@@ -1923,6 +1960,26 @@ void ocppLoop() {
 
     mocpp_loop();
 
+    // Check OCPP / LoadBl mutual exclusivity at runtime
+    ocpp_lb_status_t lb_status = ocpp_check_lb_exclusivity(LoadBl, OcppMode, OcppWasStandalone);
+    OcppTelemetry.lb_conflict = (lb_status != OCPP_LB_OK);
+    if (lb_status == OCPP_LB_CONFLICT) {
+        // LoadBl changed to non-zero while OCPP is active — Smart Charging limits
+        // are silently ignored by the state machine. Neutralize the limit and warn.
+        if (OcppCurrentLimit >= 0.0f) {
+            _LOG_W("OCPP: LoadBl=%u conflicts with Smart Charging, disabling OCPP current limit\n", LoadBl);
+            OcppCurrentLimit = -1.0f;
+        }
+    } else if (lb_status == OCPP_LB_NEEDS_REINIT) {
+        // LoadBl changed from non-zero to 0 — Smart Charging callback was never
+        // registered. User needs to disable/enable OCPP for it to take effect.
+        static bool ocpp_reinit_warned = false;
+        if (!ocpp_reinit_warned) {
+            _LOG_W("OCPP: LoadBl changed to standalone but Smart Charging not registered. Disable/enable OCPP to activate.\n");
+            ocpp_reinit_warned = true;
+        }
+    }
+
     // handle Configuration updates
 
     auto config = MicroOcpp::getConfigurationPublic("ConfigureMaxCurrent");
@@ -1973,13 +2030,22 @@ void ocppLoop() {
     if (RFIDReader == 6 || RFIDReader == 0) {
         // RFID reader in OCPP mode or RFID fully disabled - OCPP controls Access_bit
         if (!OcppTrackPermitsCharge && ocppPermitsCharge()) {
-            _LOG_A("OCPP set Access_bit\n");
-            setAccess(ON);
+            // Guard: defer Access_bit if mode/delay conflicts (FreeVend + Solar, ChargeDelay)
+            if (ocpp_should_defer_access(Mode, ChargeDelay, ErrorFlags)) {
+                // Don't update OcppTrackPermitsCharge — retry rising edge on next loop
+                _LOG_D("OCPP: deferring Access_bit (Mode=%u ChargeDelay=%u ErrorFlags=0x%04X)\n", Mode, ChargeDelay, ErrorFlags);
+            } else {
+                _LOG_A("OCPP set Access_bit\n");
+                setAccess(ON);
+                OcppTrackPermitsCharge = true;
+            }
         } else if (AccessStatus == ON && !ocppPermitsCharge()) {
             _LOG_A("OCPP unset Access_bit\n");
             setAccess(OFF);
+            OcppTrackPermitsCharge = false;
+        } else {
+            OcppTrackPermitsCharge = ocppPermitsCharge();
         }
-        OcppTrackPermitsCharge = ocppPermitsCharge();
 
         // Check if OCPP charge permission has been revoked by other module
         if (OcppTrackPermitsCharge && // OCPP has set Acess_bit and still allows charge

SmartEVSE-3/src/http_handlers.cpp

@@ -20,6 +20,8 @@
 #include <MicroOcpp.h>
 #include <MicroOcppMongooseClient.h>
 #include <MicroOcpp/Core/Configuration.h>
+#include "ocpp_logic.h"
+#include "ocpp_telemetry.h"
 #endif //ENABLE_OCPP
 
 // Externs for globals not exposed via headers
@@ -81,6 +83,8 @@ extern uint16_t MQTTHeartbeat;
 
 #if ENABLE_OCPP && defined(SMARTEVSE_VERSION)
 extern MicroOcpp::MOcppMongooseClient *OcppWsClient;
+extern float OcppCurrentLimit;
+extern ocpp_telemetry_t OcppTelemetry;
 #endif
 
 //make mongoose 7.14 compatible with 7.13
@@ -259,6 +263,17 @@ bool handle_URI(struct mg_connection *c, struct mg_http_message *hm,  webServerR
         } else {
             doc["ocpp"]["status"] = "Disconnected";
         }
+
+        // OCPP telemetry
+        doc["ocpp"]["tx_active"] = OcppTelemetry.tx_active;
+        doc["ocpp"]["tx_starts"] = OcppTelemetry.tx_start_count;
+        doc["ocpp"]["tx_stops"] = OcppTelemetry.tx_stop_count;
+        doc["ocpp"]["auth_accepts"] = OcppTelemetry.auth_accept_count;
+        doc["ocpp"]["auth_rejects"] = OcppTelemetry.auth_reject_count;
+        doc["ocpp"]["auth_timeouts"] = OcppTelemetry.auth_timeout_count;
+        doc["ocpp"]["smart_charging_active"] = (!LoadBl && OcppCurrentLimit >= 0.0f);
+        doc["ocpp"]["current_limit_a"] = OcppCurrentLimit >= 0.0f ? OcppCurrentLimit : -1;
+        doc["ocpp"]["lb_conflict"] = OcppTelemetry.lb_conflict;
 #endif //ENABLE_OCPP
 
         doc["home_battery"]["current"] = homeBatteryCurrent;
@@ -633,26 +648,44 @@ bool handle_URI(struct mg_connection *c, struct mg_http_message *hm,  webServerR
                 }
 
                 if(request->hasParam("ocpp_backend_url")) {
-                    if (OcppWsClient) {
-                        OcppWsClient->setBackendUrl(request->getParam("ocpp_backend_url")->value().c_str());
+                    const char *url = request->getParam("ocpp_backend_url")->value().c_str();
+                    ocpp_validate_result_t vr = ocpp_validate_backend_url(url);
+                    if (vr != OCPP_VALIDATE_OK) {
+                        doc["ocpp_backend_url"] = vr == OCPP_VALIDATE_EMPTY ? "URL is empty"
+                                                : vr == OCPP_VALIDATE_BAD_SCHEME ? "URL must start with ws:// or wss://"
+                                                : "Invalid URL";
+                    } else if (OcppWsClient) {
+                        OcppWsClient->setBackendUrl(url);
                         doc["ocpp_backend_url"] = OcppWsClient->getBackendUrl();
                     } else {
                         doc["ocpp_backend_url"] = "Can only update when OCPP enabled";
                     }
                 }
 
                 if(request->hasParam("ocpp_cb_id")) {
-                    if (OcppWsClient) {
-                        OcppWsClient->setChargeBoxId(request->getParam("ocpp_cb_id")->value().c_str());
+                    const char *cb_id = request->getParam("ocpp_cb_id")->value().c_str();
+                    ocpp_validate_result_t vr = ocpp_validate_chargebox_id(cb_id);
+                    if (vr != OCPP_VALIDATE_OK) {
+                        doc["ocpp_cb_id"] = vr == OCPP_VALIDATE_EMPTY ? "ChargeBoxId is empty"
+                                          : vr == OCPP_VALIDATE_TOO_LONG ? "ChargeBoxId exceeds 20 characters"
+                                          : vr == OCPP_VALIDATE_BAD_CHARS ? "ChargeBoxId contains invalid characters"
+                                          : "Invalid ChargeBoxId";
+                    } else if (OcppWsClient) {
+                        OcppWsClient->setChargeBoxId(cb_id);
                         doc["ocpp_cb_id"] = OcppWsClient->getChargeBoxId();
                     } else {
                         doc["ocpp_cb_id"] = "Can only update when OCPP enabled";
                     }
                 }
 
                 if(request->hasParam("ocpp_auth_key")) {
-                    if (OcppWsClient) {
-                        OcppWsClient->setAuthKey(request->getParam("ocpp_auth_key")->value().c_str());
+                    const char *auth_key = request->getParam("ocpp_auth_key")->value().c_str();
+                    ocpp_validate_result_t vr = ocpp_validate_auth_key(auth_key);
+                    if (vr != OCPP_VALIDATE_OK) {
+                        doc["ocpp_auth_key"] = vr == OCPP_VALIDATE_TOO_LONG ? "Auth key exceeds 40 characters"
+                                             : "Invalid auth key";
+                    } else if (OcppWsClient) {
+                        OcppWsClient->setAuthKey(auth_key);
                         doc["ocpp_auth_key"] = OcppWsClient->getAuthKey();
                     } else {
                         doc["ocpp_auth_key"] = "Can only update when OCPP enabled";

SmartEVSE-3/src/main.cpp

@@ -55,6 +55,7 @@
 #include <MicroOcppMongooseClient.h>
 #include <MicroOcpp/Core/Configuration.h>
 #include <MicroOcpp/Core/Context.h>
+#include "ocpp_telemetry.h"
 #endif //ENABLE_OCPP
 
 extern Preferences preferences;
@@ -293,6 +294,8 @@ uint8_t OcppTrackCPvoltage = PILOT_NOK; //track positive part of CP signal for O
 MicroOcpp::MOcppMongooseClient *OcppWsClient;
 
 float OcppCurrentLimit = -1.f; // Negative value: no OCPP limit defined
+bool OcppWasStandalone = false; // Tracks LoadBl state at ocppInit() time for LB exclusivity check
+ocpp_telemetry_t OcppTelemetry; // OCPP connection and transaction telemetry
 
 unsigned long OcppStopReadingSyncTime; // Stop value synchronization: delay StopTransaction by a few seconds so it reports an accurate energy reading
 

SmartEVSE-3/src/mqtt_publish.h

@@ -76,6 +76,9 @@ typedef enum {
     MQTT_SLOT_SCHEDULE_STATE,
     MQTT_SLOT_FREE_HEAP,
     MQTT_SLOT_MQTT_MSG_COUNT,
+    MQTT_SLOT_OCPP_TX_ACTIVE,
+    MQTT_SLOT_OCPP_CURRENT_LIMIT,
+    MQTT_SLOT_OCPP_SMART_CHARGING,
     MQTT_SLOT_COUNT  /* must be <= MQTT_CACHE_MAX_SLOTS */
 } mqtt_slot_t;
 

SmartEVSE-3/src/ocpp_logic.c

@@ -54,6 +54,28 @@ bool ocpp_should_clear_access(bool permits_charge, uint8_t access_status) {
     return access_status == 1 && !permits_charge;  /* 1 = ON */
 }
 
+bool ocpp_should_defer_access(uint8_t mode, uint8_t charge_delay,
+                              uint16_t error_flags) {
+    /*
+     * When FreeVend/auto-auth is active, OCPP grants ocppPermitsCharge()
+     * unconditionally. But in Solar mode, we should defer Access_bit until
+     * the state machine's solar logic confirms surplus is available.
+     *
+     * Deferral conditions:
+     * 1. Solar mode + NO_SUN error → no solar surplus available
+     * 2. Any mode + ChargeDelay active → still in delay period
+     */
+    if (mode == MODE_SOLAR && (error_flags & NO_SUN)) {
+        return true;
+    }
+
+    if (charge_delay > 0) {
+        return true;
+    }
+
+    return false;
+}
+
 /* ---- RFID hex formatting ---- */
 
 void ocpp_format_rfid_hex(const uint8_t *rfid, size_t rfid_len,

SmartEVSE-3/src/ocpp_logic.h

@@ -52,6 +52,18 @@ bool ocpp_should_set_access(bool permits_charge, bool prev_permits_charge);
  */
 bool ocpp_should_clear_access(bool permits_charge, uint8_t access_status);
 
+/*
+ * Returns true if setting Access_bit should be deferred despite OCPP
+ * permitting charge. This guards against FreeVend/auto-auth bypassing
+ * Solar mode surplus checks or ChargeDelay.
+ *
+ *   mode          — current Mode (MODE_NORMAL=0, MODE_SMART=1, MODE_SOLAR=2)
+ *   charge_delay  — current ChargeDelay (>0 means delay active)
+ *   error_flags   — current ErrorFlags (NO_SUN bit means no solar surplus)
+ */
+bool ocpp_should_defer_access(uint8_t mode, uint8_t charge_delay,
+                              uint16_t error_flags);
+
 /* ---- RFID hex formatting ---- */
 
 #define OCPP_RFID_HEX_MAX  15  /* 7 bytes * 2 hex chars + NUL */

SmartEVSE-3/src/ocpp_telemetry.c

@@ -0,0 +1,51 @@
+/*
+ * ocpp_telemetry.c - OCPP connection and transaction telemetry
+ *
+ * Pure C counter management. All functions are simple and safe to call
+ * from any context. The struct is ~40 bytes — well within RAM budget.
+ */
+
+#include "ocpp_telemetry.h"
+#include <string.h>
+
+void ocpp_telemetry_init(ocpp_telemetry_t *t) {
+    if (!t) return;
+    memset(t, 0, sizeof(*t));
+}
+
+void ocpp_telemetry_ws_connected(ocpp_telemetry_t *t) {
+    if (!t) return;
+    t->ws_connect_count++;
+}
+
+void ocpp_telemetry_ws_disconnected(ocpp_telemetry_t *t) {
+    if (!t) return;
+    t->ws_disconnect_count++;
+}
+
+void ocpp_telemetry_tx_started(ocpp_telemetry_t *t) {
+    if (!t) return;
+    t->tx_start_count++;
+    t->tx_active = true;
+}
+
+void ocpp_telemetry_tx_stopped(ocpp_telemetry_t *t) {
+    if (!t) return;
+    t->tx_stop_count++;
+    t->tx_active = false;
+}
+
+void ocpp_telemetry_auth_accepted(ocpp_telemetry_t *t) {
+    if (!t) return;
+    t->auth_accept_count++;
+}
+
+void ocpp_telemetry_auth_rejected(ocpp_telemetry_t *t) {
+    if (!t) return;
+    t->auth_reject_count++;
+}
+
+void ocpp_telemetry_auth_timeout(ocpp_telemetry_t *t) {
+    if (!t) return;
+    t->auth_timeout_count++;
+}