Merge branch 'main' into feature/v201-api-upgrade

Author: matth-x

CHANGELOG.md

@@ -5,6 +5,11 @@
 ### Changed
 
 - Change `MicroOcpp::TxNotification` into C-style enum, replace `OCPP_TxNotication`
+- Improved UUID generation ([#383](https://github.com/matth-x/MicroOcpp/pull/383))
+
+### Fixed
+
+- Timing issues for OCTT test cases ([#383](https://github.com/matth-x/MicroOcpp/pull/383))
 
 ## [1.2.0] - 2024-11-03
 

CMakeLists.txt

@@ -23,6 +23,7 @@ set(MO_SRC
     src/MicroOcpp/Core/Request.cpp
     src/MicroOcpp/Core/Connection.cpp
     src/MicroOcpp/Core/Time.cpp
+    src/MicroOcpp/Core/UuidUtils.cpp
     src/MicroOcpp/Operations/Authorize.cpp
     src/MicroOcpp/Operations/BootNotification.cpp
     src/MicroOcpp/Operations/CancelReservation.cpp

src/MicroOcpp/Core/Request.cpp

@@ -6,6 +6,7 @@
 #include <MicroOcpp/Core/Operation.h>
 #include <MicroOcpp/Core/Connection.h>
 #include <MicroOcpp/Model/Transactions/Transaction.h>
+#include <MicroOcpp/Core/UuidUtils.h>
 
 #include <MicroOcpp/Operations/StartTransaction.h>
 #include <MicroOcpp/Operations/StopTransaction.h>
@@ -68,16 +69,9 @@ void Request::setMessageID(const char *id){
 Request::CreateRequestResult Request::createRequest(JsonDoc& requestJson) {
 
     if (messageID.empty()) {
-        unsigned char random [18];
-        char guuid [sizeof(random) * 2 + 1];
-
-        writeRandomNonsecure(random, sizeof(random));
-
-        for (size_t i = 0; i < sizeof(random); i++) {
-            snprintf(guuid + i * 2, 3, "%02x", random[i]);
-        }
-        guuid[8] = guuid[13] = guuid[18] = guuid[23] = '-';
-        messageID = guuid;
+        char uuid [37] = {'\0'};
+        generateUUID(uuid, 37);
+        messageID = uuid;
     }
 
     /*

src/MicroOcpp/Core/Time.cpp

@@ -255,6 +255,13 @@ int Timestamp::operator-(const Timestamp &rhs) const {
     }
 
     int dt = (lhsDays - rhsDays) * (24 * 3600) + (hour - rhs.hour) * 3600 + (minute - rhs.minute) * 60 + second - rhs.second;
+
+#if MO_ENABLE_TIMESTAMP_MILLISECONDS
+    // Make it so that we round the difference to the nearest second, instead of being up to almost a whole second off
+    if ((ms - rhs.ms) > 500) dt++;
+    if ((ms - rhs.ms) < -500) dt--;
+#endif //MO_ENABLE_TIMESTAMP_MILLISECONDS
+
     return dt;
 }
 

src/MicroOcpp/Core/UuidUtils.cpp

@@ -0,0 +1,56 @@
+#include <MicroOcpp/Core/UuidUtils.h>
+#include <MicroOcpp/Platform.h>
+
+#include <stdint.h>
+
+namespace MicroOcpp {
+
+#define UUID_STR_LEN 36
+
+bool generateUUID(char *uuidBuffer, size_t len) {
+  if (len < UUID_STR_LEN + 1)
+  {
+    return false;
+  }
+
+  uint32_t ar[4];
+  for (uint8_t i = 0; i < 4; i++) {
+    ar[i] = mocpp_rng();
+  }
+
+  // Conforming to RFC 4122 Specification
+  // - byte 7: four most significant bits ==> 0100  --> always 4
+  // - byte 9: two  most significant bits ==> 10    --> always {8, 9, A, B}.
+  //
+  // patch bits for version 1 and variant 4 here
+  ar[1] &= 0xFFF0FFFF;   //  remove 4 bits.
+  ar[1] |= 0x00040000;   //  variant 4
+  ar[2] &= 0xFFFFFFF3;   //  remove 2 bits
+  ar[2] |= 0x00000008;   //  version 1
+
+  // loop through the random 16 byte array
+  for (uint8_t i = 0, j = 0; i < 16; i++) {
+    // multiples of 4 between 8 and 20 get a -.
+    // note we are processing 2 digits in one loop.
+    if ((i & 0x1) == 0) {
+      if ((4 <= i) && (i <= 10)) {
+        uuidBuffer[j++] = '-';
+      }
+    }
+
+    // encode the byte as two hex characters
+    uint8_t nr   = i / 4;
+    uint8_t xx   = ar[nr];
+    uint8_t ch   = xx & 0x0F;
+    uuidBuffer[j++] = (ch < 10)? '0' + ch : ('a' - 10) + ch;
+
+    ch = (xx >> 4) & 0x0F;
+    ar[nr] >>= 8;
+    uuidBuffer[j++] = (ch < 10)? '0' + ch : ('a' - 10) + ch;
+  }
+
+  uuidBuffer[UUID_STR_LEN] = 0;
+  return true;
+}
+
+}

src/MicroOcpp/Core/UuidUtils.h

@@ -0,0 +1,14 @@
+#ifndef MO_UUIDUTILS_H
+#define MO_UUIDUTILS_H
+
+#include <stddef.h>
+namespace MicroOcpp {
+
+// Generates a UUID (Universally Unique Identifier) and writes it into a given buffer
+// Returns false if the generation failed
+// The buffer must be at least 37 bytes long (36 characters + zero termination)
+bool generateUUID(char *uuidBuffer, size_t len);
+
+}
+
+#endif

src/MicroOcpp/Model/ConnectorBase/Connector.cpp

@@ -305,7 +305,7 @@ void Connector::loop() {
                     transaction->getBeginTimestamp() > MIN_TIME &&
                     connectionTimeOutInt && connectionTimeOutInt->getInt() > 0 &&
                     !connectorPluggedInput() &&
-                    model.getClock().now() - transaction->getBeginTimestamp() >= connectionTimeOutInt->getInt()) {
+                    model.getClock().now() - transaction->getBeginTimestamp() > connectionTimeOutInt->getInt()) {
 
                 MO_DBG_INFO("Session mngt: timeout");
                 transaction->setInactive();

src/MicroOcpp/Model/Heartbeat/HeartbeatService.cpp

@@ -29,6 +29,8 @@ void HeartbeatService::loop() {
         lastHeartbeat = now;
 
         auto heartbeat = makeRequest(new Ocpp16::Heartbeat(context.getModel()));
+        // Heartbeats can not deviate more than 4s from the configured interval
+        heartbeat->setTimeout(std::min(4000UL, hbInterval));
         context.initiateRequest(std::move(heartbeat));
     }
 }

src/MicroOcpp/Model/Metering/MeteringConnector.cpp

@@ -90,7 +90,7 @@ void MeteringConnector::loop() {
 
         auto& timestampNow = model.getClock().now();
         auto dt = nextAlignedTime - timestampNow;
-        if (dt <= 0 ||                              //normal case: interval elapsed
+        if (dt < 0 ||                              //normal case: interval elapsed
                 dt > clockAlignedDataIntervalInt->getInt()) {   //special case: clock has been adjusted or first run
 
             MO_DBG_DEBUG("Clock aligned measurement %ds: %s", dt,

src/MicroOcpp/Platform.cpp

@@ -82,3 +82,31 @@ unsigned long mocpp_tick_ms_unix() {
 }
 #endif
 #endif
+
+#ifdef MO_CUSTOM_RNG
+uint32_t (*mocpp_rng_impl)() = nullptr;
+
+void mocpp_set_rng(uint32_t (*rng)()) {
+    mocpp_rng_impl = rng;
+}
+
+uint32_t mocpp_rng_custom(void) {
+    if (mocpp_rng_impl) {
+        return mocpp_rng_impl();
+    } else {
+        return 0;
+    }
+}
+#else
+
+// Time-based Pseudo RNG.
+// Contains internal state which is mixed with the current timestamp
+// each time it is called. Then this is passed through a multiply-with-carry
+// PRNG operation to get a pseudo-random number.
+uint32_t mocpp_time_based_prng(void) {
+    static uint32_t prng_state = 1;
+    uint32_t entropy = mocpp_tick_ms();
+    prng_state = (prng_state ^ entropy)*1664525U + 1013904223U; // assuming complement-2 integers and non-signaling overflow
+    return prng_state;
+}
+#endif