expose ChargePointStatus in API (#309)

* provide ChargePointStatus in API

* change ChargePointStatus into C-style enum

* update version statement

CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## Unreleased
+
+### Changed
+
+- Change `MicroOcpp::ChargePointStatus` into C-style enum ([#309](https://github.com/matth-x/MicroOcpp/pull/309))
+
+### Added
+
+- Provide ChargePointStatus in API ([#309](https://github.com/matth-x/MicroOcpp/pull/309))
+
 ## [1.1.0] - 2024-05-21
 
 ### Changed

CMakeLists.txt

@@ -117,7 +117,7 @@ if(ESP_PLATFORM)
     return()
 endif()
 
-project(MicroOcpp VERSION 1.1.0)
+project(MicroOcpp VERSION 1.2.0)
 
 add_library(MicroOcpp ${MO_SRC})
 

library.json

@@ -1,6 +1,6 @@
 {
     "name": "MicroOcpp",
-    "version": "1.1.0",
+    "version": "1.2.0",
     "description": "OCPP 1.6 Client for microcontrollers",
     "keywords": "OCPP, 1.6, OCPP 1.6, Smart Energy, Smart Charging, client, ESP8266, ESP32, Arduino, esp-idf, EVSE, Charge Point",
     "repository":

library.properties

@@ -1,5 +1,5 @@
 name=MicroOcpp
-version=1.1.0
+version=1.2.0
 author=Matthias Akstaller
 maintainer=Matthias Akstaller
 sentence=OCPP 1.6 Client for microcontrollers

src/MicroOcpp.cpp

@@ -548,6 +548,19 @@ bool ocppPermitsCharge(unsigned int connectorId) {
     return connector->ocppPermitsCharge();
 }
 
+ChargePointStatus getChargePointStatus(unsigned int connectorId) {
+    if (!context) {
+        MO_DBG_WARN("OCPP uninitialized");
+        return ChargePointStatus_UNDEFINED;
+    }
+    auto connector = context->getModel().getConnector(connectorId);
+    if (!connector) {
+        MO_DBG_ERR("could not find connector");
+        return ChargePointStatus_UNDEFINED;
+    }
+    return connector->getStatus();
+}
+
 void setConnectorPluggedInput(std::function<bool()> pluggedInput, unsigned int connectorId) {
     if (!context) {
         MO_DBG_ERR("OCPP uninitialized"); //need to call mocpp_initialize before

src/MicroOcpp.h

@@ -17,6 +17,7 @@
 #include <MicroOcpp/Model/Transactions/Transaction.h>
 #include <MicroOcpp/Model/ConnectorBase/Notification.h>
 #include <MicroOcpp/Model/ConnectorBase/ChargePointErrorData.h>
+#include <MicroOcpp/Model/ConnectorBase/ChargePointStatus.h>
 #include <MicroOcpp/Model/ConnectorBase/UnlockConnectorResult.h>
 #include <MicroOcpp/Version.h>
 #include <MicroOcpp/Model/Certificates/Certificate.h>
@@ -244,6 +245,11 @@ std::shared_ptr<MicroOcpp::Transaction>& getTransaction(unsigned int connectorId
  */
 bool ocppPermitsCharge(unsigned int connectorId = 1);
 
+/*
+ * Returns the latest ChargePointStatus as reported via StatusNotification (standard OCPP data type)
+ */
+ChargePointStatus getChargePointStatus(unsigned int connectorId = 1);
+
 /*
  * Define the Inputs and Outputs of this library.
  * 

src/MicroOcpp/Model/Authorization/AuthorizationService.cpp

@@ -180,7 +180,7 @@ void AuthorizationService::notifyAuthorization(const char *idTag, JsonObject idT
     if (!equivalent) {
         //send error code "LocalListConflict" to server
 
-        ChargePointStatus cpStatus = ChargePointStatus::NOT_SET;
+        ChargePointStatus cpStatus = ChargePointStatus_UNDEFINED;
         if (context.getModel().getNumConnectors() > 0) {
             cpStatus = context.getModel().getConnector(0)->getStatus();
         }

src/MicroOcpp/Model/ConnectorBase/ChargePointStatus.h

@@ -2,31 +2,35 @@
 // Copyright Matthias Akstaller 2019 - 2024
 // MIT License
 
-#ifndef OCPP_EVSE_STATE
-#define OCPP_EVSE_STATE
+#ifndef MO_CHARGEPOINTSTATUS_H
+#define MO_CHARGEPOINTSTATUS_H
 
 #include <MicroOcpp/Version.h>
 
-namespace MicroOcpp {
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-enum class ChargePointStatus {
-    Available,
-    Preparing,
-    Charging,
-    SuspendedEVSE,
-    SuspendedEV,
-    Finishing,
-    Reserved,
-    Unavailable,
-    Faulted,
+typedef enum ChargePointStatus {
+    ChargePointStatus_UNDEFINED, //internal use only - no OCPP standard value 
+    ChargePointStatus_Available,
+    ChargePointStatus_Preparing,
+    ChargePointStatus_Charging,
+    ChargePointStatus_SuspendedEVSE,
+    ChargePointStatus_SuspendedEV,
+    ChargePointStatus_Finishing,
+    ChargePointStatus_Reserved,
+    ChargePointStatus_Unavailable,
+    ChargePointStatus_Faulted
 
 #if MO_ENABLE_V201
-    Occupied,
+    ,ChargePointStatus_Occupied
 #endif
 
-    NOT_SET //internal value for "undefined"
-};
+}   ChargePointStatus;
 
-} //end namespace MicroOcpp
+#ifdef __cplusplus
+}
+#endif
 
 #endif

src/MicroOcpp/Model/ConnectorBase/Connector.cpp

@@ -79,79 +79,79 @@ Connector::~Connector() {
 
 ChargePointStatus Connector::getStatus() {
 
-    ChargePointStatus res = ChargePointStatus::NOT_SET;
+    ChargePointStatus res = ChargePointStatus_UNDEFINED;
 
     /*
     * Handle special case: This is the Connector for the whole CP (i.e. connectorId=0) --> only states Available, Unavailable, Faulted are possible
     */
     if (connectorId == 0) {
         if (isFaulted()) {
-            res = ChargePointStatus::Faulted;
+            res = ChargePointStatus_Faulted;
         } else if (!isOperative()) {
-            res = ChargePointStatus::Unavailable;
+            res = ChargePointStatus_Unavailable;
         } else {
-            res = ChargePointStatus::Available;
+            res = ChargePointStatus_Available;
         }
         return res;
     }
 
     if (isFaulted()) {
-        res = ChargePointStatus::Faulted;
+        res = ChargePointStatus_Faulted;
     } else if (!isOperative()) {
-        res = ChargePointStatus::Unavailable;
+        res = ChargePointStatus_Unavailable;
     } else if (transaction && transaction->isRunning()) {
         //Transaction is currently running
         if (connectorPluggedInput && !connectorPluggedInput()) { //special case when StopTransactionOnEVSideDisconnect is false
-            res = ChargePointStatus::SuspendedEV;
+            res = ChargePointStatus_SuspendedEV;
         } else if (!ocppPermitsCharge() ||
                 (evseReadyInput && !evseReadyInput())) { 
-            res = ChargePointStatus::SuspendedEVSE;
+            res = ChargePointStatus_SuspendedEVSE;
         } else if (evReadyInput && !evReadyInput()) {
-            res = ChargePointStatus::SuspendedEV;
+            res = ChargePointStatus_SuspendedEV;
         } else {
-            res = ChargePointStatus::Charging;
+            res = ChargePointStatus_Charging;
         }
     }
     #if MO_ENABLE_RESERVATION
     else if (model.getReservationService() && model.getReservationService()->getReservation(connectorId)) {
-        res = ChargePointStatus::Reserved;
+        res = ChargePointStatus_Reserved;
     }
     #endif 
     else if ((!transaction || !transaction->isActive()) &&                 //no transaction preparation
                (!connectorPluggedInput || !connectorPluggedInput()) &&   //no vehicle plugged
                (!occupiedInput || !occupiedInput())) {                       //occupied override clear
-        res = ChargePointStatus::Available;
+        res = ChargePointStatus_Available;
     } else {
         /*
          * Either in Preparing or Finishing state. Only way to know is from previous state
          */
         const auto previous = currentStatus;
-        if (previous == ChargePointStatus::Finishing ||
-                previous == ChargePointStatus::Charging ||
-                previous == ChargePointStatus::SuspendedEV ||
-                previous == ChargePointStatus::SuspendedEVSE) {
-            res = ChargePointStatus::Finishing;
+        if (previous == ChargePointStatus_Finishing ||
+                previous == ChargePointStatus_Charging ||
+                previous == ChargePointStatus_SuspendedEV ||
+                previous == ChargePointStatus_SuspendedEVSE) {
+            res = ChargePointStatus_Finishing;
         } else {
-            res = ChargePointStatus::Preparing;
+            res = ChargePointStatus_Preparing;
         }
     }
 
 #if MO_ENABLE_V201
     if (model.getVersion().major == 2) {
         //OCPP 2.0.1: map v1.6 status onto v2.0.1
-        if (res == ChargePointStatus::Preparing ||
-                res == ChargePointStatus::Charging ||
-                res == ChargePointStatus::SuspendedEV ||
-                res == ChargePointStatus::SuspendedEVSE ||
-                res == ChargePointStatus::Finishing) {
-            res = ChargePointStatus::Occupied;
+        if (res == ChargePointStatus_Preparing ||
+                res == ChargePointStatus_Charging ||
+                res == ChargePointStatus_SuspendedEV ||
+                res == ChargePointStatus_SuspendedEVSE ||
+                res == ChargePointStatus_Finishing) {
+            res = ChargePointStatus_Occupied;
         }
     }
 #endif
 
-    if (res == ChargePointStatus::NOT_SET) {
+    if (res == ChargePointStatus_UNDEFINED) {
         MO_DBG_DEBUG("status undefined");
-        return ChargePointStatus::Faulted; //internal error
+        return ChargePointStatus_Faulted; //internal error
     }
 
     return res;
@@ -429,7 +429,7 @@ void Connector::loop() {
 
     if (status != currentStatus) {
         MO_DBG_DEBUG("Status changed %s -> %s %s",
-                currentStatus == ChargePointStatus::NOT_SET ? "" : cstrFromOcppEveState(currentStatus),
+                currentStatus == ChargePointStatus_UNDEFINED ? "" : cstrFromOcppEveState(currentStatus),
                 cstrFromOcppEveState(status),
                 minimumStatusDurationInt->getInt() ? " (will report delayed)" : "");
         currentStatus = status;

src/MicroOcpp/Model/ConnectorBase/Connector.h

@@ -44,9 +44,9 @@ class Connector {
     bool isFaulted();
     const char *getErrorCode();
 
-    ChargePointStatus currentStatus = ChargePointStatus::NOT_SET;
+    ChargePointStatus currentStatus = ChargePointStatus_UNDEFINED;
     std::shared_ptr<Configuration> minimumStatusDurationInt; //in seconds
-    ChargePointStatus reportedStatus = ChargePointStatus::NOT_SET;
+    ChargePointStatus reportedStatus = ChargePointStatus_UNDEFINED;
     unsigned long t_statusTransition = 0;
 
     std::function<UnlockConnectorResult()> onUnlockConnector;

src/MicroOcpp/Model/ConnectorBase/ConnectorsCommon.cpp

@@ -83,7 +83,7 @@ ConnectorsCommon::ConnectorsCommon(Context& context, unsigned int numConn, std::
     }
     // OCPP 1.6 + 2.0.1 compliant echo messages
     context.getOperationRegistry().registerOperation("StatusNotification", [&context] () {
-        return new Ocpp16::StatusNotification(-1, ChargePointStatus::NOT_SET, Timestamp());});
+        return new Ocpp16::StatusNotification(-1, ChargePointStatus_UNDEFINED, Timestamp());});
 }
 
 void ConnectorsCommon::loop() {

src/MicroOcpp/Model/Reservation/ReservationService.cpp

@@ -46,7 +46,7 @@ void ReservationService::loop() {
 
             //check if connector went inoperative
             auto cStatus = connector->getStatus();
-            if (cStatus == ChargePointStatus::Faulted || cStatus == ChargePointStatus::Unavailable) {
+            if (cStatus == ChargePointStatus_Faulted || cStatus == ChargePointStatus_Unavailable) {
                 reservation->clear();
                 continue;
             }
@@ -157,7 +157,7 @@ Reservation *ReservationService::getReservation(unsigned int connectorId, const
             continue;
         }
         if (auto connector = context.getModel().getConnector(cId)) {
-            if (connector->getStatus() == ChargePointStatus::Available) {
+            if (connector->getStatus() == ChargePointStatus_Available) {
                 availableCount++;
             }
         }

src/MicroOcpp/Model/Reset/ResetService.cpp

@@ -58,7 +58,7 @@ void ResetService::loop() {
                 connector->setAvailabilityVolatile(true);
             }
 
-            ChargePointStatus cpStatus = ChargePointStatus::NOT_SET;
+            ChargePointStatus cpStatus = ChargePointStatus_UNDEFINED;
             if (context.getModel().getNumConnectors() > 0) {
                 cpStatus = context.getModel().getConnector(0)->getStatus();
             }

src/MicroOcpp/Operations/ReserveNow.cpp

@@ -87,19 +87,19 @@ void ReserveNow::processReq(JsonObject payload) {
             connector = model.getConnector((unsigned int) connectorId);
         }
 
-        if (chargePoint->getStatus() == ChargePointStatus::Faulted ||
-                (connector && connector->getStatus() == ChargePointStatus::Faulted)) {
+        if (chargePoint->getStatus() == ChargePointStatus_Faulted ||
+                (connector && connector->getStatus() == ChargePointStatus_Faulted)) {
             reservationStatus = "Faulted";
             return;
         }
 
-        if (chargePoint->getStatus() == ChargePointStatus::Unavailable ||
-                (connector && connector->getStatus() == ChargePointStatus::Unavailable)) {
+        if (chargePoint->getStatus() == ChargePointStatus_Unavailable ||
+                (connector && connector->getStatus() == ChargePointStatus_Unavailable)) {
             reservationStatus = "Unavailable";
             return;
         }
 
-        if (connector && connector->getStatus() != ChargePointStatus::Available) {
+        if (connector && connector->getStatus() != ChargePointStatus_Available) {
             reservationStatus = "Occupied";
             return;
         }

src/MicroOcpp/Operations/StatusNotification.cpp

@@ -13,33 +13,33 @@ namespace MicroOcpp {
 //helper function
 const char *cstrFromOcppEveState(ChargePointStatus state) {
     switch (state) {
-        case (ChargePointStatus::Available):
+        case (ChargePointStatus_Available):
             return "Available";
-        case (ChargePointStatus::Preparing):
+        case (ChargePointStatus_Preparing):
             return "Preparing";
-        case (ChargePointStatus::Charging):
+        case (ChargePointStatus_Charging):
             return "Charging";
-        case (ChargePointStatus::SuspendedEVSE):
+        case (ChargePointStatus_SuspendedEVSE):
             return "SuspendedEVSE";
-        case (ChargePointStatus::SuspendedEV):
+        case (ChargePointStatus_SuspendedEV):
             return "SuspendedEV";
-        case (ChargePointStatus::Finishing):
+        case (ChargePointStatus_Finishing):
             return "Finishing";
-        case (ChargePointStatus::Reserved):
+        case (ChargePointStatus_Reserved):
             return "Reserved";
-        case (ChargePointStatus::Unavailable):
+        case (ChargePointStatus_Unavailable):
             return "Unavailable";
-        case (ChargePointStatus::Faulted):
+        case (ChargePointStatus_Faulted):
             return "Faulted";
 #if MO_ENABLE_V201
-        case (ChargePointStatus::Occupied):
+        case (ChargePointStatus_Occupied):
             return "Occupied";
 #endif
         default:
             MO_DBG_ERR("ChargePointStatus not specified");
             /* fall through */
-        case (ChargePointStatus::NOT_SET):
-            return "NOT_SET";
+        case (ChargePointStatus_UNDEFINED):
+            return "UNDEFINED";
     }
 }
 
@@ -48,7 +48,7 @@ namespace Ocpp16 {
 StatusNotification::StatusNotification(int connectorId, ChargePointStatus currentStatus, const Timestamp &timestamp, ErrorData errorData)
         : connectorId(connectorId), currentStatus(currentStatus), timestamp(timestamp), errorData(errorData) {
 
-    if (currentStatus != ChargePointStatus::NOT_SET) {
+    if (currentStatus != ChargePointStatus_UNDEFINED) {
         MO_DBG_INFO("New status: %s (connectorId %d)", cstrFromOcppEveState(currentStatus), connectorId);
     }
 }
@@ -75,7 +75,7 @@ std::unique_ptr<DynamicJsonDocument> StatusNotification::createReq() {
         if (errorData.vendorErrorCode) {
             payload["vendorErrorCode"] = errorData.vendorErrorCode;
         }
-    } else if (currentStatus == ChargePointStatus::NOT_SET) {
+    } else if (currentStatus == ChargePointStatus_UNDEFINED) {
         MO_DBG_ERR("Reporting undefined status");
         payload["errorCode"] = "InternalError";
     } else {