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/StaticISO15118VASProvider/CMakeLists.txt

@@ -0,0 +1,25 @@
+#
+# AUTO GENERATED - MARKED REGIONS WILL BE KEPT
+# template version 3
+#
+
+# module setup:
+#   - ${MODULE_NAME}: module name
+ev_setup_cpp_module()
+
+# ev@bcc62523-e22b-41d7-ba2f-825b493a3c97:v1
+# insert your custom targets and additional config variables here
+target_link_libraries(${MODULE_NAME}
+    PRIVATE
+        everest::yaml
+)
+# ev@bcc62523-e22b-41d7-ba2f-825b493a3c97:v1
+
+target_sources(${MODULE_NAME}
+    PRIVATE
+        "iso15118_vas/ISO15118_vasImpl.cpp"
+)
+
+# ev@c55432ab-152c-45a9-9d2e-7281d50c69c3:v1
+# insert other things like install cmds etc here
+# ev@c55432ab-152c-45a9-9d2e-7281d50c69c3:v1

tools/EVerest-main/modules/EVSE/StaticISO15118VASProvider/StaticISO15118VASProvider.cpp

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+#include "StaticISO15118VASProvider.hpp"
+
+namespace module {
+
+void StaticISO15118VASProvider::init() {
+    invoke_init(*p_iso15118_vas);
+}
+
+void StaticISO15118VASProvider::ready() {
+    invoke_ready(*p_iso15118_vas);
+}
+
+} // namespace module

tools/EVerest-main/modules/EVSE/StaticISO15118VASProvider/StaticISO15118VASProvider.hpp

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+#ifndef STATIC_ISO15118VASPROVIDER_HPP
+#define STATIC_ISO15118VASPROVIDER_HPP
+
+//
+// AUTO GENERATED - MARKED REGIONS WILL BE KEPT
+// template version 2
+//
+
+#include "ld-ev.hpp"
+
+// headers for provided interface implementations
+#include <generated/interfaces/ISO15118_vas/Implementation.hpp>
+
+// ev@4bf81b14-a215-475c-a1d3-0a484ae48918:v1
+// insert your custom include headers here
+// ev@4bf81b14-a215-475c-a1d3-0a484ae48918:v1
+
+namespace module {
+
+struct Conf {
+    std::string service_file;
+};
+
+class StaticISO15118VASProvider : public Everest::ModuleBase {
+public:
+    StaticISO15118VASProvider() = delete;
+    StaticISO15118VASProvider(const ModuleInfo& info, std::unique_ptr<ISO15118_vasImplBase> p_iso15118_vas,
+                              Conf& config) :
+        ModuleBase(info), p_iso15118_vas(std::move(p_iso15118_vas)), config(config){};
+
+    const std::unique_ptr<ISO15118_vasImplBase> p_iso15118_vas;
+    const Conf& config;
+
+    // ev@1fce4c5e-0ab8-41bb-90f7-14277703d2ac:v1
+    // insert your public definitions here
+    // ev@1fce4c5e-0ab8-41bb-90f7-14277703d2ac:v1
+
+protected:
+    // ev@4714b2ab-a24f-4b95-ab81-36439e1478de:v1
+    // insert your protected definitions here
+    // ev@4714b2ab-a24f-4b95-ab81-36439e1478de:v1
+
+private:
+    friend class LdEverest;
+    void init();
+    void ready();
+
+    // ev@211cfdbe-f69a-4cd6-a4ec-f8aaa3d1b6c8:v1
+    // insert your private definitions here
+    // ev@211cfdbe-f69a-4cd6-a4ec-f8aaa3d1b6c8:v1
+};
+
+// ev@087e516b-124c-48df-94fb-109508c7cda9:v1
+// insert other definitions here
+// ev@087e516b-124c-48df-94fb-109508c7cda9:v1
+
+} // namespace module
+
+#endif // STATIC_ISO15118VASPROVIDER_HPP

tools/EVerest-main/modules/EVSE/StaticISO15118VASProvider/example.yaml

@@ -0,0 +1,39 @@
+services:
+  - id: 34567
+    description: Test service 1
+    parameter_sets:
+      - id: 0
+        parameters:
+          - name: TestBool
+            type: bool
+            value: false
+          - name: TestRational
+            type: rational
+            value: 0.1209
+          - name: TestInt32
+            type: int32
+            value: 1234567
+          - name: TestInt16
+            type: int16
+            value: 12345
+          - name: TestInt8
+            type: int8
+            value: 123
+          - name: TestString
+            type: string
+            value: This is a test string
+      - id: 1
+        parameters:
+          - name: TestBool
+            type: bool
+            value: true
+  - id: 34568
+    name: Service 2
+    scope: test-scope
+    description: Test service 2
+    parameter_sets:
+      - id: 0
+        parameters:
+          - name: TestInt8
+            type: int8
+            value: 42

tools/EVerest-main/modules/EVSE/StaticISO15118VASProvider/iso15118_vas/ISO15118_vasImpl.cpp

@@ -0,0 +1,167 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+
+#include "ISO15118_vasImpl.hpp"
+#include <utils/yaml_loader.hpp>
+
+namespace module {
+namespace iso15118_vas {
+
+/**
+ * @brief Convert a single JSON Parameter Object (name and type) to a VAS Parameter object.
+ * @param json The JSON object to convert.
+ * @return The converted Parameter object.
+ */
+types::iso15118_vas::Parameter parameter_from_json(const nlohmann::ordered_json& json) {
+    auto param_name = json["name"].get<std::string>();
+    auto param_type = json["type"].get<std::string>();
+
+    types::iso15118_vas::Parameter parameter;
+    parameter.name = param_name;
+
+    EVLOG_debug << "    Parameter name: " << param_name;
+
+    if (param_type == "bool") {
+        parameter.value.bool_value = json["value"].get<bool>();
+        EVLOG_debug << "      Parameter value: " << (parameter.value.bool_value.value() ? "true" : "false");
+    } else if (param_type == "int32") {
+        parameter.value.int_value = json["value"].get<int32_t>();
+        EVLOG_debug << "      Parameter value: " << std::to_string(parameter.value.int_value.value());
+    } else if (param_type == "int16") {
+        parameter.value.short_value = json["value"].get<int16_t>();
+        EVLOG_debug << "      Parameter value: " << std::to_string(parameter.value.short_value.value());
+    } else if (param_type == "int8") {
+        parameter.value.byte_value = json["value"].get<int8_t>();
+        EVLOG_debug << "      Parameter value: " << std::to_string(parameter.value.byte_value.value());
+    } else if (param_type == "string") {
+        parameter.value.finite_string = json["value"].get<std::string>();
+        EVLOG_debug << "      Parameter value: " << parameter.value.finite_string.value();
+    } else if (param_type == "rational") {
+        parameter.value.rational_number = json["value"].get<float>();
+        EVLOG_debug << "      Parameter value: " << std::to_string(parameter.value.rational_number.value());
+    } else {
+        EVLOG_AND_THROW(Everest::EverestConfigError("Unknown parameter type: " + param_type));
+    }
+
+    return parameter;
+}
+
+/**
+ * @brief Convert a single JSON ParameterSet Object (id and parameters) to a ParameterSet object. Also checks for
+ * duplicate parameter names.
+ * @param json The JSON object to convert.
+ * @return The converted ParameterSet object.
+ */
+types::iso15118_vas::ParameterSet parameter_set_from_json(const nlohmann::ordered_json& json) {
+    auto set_id = json["id"].get<uint16_t>();
+    auto parameters_raw = json["parameters"];
+
+    std::vector<types::iso15118_vas::Parameter> parameters;
+    std::set<std::string> parameter_names; // only used for duplicate check
+
+    EVLOG_debug << "  Parameter set ID: " << set_id;
+    for (const auto& parameter : parameters_raw) {
+        const auto param = parameter_from_json(parameter);
+        parameters.push_back(param);
+
+        // check for duplicate parameter names
+        if (parameter_names.find(param.name) != parameter_names.end()) {
+            EVLOG_AND_THROW(Everest::EverestConfigError(
+                "Parameter name " + param.name + " already exists in parameter set with id " + std::to_string(set_id)));
+        }
+
+        parameter_names.insert(param.name);
+    }
+
+    return types::iso15118_vas::ParameterSet{set_id, parameters};
+}
+
+/**
+ * @brief Convert a JSON array of ParameterSet objects to a vector of ParameterSet objects. Also checks for duplicate
+ * parameter set IDs.
+ * @param json The JSON array to convert.
+ * @return The converted vector of ParameterSet objects.
+ */
+std::vector<types::iso15118_vas::ParameterSet> parameter_sets_from_json(const nlohmann::ordered_json& json) {
+    std::vector<types::iso15118_vas::ParameterSet> parameter_sets;
+    std::set<uint16_t> parameter_set_ids; // only used for duplicate check
+
+    for (const auto& parameter_set_raw : json) {
+        const auto parameter_set = parameter_set_from_json(parameter_set_raw);
+        parameter_sets.push_back(parameter_set);
+
+        // check for duplicate parameter set IDs
+        if (parameter_set_ids.find(parameter_set.set_id) != parameter_set_ids.end()) {
+            EVLOG_AND_THROW(Everest::EverestConfigError("Parameter set ID " + std::to_string(parameter_set.set_id) +
+                                                        " already exists"));
+        }
+
+        parameter_set_ids.insert(parameter_set.set_id);
+    }
+
+    return parameter_sets;
+}
+
+void ISO15118_vasImpl::init() {
+    EVLOG_info << "Loading VAS configuration from " << mod->config.service_file;
+
+    auto yaml = Everest::load_yaml(mod->config.service_file);
+    auto raw_services = yaml["services"];
+
+    for (const auto& service : raw_services) {
+        types::iso15118_vas::OfferedService offered_service;
+
+        offered_service.service_id = service["id"].get<uint16_t>();
+        if (service.contains("name")) {
+            offered_service.service_name = service["name"].get<std::string>();
+        }
+        if (service.contains("scope")) {
+            offered_service.service_scope = service["scope"].get<std::string>();
+        }
+        if (service.contains("free_service")) {
+            offered_service.free_service = service["free_service"].get<bool>();
+        }
+
+        // check for duplicate service IDs
+        for (const auto& item : value_added_services) {
+            if (item.first.service_id == offered_service.service_id) {
+                EVLOG_AND_THROW(Everest::EverestConfigError("Service ID " + std::to_string(offered_service.service_id) +
+                                                            " already exists"));
+            }
+        }
+
+        EVLOG_debug << offered_service;
+
+        value_added_services.push_back(
+            std::make_pair(offered_service, parameter_sets_from_json(service["parameter_sets"])));
+    }
+
+    EVLOG_info << "Loaded VAS configuration with " << value_added_services.size() << " services";
+}
+
+void ISO15118_vasImpl::ready() {
+    types::iso15118_vas::OfferedServices offered_services;
+
+    offered_services.services.reserve(value_added_services.size());
+    for (const auto& item : value_added_services) {
+        offered_services.services.push_back(item.first);
+    }
+
+    publish_offered_vas(offered_services);
+}
+
+std::vector<types::iso15118_vas::ParameterSet> ISO15118_vasImpl::handle_get_service_parameters(int& service_id) {
+    for (const auto& item : value_added_services) {
+        if (item.first.service_id == service_id) {
+            return item.second;
+        }
+    }
+    return {};
+}
+
+void ISO15118_vasImpl::handle_selected_services(std::vector<types::iso15118_vas::SelectedService>& selected_services) {
+    // empty implementation
+}
+
+} // namespace iso15118_vas
+} // namespace module

tools/EVerest-main/modules/EVSE/StaticISO15118VASProvider/iso15118_vas/ISO15118_vasImpl.hpp

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+#ifndef ISO15118_VAS_ISO15118_VAS_IMPL_HPP
+#define ISO15118_VAS_ISO15118_VAS_IMPL_HPP
+
+//
+// AUTO GENERATED - MARKED REGIONS WILL BE KEPT
+// template version 3
+//
+
+#include <generated/interfaces/ISO15118_vas/Implementation.hpp>
+
+#include "../StaticISO15118VASProvider.hpp"
+
+// ev@75ac1216-19eb-4182-a85c-820f1fc2c091:v1
+// insert your custom include headers here
+// ev@75ac1216-19eb-4182-a85c-820f1fc2c091:v1
+
+namespace module {
+namespace iso15118_vas {
+
+struct Conf {};
+
+class ISO15118_vasImpl : public ISO15118_vasImplBase {
+public:
+    ISO15118_vasImpl() = delete;
+    ISO15118_vasImpl(Everest::ModuleAdapter* ev, const Everest::PtrContainer<StaticISO15118VASProvider>& mod,
+                     Conf& config) :
+        ISO15118_vasImplBase(ev, "iso15118_vas"), mod(mod), config(config){};
+
+    // ev@8ea32d28-373f-4c90-ae5e-b4fcc74e2a61:v1
+    // insert your public definitions here
+    // ev@8ea32d28-373f-4c90-ae5e-b4fcc74e2a61:v1
+
+protected:
+    // command handler functions (virtual)
+    virtual std::vector<types::iso15118_vas::ParameterSet> handle_get_service_parameters(int& service_id) override;
+    virtual void
+    handle_selected_services(std::vector<types::iso15118_vas::SelectedService>& selected_services) override;
+
+    // ev@d2d1847a-7b88-41dd-ad07-92785f06f5c4:v1
+    // insert your protected definitions here
+    // ev@d2d1847a-7b88-41dd-ad07-92785f06f5c4:v1
+
+private:
+    const Everest::PtrContainer<StaticISO15118VASProvider>& mod;
+    const Conf& config;
+
+    virtual void init() override;
+    virtual void ready() override;
+
+    // ev@3370e4dd-95f4-47a9-aaec-ea76f34a66c9:v1
+    std::vector<std::pair<types::iso15118_vas::OfferedService, std::vector<types::iso15118_vas::ParameterSet>>>
+        value_added_services;
+    // ev@3370e4dd-95f4-47a9-aaec-ea76f34a66c9:v1
+};
+
+// ev@3d7da0ad-02c2-493d-9920-0bbbd56b9876:v1
+// insert other definitions here
+// ev@3d7da0ad-02c2-493d-9920-0bbbd56b9876:v1
+
+} // namespace iso15118_vas
+} // namespace module
+
+#endif // ISO15118_VAS_ISO15118_VAS_IMPL_HPP

tools/EVerest-main/modules/EVSE/StaticISO15118VASProvider/manifest.yaml

@@ -0,0 +1,14 @@
+description: >-
+  This module provides static ISO15118 value-added services (VAS) defined in a yaml file
+config:
+  service_file:
+    description: The path to the service yaml file
+    type: string
+provides:
+  iso15118_vas:
+    interface: ISO15118_vas
+    description: The custom VAS parsed from the yaml file
+metadata:
+  license: https://opensource.org/licenses/Apache-2.0
+  authors:
+    - Mark Oude Elberink