simplify Context and Model (WIP)

Author: matth-x

CMakeLists.txt

@@ -1,5 +1,5 @@
 # matth-x/MicroOcpp
-# Copyright Matthias Akstaller 2019 - 2024
+# Copyright Matthias Akstaller 2019 - 2025
 # MIT License
 
 cmake_minimum_required(VERSION 3.15)
@@ -77,12 +77,11 @@ set(MO_SRC
     src/MicroOcpp/Model/Certificates/Certificate_c.cpp
     src/MicroOcpp/Model/Certificates/CertificateMbedTLS.cpp
     src/MicroOcpp/Model/Certificates/CertificateService.cpp
-    src/MicroOcpp/Model/ConnectorBase/ConnectorsCommon.cpp
+    src/MicroOcpp/Model/ConnectorBase/ConnectorService.cpp
     src/MicroOcpp/Model/ConnectorBase/Connector.cpp
     src/MicroOcpp/Model/Diagnostics/DiagnosticsService.cpp
     src/MicroOcpp/Model/FirmwareManagement/FirmwareService.cpp
     src/MicroOcpp/Model/Heartbeat/HeartbeatService.cpp
-    src/MicroOcpp/Model/Metering/MeteringConnector.cpp
     src/MicroOcpp/Model/Metering/MeteringService.cpp
     src/MicroOcpp/Model/Metering/MeterStore.cpp
     src/MicroOcpp/Model/Metering/MeterValue.cpp

src/MicroOcpp.cpp

@@ -8,7 +8,7 @@
 #include <MicroOcpp/Model/Model.h>
 #include <MicroOcpp/Model/Metering/MeteringService.h>
 #include <MicroOcpp/Model/SmartCharging/SmartChargingService.h>
-#include <MicroOcpp/Model/ConnectorBase/ConnectorsCommon.h>
+#include <MicroOcpp/Model/ConnectorBase/ConnectorService.h>
 #include <MicroOcpp/Model/Heartbeat/HeartbeatService.h>
 #include <MicroOcpp/Model/FirmwareManagement/FirmwareService.h>
 #include <MicroOcpp/Model/Diagnostics/DiagnosticsService.h>
@@ -48,10 +48,6 @@ Connection *connection {nullptr};
 Context *context {nullptr};
 std::shared_ptr<FilesystemAdapter> filesystem;
 
-#ifndef MO_NUMCONNECTORS
-#define MO_NUMCONNECTORS 2
-#endif
-
 #define OCPP_ID_OF_CP 0
 #define OCPP_ID_OF_CONNECTOR 1
 
@@ -300,8 +296,8 @@ void mocpp_initialize(Connection& connection, const char *bootNotificationCreden
     {
         model.setTransactionStore(std::unique_ptr<TransactionStore>(
             new TransactionStore(MO_NUMCONNECTORS, filesystem)));
-        model.setConnectorsCommon(std::unique_ptr<ConnectorsCommon>(
-            new ConnectorsCommon(*context, MO_NUMCONNECTORS, filesystem)));
+        model.setConnectorService(std::unique_ptr<ConnectorService>(
+            new ConnectorService(*context, MO_NUMCONNECTORS, filesystem)));
         auto connectors = makeVector<std::unique_ptr<Connector>>("v16.ConnectorBase.Connector");
         for (unsigned int connectorId = 0; connectorId < MO_NUMCONNECTORS; connectorId++) {
             connectors.emplace_back(new Connector(*context, filesystem, connectorId));

src/MicroOcpp/Core/Connection.h

@@ -40,10 +40,11 @@ class Connection {
     virtual bool sendTXT(const char *msg, size_t length) = 0;
 
     /*
+     * Pass incoming data from the server to this function. The OCPP library will consume it
      * The OCPP library calls this function once during initialization. It passes a callback function to
      * the socket. The socket should forward any incoming payload from the OCPP server to the receiveTXT callback
      */
-    virtual void setReceiveTXTcallback(ReceiveTXTcallback &receiveTXT) = 0;
+    bool recvTXT(const char *msg, size_t len) = 0;
 
     /*
      * Returns the timestamp of the last incoming message. Use mocpp_tick_ms() for creating the correct timestamp

src/MicroOcpp/Core/Context.cpp

@@ -3,37 +3,135 @@
 // MIT License
 
 #include <MicroOcpp/Core/Context.h>
-#include <MicroOcpp/Core/Request.h>
 #include <MicroOcpp/Core/Connection.h>
-#include <MicroOcpp/Model/Model.h>
+#include <MicroOcpp/Core/FilesystemAdapter.h>
+#include <MicroOcpp/Core/Ftp.h>
 
 #include <MicroOcpp/Debug.h>
 
 using namespace MicroOcpp;
 
-Context::Context(Connection& connection, std::shared_ptr<FilesystemAdapter> filesystem, uint16_t bootNr, ProtocolVersion version)
-        : MemoryManaged("Context"), connection(connection), model{version, bootNr}, reqQueue{connection, operationRegistry} {
+Context::Context() : MemoryManaged("Context") {
 
 }
 
 Context::~Context() {
+    if (filesystem && isFilesystemOwner) {
+        delete filesystem;
+        filesystem = nullptr;
+        isFilesystemOwner = false;
+    }
+
+    if (connection && isConnectionOwner) {
+        delete connection;
+        connection = nullptr;
+        isConnectionOwner = false;
+    }
 
+    if (ftpClient && isFtpClientOwner) {
+        delete ftpClient;
+        ftpClient = nullptr;
+        isFtpClientOwner = false;
+    }
+}
+
+void Context::setDebugCb(void (*debugCb)(const char *msg)) {
+    this->debugCb = debugCb;
+}
+
+void Context::setDebugCb2(void (*debugCb2)(int lvl, const char *fn, int line, const char *msg)) {
+    this->debugCb2 = debugCb2;
+}
+
+void Context::setTicksCb(unsigned long (*ticksCb)()) {
+    this->ticksCb = ticksCb;
+}
+
+void Context::setFilesystemAdapter(FilesystemAdapter *filesystem) {
+    if (this->filesystem && isFilesystemOwner) {
+        delete this->filesystem;
+        this->filesystem = nullptr;
+        isFilesystemOwner = false;
+    }
+    this->filesystem = filesystem;
 }
 
+FilesystemAdapter *Context::getFilesystemAdapter() {
+    return filesystem;
+}
+
+void Context::setConnection(Connection *connection) {
+    if (connection && isConnectionOwner) {
+        delete connection;
+        connection = nullptr;
+        isConnectionOwner = false;
+    }
+    this->connection = connection;
+}
+
+Connection *Context::getConnection() {
+    return connection;
+}
+
+void Context::setFtpClient(FtpClient *ftpClient) {
+    if (ftpClient && isFtpClientOwner) {
+        delete ftpClient;
+        ftpClient = nullptr;
+        isFtpClientOwner = false;
+    }
+    ftpClient = ftpClient;
+}
+
+FtpClient *Context::getFtpClient() {
+    return ftpClient;
+}
+
+bool Context::setup(int protocolVersion) {
+
+}
+
+    void Context::loop();
+
+    Model& getModel();
+
+    OperationRegistry& getOperationRegistry();
+
+    RequestQueue& getRequestQueue();
+
+    const ProtocolVersion& getVersion();
+};
+
+} //end namespace MicroOcpp
+
+#endif // __cplusplus
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+struct mo_context;
+typedef struct mo_context mo_context;
+
+mo_context *mo_context_make();
+
+void mo_context_free(mo_context *ctx);
+
+void mo_context_dbg_cb_set(mo_context *ctx, void (*debug_cb)(const char *msg));
+
+void mo_context_dbg_cb2_set(mo_context *ctx, void (*debug_cb)(int lvl, const char *fn, int line, const char *msg));
+
+void mo_context_ticks_cb_set(unsigned long (*ticksCb)());
+
+bool mo_context_setup(mo_context *ctx, int protocol_version);
+
+void mo_context_loop(mo_context *ctx);
+
 void Context::loop() {
     connection.loop();
     reqQueue.loop();
     model.loop();
 }
 
-void Context::initiateRequest(std::unique_ptr<Request> op) {
-    if (!op) {
-        MO_DBG_ERR("invalid arg");
-        return;
-    }
-    reqQueue.sendRequest(std::move(op));
-}
-
 Model& Context::getModel() {
     return model;
 }

src/MicroOcpp/Core/Context.h

@@ -1,55 +1,99 @@
 // matth-x/MicroOcpp
-// Copyright Matthias Akstaller 2019 - 2024
+// Copyright Matthias Akstaller 2019 - 2025
 // MIT License
 
 #ifndef MO_CONTEXT_H
 #define MO_CONTEXT_H
 
-#include <memory>
-
+#include <MicroOcpp/Model/Model.h>
 #include <MicroOcpp/Core/OperationRegistry.h>
 #include <MicroOcpp/Core/RequestQueue.h>
 #include <MicroOcpp/Core/Memory.h>
-#include <MicroOcpp/Core/Ftp.h>
-#include <MicroOcpp/Model/Model.h>
 #include <MicroOcpp/Version.h>
 
+#ifdef __cplusplus
+
 namespace MicroOcpp {
 
-class Connection;
 class FilesystemAdapter;
+class Connection;
+class FtpClient;
 
 class Context : public MemoryManaged {
 private:
-    Connection& connection;
-    OperationRegistry operationRegistry;
+    void (*debugCb)(const char *msg) = nullptr;
+    void (*debugCb2)(int lvl, const char *fn, int line, const char *msg) = nullptr;
+
+    unsigned long (*ticksCb)() = nullptr;
+    
+    FilesystemAdapter *filesystem = nullptr;
+    Connection *connection = nullptr;
+    FtpClient *ftpClient = nullptr;
+
     Model model;
+    OperationRegistry operationRegistry;
     RequestQueue reqQueue;
 
-    std::unique_ptr<FtpClient> ftpClient;
+    bool isFilesystemOwner = false;
+    bool isConnectionOwner = false;
+    bool isFtpClientOwner = false;
 
 public:
-    Context(Connection& connection, std::shared_ptr<FilesystemAdapter> filesystem, uint16_t bootNr, ProtocolVersion version);
+    Context();
     ~Context();
 
-    void loop();
+    void setDebugCb(void (*debugCb)(const char *msg));
+    void setDebugCb2(void (*debugCb2)(int lvl, const char *fn, int line, const char *msg));
+
+    void setTicksCb(unsigned long (*ticksCb)());
 
-    void initiateRequest(std::unique_ptr<Request> op);
+    void setFilesystemAdapter(FilesystemAdapter *filesystem);
+    FilesystemAdapter *getFilesystemAdapter();
+
+    void setConnection(Connection *connection);
+    Connection *getConnection();
+
+    void setFtpClient(FtpClient *ftpClient);
+    FtpClient *getFtpClient();
 
     Model& getModel();
 
-    OperationRegistry& getOperationRegistry();
+    bool setup(int ocppVersion);
 
-    const ProtocolVersion& getVersion();
+    void loop();
 
-    Connection& getConnection();
+    OperationRegistry& getOperationRegistry();
 
     RequestQueue& getRequestQueue();
-
-    void setFtpClient(std::unique_ptr<FtpClient> ftpClient);
-    FtpClient *getFtpClient();
 };
 
 } //end namespace MicroOcpp
 
+#endif // __cplusplus
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+struct mo_context;
+typedef struct mo_context mo_context;
+
+mo_context *mo_context_make();
+
+void mo_context_free(mo_context *ctx);
+
+void mo_context_dbg_cb_set(mo_context *ctx, void (*debug_cb)(const char *msg));
+
+void mo_context_dbg_cb2_set(mo_context *ctx, void (*debug_cb)(int lvl, const char *fn, int line, const char *msg));
+
+void mo_context_ticks_cb_set(unsigned long (*ticksCb)());
+
+bool mo_context_setup(mo_context *ctx, int ocpp_version);
+
+void mo_context_loop(mo_context *ctx);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus
+
 #endif

src/MicroOcpp/Core/RequestQueue.h

@@ -83,6 +83,10 @@ class RequestQueue : public MemoryManaged {
     void sendRequest(std::unique_ptr<Request> request); //send an OCPP operation request to the server; adds request to default queue
     void sendRequestPreBoot(std::unique_ptr<Request> request); //send an OCPP operation request to the server; adds request to preBootQueue
 
+    void handleRequest(const char *operationType, Operation* (*createOperationCb)(const char *operationType, void* user_data), void *user_data = nullptr);
+    void setOnRequest(const char *operationType, void (*onRequest)(const char *payloadJson, size_t len));
+    void setOnConfirmation(const char *operationType, void (*onConfirmation)(const char *payloadJson, size_t len));
+
     void addSendQueue(RequestEmitter* sendQueue);
     void setPreBootSendQueue(VolatileRequestQueue *preBootQueue);
 

src/MicroOcpp/Core/Time.h

@@ -26,18 +26,10 @@ namespace MicroOcpp {
 
 class Timestamp : public MemoryManaged {
 private:
-    /*
-     * Internal representation of the current time. The initial values correspond to UNIX-time 0. January
-     * corresponds to month 0 and the first day in the month is day 0.
-     */
-    int16_t year = 1970;
-    int16_t month = 0;
-    int16_t day = 0;
-    int32_t hour = 0;
-    int32_t minute = 0;
-    int32_t second = 0;
+    int32_t time; //Unix time (number of seconds since Jan 1, 1970 UTC, not counting leap seconds)
+
 #if MO_ENABLE_TIMESTAMP_MILLISECONDS
-    int32_t ms = 0;
+    int16_t ms = 0; //fractional ms of timestamp. Compound timestamp = time + ms. Range should be [0, 999]
 #endif //MO_ENABLE_TIMESTAMP_MILLISECONDS
 
 public:
@@ -83,6 +75,8 @@ class Timestamp : public MemoryManaged {
 
     int operator-(const Timestamp &rhs) const;
 
+    operator int32_t() const;
+
     friend Timestamp operator+(const Timestamp &lhs, int secs);
     friend Timestamp operator-(const Timestamp &lhs, int secs);