Add extracted tools: CitrineOS, OpenOCPP, ShapeShifter

- CitrineOS core extracted (CSMS OCPP 2.0.1)
- OpenOCPP extracted (firmware OCPP 1.6J/2.0.1)
- ShapeShifter library installed (pip install -e)
- ShapeShifter specification extracted
- EVerest extracted

TODO updated with progress

tools/EVerest-main/modules/EVSE/EvseManager/Timeout.hpp

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+#ifndef TIMEOUT_HPP
+#define TIMEOUT_HPP
+
+#include <chrono>
+#include <sigslot/signal.hpp>
+
+#include "utils/thread.hpp"
+
+using namespace std::chrono;
+
+/*
+ Simple helper class for a polling timeout
+*/
+
+class Timeout {
+public:
+    void start(milliseconds _t) {
+        t = _t;
+        start_time = steady_clock::now();
+        running = true;
+    }
+
+    void stop() {
+        running = false;
+    }
+
+    bool is_running() {
+        return running;
+    }
+
+    bool reached() {
+        if (!running)
+            return false;
+        if ((steady_clock::now() - start_time) > t) {
+            running = false;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+private:
+    milliseconds t;
+    time_point<steady_clock> start_time;
+    bool running{false};
+};
+
+/* Simple helper class for a timeout with internal thread */
+class AsyncTimeout {
+public:
+    void start(milliseconds _t) {
+        std::scoped_lock lock(mutex);
+
+        if (running) {
+            wait_thread.stop();
+            running = false;
+        }
+
+        t = _t;
+        start_time = steady_clock::now();
+
+        // start waiting thread
+        wait_thread = std::thread([this]() {
+            while (not wait_thread.shouldExit()) {
+                std::this_thread::sleep_for(resolution);
+                if (reached_nolock()) {
+                    // Note the order is important here.
+                    // We first signal reached which will call all callbacks.
+                    // The timer is still running in this in those callbacks, so they can also call reached() and
+                    // get a true as return value.
+                    signal_reached();
+                    // After all signal handlers are called, we stop the timer.
+                    break;
+                }
+            }
+        });
+        running = true;
+    }
+
+    // Note that stopping the timer may take up to "resolution" amount of time to return
+    void stop() {
+        std::scoped_lock lock(mutex);
+        if (running) {
+            wait_thread.stop();
+            running = false;
+        }
+    }
+
+    bool is_running() {
+        std::scoped_lock lock(mutex);
+        return running;
+    }
+
+    bool reached() {
+        std::scoped_lock lock(mutex);
+        return reached_nolock();
+    }
+
+    sigslot::signal<> signal_reached;
+
+private:
+    bool reached_nolock() {
+        if (!running) {
+            return false;
+        } else if ((steady_clock::now() - start_time) > t) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    constexpr static auto resolution = 500ms;
+    milliseconds t;
+    time_point<steady_clock> start_time;
+    bool running{false};
+    std::mutex mutex;
+    Everest::Thread wait_thread;
+};
+
+#endif