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/HardwareDrivers/PowerMeters/GenericPowermeter/BUILD.bazel

@@ -0,0 +1,11 @@
+load("//modules:module.bzl", "cc_everest_module")
+
+IMPLS = [
+    "main",
+]
+
+cc_everest_module(
+    name = "GenericPowermeter",
+    deps = [],
+    impls = IMPLS,
+)

tools/EVerest-main/modules/HardwareDrivers/PowerMeters/GenericPowermeter/CMakeLists.txt

@@ -0,0 +1,27 @@
+#
+# 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
+
+install(
+    DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/models/
+    DESTINATION "${CMAKE_INSTALL_DATADIR}/everest/modules/${MODULE_NAME}/models/"
+)
+# ev@bcc62523-e22b-41d7-ba2f-825b493a3c97:v1
+
+target_sources(${MODULE_NAME}
+    PRIVATE
+        "main/powermeterImpl.cpp"
+)
+
+# ev@c55432ab-152c-45a9-9d2e-7281d50c69c3:v1
+# insert other things like install cmds etc here
+target_link_libraries(${MODULE_NAME} PRIVATE everest::yaml)
+# ev@c55432ab-152c-45a9-9d2e-7281d50c69c3:v1

tools/EVerest-main/modules/HardwareDrivers/PowerMeters/GenericPowermeter/GenericPowermeter.cpp

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

tools/EVerest-main/modules/HardwareDrivers/PowerMeters/GenericPowermeter/GenericPowermeter.hpp

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+#ifndef GENERIC_POWERMETER_HPP
+#define GENERIC_POWERMETER_HPP
+
+//
+// AUTO GENERATED - MARKED REGIONS WILL BE KEPT
+// template version 2
+//
+
+#include "ld-ev.hpp"
+
+// headers for provided interface implementations
+#include <generated/interfaces/powermeter/Implementation.hpp>
+
+// headers for required interface implementations
+#include <generated/interfaces/serial_communication_hub/Interface.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 {};
+
+class GenericPowermeter : public Everest::ModuleBase {
+public:
+    GenericPowermeter() = delete;
+    GenericPowermeter(const ModuleInfo& info, std::unique_ptr<powermeterImplBase> p_main,
+                      std::unique_ptr<serial_communication_hubIntf> r_serial_comm_hub, Conf& config) :
+        ModuleBase(info), p_main(std::move(p_main)), r_serial_comm_hub(std::move(r_serial_comm_hub)), config(config){};
+
+    const std::unique_ptr<powermeterImplBase> p_main;
+    const std::unique_ptr<serial_communication_hubIntf> r_serial_comm_hub;
+    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 // GENERIC_POWERMETER_HPP

tools/EVerest-main/modules/HardwareDrivers/PowerMeters/GenericPowermeter/docs/index.rst

@@ -0,0 +1,96 @@
+.. _everest_modules_handwritten_GenericPowermeter:
+
+.. *****************
+.. GenericPowermeter
+.. *****************
+
+The module ``GenericPowermeter`` provides a connection to get data from 
+powermeters that are connected via Modbus RTU and whose data is automatically 
+updated (without startup configuration and/or request functions). 
+
+It supports both AC and DC powermeters.
+
+To do so, a register configuration file is needed that describes which (ModbusRTU-)registers
+are available on the device and what data they contain. The available data will then be used
+to calculate the correct structure of data for the ``powermeter`` interface of EVerest.
+
+Currently available powermeter configurations can be found in the module's ``models`` 
+subdirectory.
+
+To add a new powermeter to the set of available devices, there exists a ``template.yaml``
+file in the ``models`` subdirectory which can be copied and filled with the new powermeter's
+data from the datasheet.
+
+
+Datasets in the configuration file
+==================================
+
+Available datasets for the module ``GenericPowermeter``
+-------------------------------------------------------
+
+This module can read the following parameters from a powermeter:
+
+(for a description of the parameter values see interface ``powermeter``)
+
+* energy_Wh_import
+* energy_Wh_export
+* power_W
+* voltage_V
+* VAR
+* current_A
+* frequency_Hz
+
+Dataset description
+-------------------
+
+A typical dataset consists of the following parameters:
+
+(<start_register> of length <num_registers>) * <multiplier> * 10^(<exponent_register>)
+
+* <start_register> = the device's ModbusRTU register at which the value for the data of this 
+  type is being stored (set to "0" if this value is not available in the powermeter)
+* <function_code_start_reg> = ModbusRTU function code used to obtain this register's value
+  (currently implemented: ``3`` (``read holding registers``) and ``4`` (``read input registers``))
+* <num_registers> = the number of registers to read from the address of <start_register>
+* <multiplier> = a multiplier to manually (pre-)scale the register's value (i.e. set to ``0.001`` 
+  when the powermeter provides energy in ``kWh``, as the ``powermeter`` interface uses energy 
+  in ``Wh``)
+* <exponent_register> = the device's ModbusRTU register at which the exponent for the 
+  register set is being stored (set to "0" if this value is not available in the powermeter)
+* <function_code_exp_reg> = ModbusRTU function code used to obtain this register's exponent 
+  (currently implemented: ``3`` (``read holding registers``) and ``4`` (``read input registers``))
+
+
+Structure of datasets in the configuration file
+-----------------------------------------------
+
+Datasets are structured into two levels:
+
+* first level : contains either DC value or, in AC case, sum total of all corresponding lines (L1/2/3)
+* second level : contains AC values, split into their corresponding lines (L1/2/3)
+
+Other things to note
+--------------------
+
+* if measuring AC, the first level of registers is always "total/sum" of a certain value and 
+  the L1/2/3 registers are for the distinct phases
+* if measuring DC, only use the first level of registers
+
+Published variables
+===================
+
+powermeter
+----------
+
+The basic dataset of powermeter values as used in the EVerest ``powermeter`` interface.
+This dataset will be periodically published by the module.
+
+
+Provided commands
+=================
+
+get_signed_meter_value
+----------------------
+
+`currently not implemented`
+

tools/EVerest-main/modules/HardwareDrivers/PowerMeters/GenericPowermeter/main/powermeterImpl.cpp

@@ -0,0 +1,584 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+
+#include "powermeterImpl.hpp"
+#include <fmt/core.h>
+#include <functional>
+#include <optional>
+#include <thread>
+#include <utils/date.hpp>
+#include <utils/yaml_loader.hpp>
+
+const std::string MODELS_SUB_DIR = "models";
+
+namespace fs = std::filesystem;
+
+namespace module {
+namespace main {
+
+void powermeterImpl::init() {
+
+    const std::size_t found = this->config.model.find(".."); // check for invalid path
+    if (found != std::string::npos) {
+        EVLOG_error << fmt::format("Error! Substring \"..\" not allowed in given model name '{}'!", this->config.model);
+        throw std::runtime_error("Incorrect model name in GenericPowermeter config");
+    }
+
+    const auto model = this->mod->info.paths.share / MODELS_SUB_DIR / fmt::format("{}.yaml", this->config.model);
+
+    try {
+        const json powermeter_registers = Everest::load_yaml(model);
+        this->init_register_assignments(std::move(powermeter_registers));
+        this->init_default_values();
+    } catch (const std::exception& e) {
+        EVLOG_error << "opening file \"" << this->config.model << ".yaml\" from path " << model
+                    << " failed: " << e.what();
+        throw std::runtime_error(fmt::format("Module \"GenericPowermeter\" could not be initialized: {}", e.what()));
+    }
+}
+
+void powermeterImpl::ready() {
+    std::thread([this] {
+        while (true) {
+            this->read_powermeter_values();
+            // Note: reading the power meter values may take several seconds already, so the complete loop
+            // time of this function will be well beyond the sleep time given below.
+            sleep(1);
+        }
+    }).detach();
+}
+
+types::powermeter::TransactionStopResponse powermeterImpl::handle_stop_transaction(std::string& transaction_id) {
+    return {types::powermeter::TransactionRequestStatus::NOT_SUPPORTED,
+            {},
+            {},
+            "Generic powermeter does not support the stop_transaction command"};
+};
+
+types::powermeter::TransactionStartResponse
+powermeterImpl::handle_start_transaction(types::powermeter::TransactionReq& value) {
+    return {types::powermeter::TransactionRequestStatus::NOT_SUPPORTED,
+            "Generic powermeter does not support the start_transaction command"};
+}
+
+void powermeterImpl::init_default_values() {
+    this->pm_last_values.timestamp = Everest::Date::to_rfc3339(date::utc_clock::now());
+    this->pm_last_values.meter_id = std::string(this->mod->info.id);
+
+    for (const auto& register_data : this->pm_configuration) {
+        if (register_data.type == ENERGY_WH_IMPORT_TOTAL) {
+            this->pm_last_values.energy_Wh_import.total = 0.0f;
+        } else if (register_data.type == ENERGY_WH_IMPORT_L1) {
+            this->pm_last_values.energy_Wh_import.L1 = 0.0f;
+        } else if (register_data.type == ENERGY_WH_IMPORT_L2) {
+            this->pm_last_values.energy_Wh_import.L2 = 0.0f;
+        } else if (register_data.type == ENERGY_WH_IMPORT_L3) {
+            this->pm_last_values.energy_Wh_import.L3 = 0.0f;
+        } else if (register_data.type == ENERGY_WH_EXPORT_TOTAL) {
+            types::units::Energy energy_out;
+            if (this->pm_last_values.energy_Wh_export.has_value()) {
+                energy_out = this->pm_last_values.energy_Wh_export.value();
+            }
+            energy_out.total = 0.0f;
+            this->pm_last_values.energy_Wh_export = energy_out;
+        } else if (register_data.type == ENERGY_WH_EXPORT_L1) {
+            types::units::Energy energy_out;
+            if (this->pm_last_values.energy_Wh_export.has_value()) {
+                energy_out = this->pm_last_values.energy_Wh_export.value();
+            }
+            energy_out.L1 = 0.0f;
+            this->pm_last_values.energy_Wh_export = energy_out;
+        } else if (register_data.type == ENERGY_WH_EXPORT_L2) {
+            types::units::Energy energy_out;
+            if (this->pm_last_values.energy_Wh_export.has_value()) {
+                energy_out = this->pm_last_values.energy_Wh_export.value();
+            }
+            energy_out.L2 = 0.0f;
+            this->pm_last_values.energy_Wh_export = energy_out;
+        } else if (register_data.type == ENERGY_WH_EXPORT_L3) {
+            types::units::Energy energy_out;
+            if (this->pm_last_values.energy_Wh_export.has_value()) {
+                energy_out = this->pm_last_values.energy_Wh_export.value();
+            }
+            energy_out.L3 = 0.0f;
+            this->pm_last_values.energy_Wh_export = energy_out;
+        } else if (register_data.type == POWER_W_TOTAL) {
+            types::units::Power pwr;
+            if (this->pm_last_values.power_W.has_value()) {
+                pwr = this->pm_last_values.power_W.value();
+            }
+            pwr.total = 0.0f;
+            this->pm_last_values.power_W = pwr;
+        } else if (register_data.type == POWER_W_L1) {
+            types::units::Power pwr;
+            if (this->pm_last_values.power_W.has_value()) {
+                pwr = this->pm_last_values.power_W.value();
+            }
+            pwr.L1 = 0.0f;
+            this->pm_last_values.power_W = pwr;
+        } else if (register_data.type == POWER_W_L2) {
+            types::units::Power pwr;
+            if (this->pm_last_values.power_W.has_value()) {
+                pwr = this->pm_last_values.power_W.value();
+            }
+            pwr.L2 = 0.0f;
+            this->pm_last_values.power_W = pwr;
+        } else if (register_data.type == POWER_W_L3) {
+            types::units::Power pwr;
+            if (this->pm_last_values.power_W.has_value()) {
+                pwr = this->pm_last_values.power_W.value();
+            }
+            pwr.L3 = 0.0f;
+            this->pm_last_values.power_W = pwr;
+        } else if (register_data.type == VOLTAGE_V_DC) {
+            types::units::Voltage volt;
+            if (this->pm_last_values.voltage_V.has_value()) {
+                volt = this->pm_last_values.voltage_V.value();
+            }
+            volt.DC = 0.0f;
+            this->pm_last_values.voltage_V = volt;
+        } else if (register_data.type == VOLTAGE_V_L1) {
+            types::units::Voltage volt;
+            if (this->pm_last_values.voltage_V.has_value()) {
+                volt = this->pm_last_values.voltage_V.value();
+            }
+            volt.L1 = 0.0f;
+            this->pm_last_values.voltage_V = volt;
+        } else if (register_data.type == VOLTAGE_V_L2) {
+            types::units::Voltage volt;
+            if (this->pm_last_values.voltage_V.has_value()) {
+                volt = this->pm_last_values.voltage_V.value();
+            }
+            volt.L2 = 0.0f;
+            this->pm_last_values.voltage_V = volt;
+        } else if (register_data.type == VOLTAGE_V_L3) {
+            types::units::Voltage volt;
+            if (this->pm_last_values.voltage_V.has_value()) {
+                volt = this->pm_last_values.voltage_V.value();
+            }
+            volt.L3 = 0.0f;
+            this->pm_last_values.voltage_V = volt;
+        } else if (register_data.type == REACTIVE_POWER_VAR_TOTAL) {
+            types::units::ReactivePower var;
+            if (this->pm_last_values.VAR.has_value()) {
+                var = this->pm_last_values.VAR.value();
+            }
+            var.total = 0.0f;
+            this->pm_last_values.VAR = var;
+        } else if (register_data.type == REACTIVE_POWER_VAR_L1) {
+            types::units::ReactivePower var;
+            if (this->pm_last_values.VAR.has_value()) {
+                var = this->pm_last_values.VAR.value();
+            }
+            var.L1 = 0.0f;
+            this->pm_last_values.VAR = var;
+        } else if (register_data.type == REACTIVE_POWER_VAR_L2) {
+            types::units::ReactivePower var;
+            if (this->pm_last_values.VAR.has_value()) {
+                var = this->pm_last_values.VAR.value();
+            }
+            var.L2 = 0.0f;
+            this->pm_last_values.VAR = var;
+        } else if (register_data.type == REACTIVE_POWER_VAR_L3) {
+            types::units::ReactivePower var;
+            if (this->pm_last_values.VAR.has_value()) {
+                var = this->pm_last_values.VAR.value();
+            }
+            var.L3 = 0.0f;
+            this->pm_last_values.VAR = var;
+        } else if (register_data.type == CURRENT_A_DC) {
+            types::units::Current amp;
+            if (this->pm_last_values.current_A.has_value()) {
+                amp = this->pm_last_values.current_A.value();
+            }
+            amp.DC = 0.0f;
+            this->pm_last_values.current_A = amp;
+        } else if (register_data.type == CURRENT_A_L1) {
+            types::units::Current amp;
+            if (this->pm_last_values.current_A.has_value()) {
+                amp = this->pm_last_values.current_A.value();
+            }
+            amp.L1 = 0.0f;
+            this->pm_last_values.current_A = amp;
+        } else if (register_data.type == CURRENT_A_L2) {
+            types::units::Current amp;
+            if (this->pm_last_values.current_A.has_value()) {
+                amp = this->pm_last_values.current_A.value();
+            }
+            amp.L2 = 0.0f;
+            this->pm_last_values.current_A = amp;
+        } else if (register_data.type == CURRENT_A_L3) {
+            types::units::Current amp;
+            if (this->pm_last_values.current_A.has_value()) {
+                amp = this->pm_last_values.current_A.value();
+            }
+            amp.L3 = 0.0f;
+            this->pm_last_values.current_A = amp;
+        } else if (register_data.type == FREQUENCY_HZ_L1) {
+            types::units::Frequency freq;
+            if (this->pm_last_values.frequency_Hz.has_value()) {
+                freq = this->pm_last_values.frequency_Hz.value();
+            }
+            freq.L1 = 0.0f;
+            this->pm_last_values.frequency_Hz = freq;
+        } else if (register_data.type == FREQUENCY_HZ_L2) {
+            types::units::Frequency freq;
+            if (this->pm_last_values.frequency_Hz.has_value()) {
+                freq = this->pm_last_values.frequency_Hz.value();
+            }
+            freq.L2 = 0.0f;
+            this->pm_last_values.frequency_Hz = freq;
+        } else if (register_data.type == FREQUENCY_HZ_L3) {
+            types::units::Frequency freq;
+            if (this->pm_last_values.frequency_Hz.has_value()) {
+                freq = this->pm_last_values.frequency_Hz.value();
+            }
+            freq.L3 = 0.0f;
+            this->pm_last_values.frequency_Hz = freq;
+        }
+    }
+}
+
+void powermeterImpl::init_register_assignments(const json& loaded_registers) {
+    bool failed{false};
+    failed |= not this->assign_register_data(loaded_registers, ENERGY_WH_IMPORT_TOTAL, "energy_Wh_import");
+    failed |= not this->assign_register_data(loaded_registers, ENERGY_WH_EXPORT_TOTAL, "energy_Wh_export");
+    failed |= not this->assign_register_data(loaded_registers, POWER_W_TOTAL, "power_W");
+    failed |= not this->assign_register_data(loaded_registers, VOLTAGE_V_DC, "voltage_V");
+    failed |= not this->assign_register_data(loaded_registers, REACTIVE_POWER_VAR_TOTAL, "reactive_power_VAR");
+    failed |= not this->assign_register_data(loaded_registers, CURRENT_A_DC, "current_A");
+    failed |= not this->assign_register_data(loaded_registers, FREQUENCY_HZ_L1, "frequency_Hz");
+
+    if (failed) {
+        EVLOG_error << "Could not load powermeter model configuration!";
+        throw std::runtime_error("Could not load GenericPowermeter model configuration");
+    }
+}
+
+bool powermeterImpl::assign_register_data(const json& registers, const PowermeterRegisters register_type,
+                                          const std::string& register_selector) {
+    try {
+        if (registers.contains(register_selector)) {
+            if (registers.at(register_selector).at("num_registers") > 0) {
+                RegisterData data = {};
+                data.type = register_type;
+                data.start_register = registers.at(register_selector).at("start_register");
+                data.start_register_function = this->select_modbus_function(
+                    (const uint8_t)registers.at(register_selector).at("function_code_start_reg"));
+                data.num_registers = registers.at(register_selector).at("num_registers");
+                data.exponent_register = registers.at(register_selector).at("exponent_register");
+                data.exponent_register_function = this->select_modbus_function(
+                    (const uint8_t)registers.at(register_selector).at("function_code_exp_reg"));
+                data.multiplier = registers.at(register_selector).at("multiplier");
+                this->pm_configuration.push_back(data);
+            }
+            if (registers.at(register_selector).contains("L1")) {
+                if (registers.at(register_selector).at("L1").at("num_registers") > 0) {
+                    assign_register_sublevel_data(registers, register_type, register_selector, "L1", 1);
+                }
+            }
+            if (registers.at(register_selector).contains("L2")) {
+                if (registers.at(register_selector).at("L2").at("num_registers") > 0) {
+                    assign_register_sublevel_data(registers, register_type, register_selector, "L2", 2);
+                }
+            }
+            if (registers.at(register_selector).contains("L3")) {
+                if (registers.at(register_selector).at("L3").at("num_registers") > 0) {
+                    assign_register_sublevel_data(registers, register_type, register_selector, "L3", 3);
+                }
+            }
+        }
+    } catch (const std::exception& e) {
+        EVLOG_error << "Assigning configuration data for register \"" << register_selector << "\" failed: " << e.what();
+        return false;
+    }
+
+    return true;
+}
+
+void powermeterImpl::assign_register_sublevel_data(const json& registers, const PowermeterRegisters& register_type,
+                                                   const std::string& register_selector,
+                                                   const std::string& sublevel_selector, const uint8_t offset) {
+
+    RegisterData sublevel_data = {};
+    sublevel_data.type = static_cast<PowermeterRegisters>((register_type + offset) % NUM_PM_REGISTERS);
+    sublevel_data.start_register = registers.at(register_selector).at(sublevel_selector).at("start_register");
+    sublevel_data.start_register_function = this->select_modbus_function(
+        (const uint8_t)registers.at(register_selector).at(sublevel_selector).at("function_code_start_reg"));
+    sublevel_data.num_registers = registers.at(register_selector).at(sublevel_selector).at("num_registers");
+    sublevel_data.exponent_register = registers.at(register_selector).at(sublevel_selector).at("exponent_register");
+    sublevel_data.exponent_register_function = this->select_modbus_function(
+        (const uint8_t)registers.at(register_selector).at(sublevel_selector).at("function_code_exp_reg"));
+    sublevel_data.multiplier = registers.at(register_selector).at(sublevel_selector).at("multiplier");
+    this->pm_configuration.push_back(sublevel_data);
+}
+
+powermeterImpl::ModbusFunctionType powermeterImpl::select_modbus_function(const uint8_t function_code) {
+    switch (function_code) {
+    case 0x03:
+        return READ_HOLDING_REGISTER;
+        break;
+
+    case 0x04:
+        return READ_INPUT_REGISTER;
+        break;
+
+    default:
+        throw std::runtime_error(fmt::format("Incorrect Modbus RTU function code {}!", function_code));
+        break;
+    }
+    return REGISTER_TYPE_UNDEFINED;
+}
+
+void powermeterImpl::read_powermeter_values() {
+    static bool pm_values_are_complete{false};
+    bool all_pm_registers_success{true};
+    for (const auto& register_data : this->pm_configuration) {
+        all_pm_registers_success &= this->read_register(register_data);
+    }
+    if (all_pm_registers_success) {
+        pm_values_are_complete = true;
+    }
+
+    if (not pm_values_are_complete) {
+        EVLOG_warning << "No complete set of power meter values has been acquired yet. Not publishing.";
+        return;
+    }
+
+    this->pm_last_values.timestamp = Everest::Date::to_rfc3339(date::utc_clock::now());
+    this->publish_powermeter(this->pm_last_values);
+}
+
+bool powermeterImpl::read_register(const RegisterData& register_config) {
+
+    types::serial_comm_hub_requests::Result register_response{};
+    std::optional<types::serial_comm_hub_requests::Result> exponent_response;
+
+    if (register_config.start_register_function == READ_HOLDING_REGISTER) {
+        register_response = mod->r_serial_comm_hub->call_modbus_read_holding_registers(
+            this->config.powermeter_device_id, register_config.start_register, register_config.num_registers);
+    } else if (register_config.start_register_function == READ_INPUT_REGISTER) {
+        register_response = mod->r_serial_comm_hub->call_modbus_read_input_registers(
+            this->config.powermeter_device_id, register_config.start_register - this->config.modbus_base_address,
+            register_config.num_registers);
+    }
+
+    if (register_config.exponent_register != 0) {
+        if (register_config.exponent_register_function == READ_HOLDING_REGISTER) {
+            exponent_response = mod->r_serial_comm_hub->call_modbus_read_holding_registers(
+                this->config.powermeter_device_id, register_config.exponent_register, register_config.num_registers);
+        } else if (register_config.exponent_register_function == READ_INPUT_REGISTER) {
+            exponent_response = mod->r_serial_comm_hub->call_modbus_read_input_registers(
+                this->config.powermeter_device_id, register_config.exponent_register - this->config.modbus_base_address,
+                register_config.num_registers);
+        }
+        return this->process_response(register_config, std::move(register_response), std::move(exponent_response));
+    } else {
+        // no exponent
+        return this->process_response(register_config, std::move(register_response), std::nullopt);
+    }
+}
+
+bool powermeterImpl::process_response(
+    const RegisterData& register_data, const types::serial_comm_hub_requests::Result& register_message,
+    std::optional<std::reference_wrapper<const types::serial_comm_hub_requests::Result>> exponent_message) {
+
+    if ((register_message.status_code != types::serial_comm_hub_requests::StatusCodeEnum::Success) ||
+        (exponent_message &&
+         exponent_message->get().status_code != types::serial_comm_hub_requests::StatusCodeEnum::Success)) {
+        // error: message sending failed
+        output_error_with_content(register_message);
+        if (exponent_message) {
+            output_error_with_content(exponent_message.value());
+        }
+
+        // let's warn the user about the meter's unavailability once only
+        // (since we keep trying communicating an 'error' is not justified)
+        if (!meter_is_unavailable) {
+            EVLOG_warning << "Lost communication with power meter.";
+            meter_is_unavailable = true;
+        }
+
+        return false;
+    }
+
+    // SerialCommHub implementation should be preventing this in case of StatusCodeEnum::Success
+    if (not register_message.value.has_value()) {
+        EVLOG_warning << "Power meter reading returned without a value, skipping";
+        return false;
+    }
+    if (exponent_message and not exponent_message->get().value.has_value()) {
+        EVLOG_warning << "Power meter reading returned without an exponent value, skipping";
+        return false;
+    }
+    if (register_message.value.value().size() == 0) {
+        EVLOG_warning << "Power meter reading returned an empty value, skipping";
+        return false;
+    }
+    if (exponent_message and exponent_message->get().value.value().size() == 0) {
+        EVLOG_warning << "Power meter reading returned an empty exponent value, skipping";
+        return false;
+    }
+
+    // in case the meter was unavailable before and now the query succeeded,
+    // we can tell the user about this good news and reset our flag
+    if (meter_is_unavailable) {
+        EVLOG_info << "Communication with power meter restored.";
+        meter_is_unavailable = false;
+    }
+
+    int16_t exponent = 0;
+    if (exponent_message) {
+        exponent = exponent_message->get().value.value().at(0);
+    }
+
+    if (register_data.type == ENERGY_WH_IMPORT_TOTAL) {
+        types::units::Energy energy_in = this->pm_last_values.energy_Wh_import;
+        energy_in.total = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.energy_Wh_import = energy_in;
+    } else if (register_data.type == ENERGY_WH_IMPORT_L1) {
+        types::units::Energy energy_in = this->pm_last_values.energy_Wh_import;
+        energy_in.L1 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.energy_Wh_import = energy_in;
+    } else if (register_data.type == ENERGY_WH_IMPORT_L2) {
+        types::units::Energy energy_in = this->pm_last_values.energy_Wh_import;
+        energy_in.L2 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.energy_Wh_import = energy_in;
+    } else if (register_data.type == ENERGY_WH_IMPORT_L3) {
+        types::units::Energy energy_in = this->pm_last_values.energy_Wh_import;
+        energy_in.L3 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.energy_Wh_import = energy_in;
+    } else if (register_data.type == ENERGY_WH_EXPORT_TOTAL) {
+        types::units::Energy energy_out = this->pm_last_values.energy_Wh_export.value();
+        energy_out.total = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.energy_Wh_export = energy_out;
+    } else if (register_data.type == ENERGY_WH_EXPORT_L1) {
+        types::units::Energy energy_out = this->pm_last_values.energy_Wh_export.value();
+        energy_out.L1 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.energy_Wh_export = energy_out;
+    } else if (register_data.type == ENERGY_WH_EXPORT_L2) {
+        types::units::Energy energy_out = this->pm_last_values.energy_Wh_export.value();
+        energy_out.L2 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.energy_Wh_export = energy_out;
+    } else if (register_data.type == ENERGY_WH_EXPORT_L3) {
+        types::units::Energy energy_out = this->pm_last_values.energy_Wh_export.value();
+        energy_out.L3 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.energy_Wh_export = energy_out;
+    } else if (register_data.type == POWER_W_TOTAL) {
+        types::units::Power power = this->pm_last_values.power_W.value();
+        power.total = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.power_W = power;
+    } else if (register_data.type == POWER_W_L1) {
+        types::units::Power power = this->pm_last_values.power_W.value();
+        power.L1 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.power_W = power;
+    } else if (register_data.type == POWER_W_L2) {
+        types::units::Power power = this->pm_last_values.power_W.value();
+        power.L2 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.power_W = power;
+    } else if (register_data.type == POWER_W_L3) {
+        types::units::Power power = this->pm_last_values.power_W.value();
+        power.L3 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.power_W = power;
+    } else if (register_data.type == VOLTAGE_V_DC) {
+        types::units::Voltage volt = this->pm_last_values.voltage_V.value();
+        volt.DC = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.voltage_V = volt;
+    } else if (register_data.type == VOLTAGE_V_L1) {
+        types::units::Voltage volt = this->pm_last_values.voltage_V.value();
+        volt.L1 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.voltage_V = volt;
+    } else if (register_data.type == VOLTAGE_V_L2) {
+        types::units::Voltage volt = this->pm_last_values.voltage_V.value();
+        volt.L2 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.voltage_V = volt;
+    } else if (register_data.type == VOLTAGE_V_L3) {
+        types::units::Voltage volt = this->pm_last_values.voltage_V.value();
+        volt.L3 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.voltage_V = volt;
+    } else if (register_data.type == REACTIVE_POWER_VAR_TOTAL) {
+        types::units::ReactivePower var = this->pm_last_values.VAR.value();
+        var.total = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.VAR = var;
+    } else if (register_data.type == REACTIVE_POWER_VAR_L1) {
+        types::units::ReactivePower var = this->pm_last_values.VAR.value();
+        var.L1 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.VAR = var;
+    } else if (register_data.type == REACTIVE_POWER_VAR_L2) {
+        types::units::ReactivePower var = this->pm_last_values.VAR.value();
+        var.L2 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.VAR = var;
+    } else if (register_data.type == REACTIVE_POWER_VAR_L3) {
+        types::units::ReactivePower var = this->pm_last_values.VAR.value();
+        var.L3 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.VAR = var;
+    } else if (register_data.type == CURRENT_A_DC) {
+        types::units::Current amp = this->pm_last_values.current_A.value();
+        amp.DC = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.current_A = amp;
+    } else if (register_data.type == CURRENT_A_L1) {
+        types::units::Current amp = this->pm_last_values.current_A.value();
+        amp.L1 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.current_A = amp;
+    } else if (register_data.type == CURRENT_A_L2) {
+        types::units::Current amp = this->pm_last_values.current_A.value();
+        amp.L2 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.current_A = amp;
+    } else if (register_data.type == CURRENT_A_L3) {
+        types::units::Current amp = this->pm_last_values.current_A.value();
+        amp.L3 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.current_A = amp;
+    } else if (register_data.type == FREQUENCY_HZ_L1) {
+        types::units::Frequency freq = this->pm_last_values.frequency_Hz.value();
+        freq.L1 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.frequency_Hz = freq;
+    } else if (register_data.type == FREQUENCY_HZ_L2) {
+        types::units::Frequency freq = this->pm_last_values.frequency_Hz.value();
+        freq.L2 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.frequency_Hz = freq;
+    } else if (register_data.type == FREQUENCY_HZ_L3) {
+        types::units::Frequency freq = this->pm_last_values.frequency_Hz.value();
+        freq.L3 = this->merge_register_values_into_element(register_data, exponent, register_message);
+        this->pm_last_values.frequency_Hz = freq;
+    } else {
+    }
+
+    return true;
+}
+
+float powermeterImpl::merge_register_values_into_element(const RegisterData& reg_data, const int16_t exponent,
+                                                         const types::serial_comm_hub_requests::Result& reg_message) {
+    uint32_t value{0};
+    const auto& reg_value = reg_message.value.value();
+    if (reg_data.num_registers == 1 && reg_value.size() == 1) {
+        value = reg_value.at(0);
+    } else if (reg_data.num_registers == 2 && reg_value.size() == 2) {
+        value += reg_value.at(0) << 16;
+        value += reg_value.at(1);
+    } else {
+        throw std::runtime_error("Values of more than 2 registers in size are currently not supported!");
+    }
+
+    const auto val = *reinterpret_cast<float*>(&value);
+    const auto val_scaled = float(val * reg_data.multiplier * pow(10.0, exponent));
+
+    return val_scaled;
+}
+
+void powermeterImpl::output_error_with_content(const types::serial_comm_hub_requests::Result& response) {
+    std::stringstream ss;
+
+    if (response.value) {
+        for (size_t i = 0; i < response.value->size(); i++) {
+            if (i != 0)
+                ss << ", ";
+            ss << "0x" << std::setfill('0') << std::setw(2) << std::hex << int(response.value.value()[i]);
+        }
+    }
+
+    EVLOG_debug << "received error response: " << status_code_enum_to_string(response.status_code) << " (" << ss.str()
+                << ")";
+}
+
+} // namespace main
+} // namespace module

tools/EVerest-main/modules/HardwareDrivers/PowerMeters/GenericPowermeter/main/powermeterImpl.hpp

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+#ifndef MAIN_POWERMETER_IMPL_HPP
+#define MAIN_POWERMETER_IMPL_HPP
+
+//
+// AUTO GENERATED - MARKED REGIONS WILL BE KEPT
+// template version 3
+//
+
+#include <generated/interfaces/powermeter/Implementation.hpp>
+
+#include "../GenericPowermeter.hpp"
+
+// ev@75ac1216-19eb-4182-a85c-820f1fc2c091:v1
+// insert your custom include headers here
+#include <optional>
+#include <string>
+// ev@75ac1216-19eb-4182-a85c-820f1fc2c091:v1
+
+namespace module {
+namespace main {
+
+struct Conf {
+    std::string model;
+    int powermeter_device_id;
+    int modbus_base_address;
+};
+
+class powermeterImpl : public powermeterImplBase {
+public:
+    powermeterImpl() = delete;
+    powermeterImpl(Everest::ModuleAdapter* ev, const Everest::PtrContainer<GenericPowermeter>& mod, Conf& config) :
+        powermeterImplBase(ev, "main"), 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 types::powermeter::TransactionStartResponse
+    handle_start_transaction(types::powermeter::TransactionReq& value) override;
+    virtual types::powermeter::TransactionStopResponse handle_stop_transaction(std::string& transaction_id) override;
+
+    // ev@d2d1847a-7b88-41dd-ad07-92785f06f5c4:v1
+    // insert your protected definitions here
+    // ev@d2d1847a-7b88-41dd-ad07-92785f06f5c4:v1
+
+private:
+    const Everest::PtrContainer<GenericPowermeter>& mod;
+    const Conf& config;
+
+    virtual void init() override;
+    virtual void ready() override;
+
+    // ev@3370e4dd-95f4-47a9-aaec-ea76f34a66c9:v1
+    enum PowermeterRegisters {
+        // do not change order or index of these elements!
+        ENERGY_WH_IMPORT_TOTAL,
+        ENERGY_WH_IMPORT_L1,
+        ENERGY_WH_IMPORT_L2,
+        ENERGY_WH_IMPORT_L3,
+        ENERGY_WH_EXPORT_TOTAL,
+        ENERGY_WH_EXPORT_L1,
+        ENERGY_WH_EXPORT_L2,
+        ENERGY_WH_EXPORT_L3,
+        POWER_W_TOTAL,
+        POWER_W_L1,
+        POWER_W_L2,
+        POWER_W_L3,
+        VOLTAGE_V_DC,
+        VOLTAGE_V_L1,
+        VOLTAGE_V_L2,
+        VOLTAGE_V_L3,
+        REACTIVE_POWER_VAR_TOTAL,
+        REACTIVE_POWER_VAR_L1,
+        REACTIVE_POWER_VAR_L2,
+        REACTIVE_POWER_VAR_L3,
+        CURRENT_A_DC,
+        CURRENT_A_L1,
+        CURRENT_A_L2,
+        CURRENT_A_L3,
+        FREQUENCY_HZ_L1,
+        FREQUENCY_HZ_L2,
+        FREQUENCY_HZ_L3,
+        NUM_PM_REGISTERS
+    };
+
+    enum ModbusFunctionType {
+        READ_HOLDING_REGISTER,
+        READ_INPUT_REGISTER,
+        REGISTER_TYPE_UNDEFINED
+    };
+
+    struct RegisterData {
+        float multiplier;
+        PowermeterRegisters type;
+        uint16_t start_register;
+        ModbusFunctionType start_register_function;
+        uint16_t exponent_register;
+        ModbusFunctionType exponent_register_function;
+        uint16_t num_registers;
+    };
+
+    std::vector<RegisterData> pm_configuration;
+
+    types::powermeter::Powermeter pm_last_values;
+
+    std::thread output_thread;
+
+    /// @brief Remember whether we already logged the meter's unavailability.
+    bool meter_is_unavailable{false};
+
+    void init_default_values();
+    void init_register_assignments(const json& loaded_registers);
+    bool assign_register_data(const json& registers, const PowermeterRegisters register_type,
+                              const std::string& register_selector);
+    void assign_register_sublevel_data(const json& registers, const PowermeterRegisters& register_type,
+                                       const std::string& register_selector, const std::string& sublevel_selector,
+                                       const uint8_t offset);
+    powermeterImpl::ModbusFunctionType select_modbus_function(const uint8_t function_code);
+    void read_powermeter_values();
+    bool read_register(const RegisterData& register_config);
+    bool process_response(
+        const RegisterData& register_data, const types::serial_comm_hub_requests::Result& register_message,
+        std::optional<std::reference_wrapper<const types::serial_comm_hub_requests::Result>> exponent_message);
+    float merge_register_values_into_element(const RegisterData& reg_data, const int16_t exponent,
+                                             const types::serial_comm_hub_requests::Result& reg_message);
+    void process_current_rate_message(const types::serial_comm_hub_requests::Result message);
+    void output_error_with_content(const types::serial_comm_hub_requests::Result& response);
+    // 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 main
+} // namespace module
+
+#endif // MAIN_POWERMETER_IMPL_HPP

tools/EVerest-main/modules/HardwareDrivers/PowerMeters/GenericPowermeter/manifest.yaml

@@ -0,0 +1,29 @@
+description: Powermeter driver for various powermeter hardware
+provides:
+  main:
+    description: Implementation of the driver functionality
+    interface: powermeter
+    config:
+      model:
+        description: Selector for the powermeter configuration file to be used
+        type: string
+        default: test_dummy
+      powermeter_device_id:
+        description: The powermeter's address on the serial bus
+        type: integer
+        minimum: 1
+        maximum: 247
+        default: 1
+      modbus_base_address:
+        description: The base address for register access
+        type: integer
+        minimum: 0
+        maximum: 65535
+        default: 30001
+requires:
+  serial_comm_hub:
+    interface: serial_communication_hub
+metadata:
+  license: https://opensource.org/licenses/Apache-2.0
+  authors:
+    - Lars Dieckmann

tools/EVerest-main/modules/HardwareDrivers/PowerMeters/GenericPowermeter/models/Eastron_SDM230.yaml

@@ -0,0 +1,206 @@
+# (<start_register> of length <num_registers>) * <multiplier> * 10^(<exponent_register>)
+#
+# if <start_register> is "0", then this value does not exist in the powermeter
+#
+# use <multiplier> to manually scale (e.g. set to 0.001 if device returns "kWh", but the parameter is "Wh") and <exponent_register> to scale by device value
+#
+# if <exponent_register> is "0", then no exponent register exists and multiplier needs to be set accordingly
+# 
+# if measuring AC, the first level of registers is always "total/sum" of a certain value and the L1/2/3 registers are for the distinct phases
+# if measuring DC, only use the first level of registers
+energy_Wh_import:
+  start_register: 30073
+  function_code_start_reg: 4
+  num_registers: 2
+  multiplier: 0.001
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+energy_Wh_export: 
+  start_register: 30075
+  function_code_start_reg: 4
+  num_registers: 2
+  multiplier: 0.001
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+power_W:
+  start_register: 30013
+  function_code_start_reg: 4
+  num_registers: 2
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+voltage_V:
+  start_register: 30001
+  function_code_start_reg: 4
+  num_registers: 2
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+reactive_power_VAR:
+  start_register: 0
+  function_code_start_reg: 3
+  num_registers: 0
+  multiplier: 0.001
+  exponent_register: 0
+  function_code_exp_reg: 3
+  L1:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L2:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L3:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+current_A:
+  start_register: 30007
+  function_code_start_reg: 4
+  num_registers: 2
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+frequency_Hz:
+  start_register: 30071
+  function_code_start_reg: 4
+  num_registers: 2
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4

tools/EVerest-main/modules/HardwareDrivers/PowerMeters/GenericPowermeter/models/Eastron_SDM630-V2.yaml

@@ -0,0 +1,206 @@
+# (<start_register> of length <num_registers>) * <multiplier> * 10^(<exponent_register>)
+#
+# if <start_register> is "0", then this value does not exist in the powermeter
+#
+# use <multiplier> to manually scale (e.g. set to 0.001 if device returns "kWh", but the parameter is "Wh") and <exponent_register> to scale by device value
+#
+# if <exponent_register> is "0", then no exponent register exists and multiplier needs to be set accordingly
+#
+# if measuring AC, the first level of registers is always "total/sum" of a certain value and the L1/2/3 registers are for the distinct phases
+# if measuring DC, only use the first level of registers
+energy_Wh_import:
+  start_register: 30073
+  function_code_start_reg: 4
+  num_registers: 2
+  multiplier: 1000.0
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 30347
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1000.0
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 30349
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1000.0
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 30351
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1000.0
+    exponent_register: 0
+    function_code_exp_reg: 4
+energy_Wh_export:
+  start_register: 30075
+  function_code_start_reg: 4
+  num_registers: 2
+  multiplier: 1000.0
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 30353
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1000.0
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 30355
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1000.0
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 30357
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1000.0
+    exponent_register: 0
+    function_code_exp_reg: 4
+power_W:
+  start_register: 30053
+  function_code_start_reg: 4
+  num_registers: 2
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 30013
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 30015
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 30017
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+voltage_V:
+  start_register: 0
+  function_code_start_reg: 4
+  num_registers: 0
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 30001
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 30003
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 30005
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+reactive_power_VAR:
+  start_register: 30061
+  function_code_start_reg: 4
+  num_registers: 2
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 30025
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 30027
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 30029
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+current_A:
+  start_register: 0
+  function_code_start_reg: 4
+  num_registers: 0
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 30007
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 30009
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 30011
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+frequency_Hz:
+  start_register: 30071
+  function_code_start_reg: 4
+  num_registers: 2
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4

tools/EVerest-main/modules/HardwareDrivers/PowerMeters/GenericPowermeter/models/Eastron_SDM72DM-V2.yaml

@@ -0,0 +1,206 @@
+# (<start_register> of length <num_registers>) * <multiplier> * 10^(<exponent_register>)
+#
+# if <start_register> is "0", then this value does not exist in the powermeter
+#
+# use <multiplier> to manually scale (e.g. set to 0.001 if device returns "kWh", but the parameter is "Wh") and <exponent_register> to scale by device value
+#
+# if <exponent_register> is "0", then no exponent register exists and multiplier needs to be set accordingly
+# 
+# if measuring AC, the first level of registers is always "total/sum" of a certain value and the L1/2/3 registers are for the distinct phases
+# if measuring DC, only use the first level of registers
+energy_Wh_import:
+  start_register: 30073
+  function_code_start_reg: 4
+  num_registers: 2
+  multiplier: 1000.0
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+energy_Wh_export: 
+  start_register: 30075
+  function_code_start_reg: 4
+  num_registers: 2
+  multiplier: 1000.0
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+power_W:
+  start_register: 30053
+  function_code_start_reg: 4
+  num_registers: 2
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 30013
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 30015
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 30017
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+voltage_V:
+  start_register: 0
+  function_code_start_reg: 4
+  num_registers: 0
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 30001
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 30003
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 30005
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+reactive_power_VAR:
+  start_register: 0
+  function_code_start_reg: 3
+  num_registers: 0
+  multiplier: 0.001
+  exponent_register: 0
+  function_code_exp_reg: 3
+  L1:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L2:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L3:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+current_A:
+  start_register: 0
+  function_code_start_reg: 4
+  num_registers: 0
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 30007
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 30009
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 30011
+    function_code_start_reg: 4
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+frequency_Hz:
+  start_register: 30071
+  function_code_start_reg: 4
+  num_registers: 2
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4

tools/EVerest-main/modules/HardwareDrivers/PowerMeters/GenericPowermeter/models/Eastron_SDM72DM.yaml

@@ -0,0 +1,31 @@
+# (<start_register> of length <num_registers>) * <multiplier> * 10^(<exponent_register>)
+#
+# if <start_register> is "0", then this value does not exist in the powermeter
+#
+# use <multiplier> to manually scale (e.g. set to 0.001 if device returns "kWh", but the parameter is "Wh") and <exponent_register> to scale by device value
+#
+# if <exponent_register> is "0", then no exponent register exists and multiplier needs to be set accordingly
+# 
+# if measuring AC, the first level of registers is always "total/sum" of a certain value and the L1/2/3 registers are for the distinct phases
+# if measuring DC, only use the first level of registers
+energy_Wh_import:
+  start_register: 30073
+  function_code_start_reg: 4
+  num_registers: 2
+  multiplier: 1000.0
+  exponent_register: 0
+  function_code_exp_reg: 4
+energy_Wh_export: 
+  start_register: 30075
+  function_code_start_reg: 4
+  num_registers: 2
+  multiplier: 1000.0
+  exponent_register: 0
+  function_code_exp_reg: 4
+power_W:
+  start_register: 30053
+  function_code_start_reg: 4
+  num_registers: 2
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 4

tools/EVerest-main/modules/HardwareDrivers/PowerMeters/GenericPowermeter/models/Klefr_693x-694x.yaml

@@ -0,0 +1,220 @@
+# (<start_register> of length <num_registers>) * <multiplier> * 10^(<exponent_register>)
+#
+# if <start_register> is "0", then this value does not exist in the powermeter
+#
+# use <multiplier> to manually scale (e.g. set to 0.001 if device returns "kWh", but the parameter is "Wh") and <exponent_register> to scale by device value
+#
+# if <exponent_register> is "0", then no exponent register exists and multiplier needs to be set accordingly
+#
+# if measuring AC, the first level of registers is always "total/sum" of a certain value and the L1/2/3 registers are for the distinct phases
+# if measuring DC, only use the first level of registers
+#
+# Usage Example:
+#   powermeter:
+#      module: GenericPowermeter
+#      config_implementation:
+#        main:
+#          model: Klefr_693x-694x
+#          powermeter_device_id: 1
+#          modbus_base_address: 0
+#      connections:
+#        serial_comm_hub:
+#          - module_id: serialcommhub_x7
+#            implementation_id: main
+#
+energy_Wh_import:
+  start_register: 24588
+  function_code_start_reg: 3
+  num_registers: 2
+  multiplier: 1000.0
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 24594
+    function_code_start_reg: 3
+    num_registers: 2
+    multiplier: 1000.0
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 24596
+    function_code_start_reg: 3
+    num_registers: 2
+    multiplier: 1000.0
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 24598
+    function_code_start_reg: 3
+    num_registers: 2
+    multiplier: 1000.0
+    exponent_register: 0
+    function_code_exp_reg: 4
+energy_Wh_export:
+  start_register: 24600
+  function_code_start_reg: 3
+  num_registers: 2
+  multiplier: 1000.0
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 24606
+    function_code_start_reg: 3
+    num_registers: 2
+    multiplier: 1000.0
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 24608
+    function_code_start_reg: 3
+    num_registers: 2
+    multiplier: 1000.0
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 24610
+    function_code_start_reg: 3
+    num_registers: 2
+    multiplier: 1000.0
+    exponent_register: 0
+    function_code_exp_reg: 4
+power_W:
+  start_register: 20498
+  function_code_start_reg: 3
+  num_registers: 2
+  multiplier: 1000.0
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 20500
+    function_code_start_reg: 3
+    num_registers: 2
+    multiplier: 1000.0
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 20502
+    function_code_start_reg: 3
+    num_registers: 2
+    multiplier: 1000.0
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 20504
+    function_code_start_reg: 3
+    num_registers: 2
+    multiplier: 1000.0
+    exponent_register: 0
+    function_code_exp_reg: 4
+voltage_V:
+  start_register: 0
+  function_code_start_reg: 4
+  num_registers: 0
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 20482
+    function_code_start_reg: 3
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 20484
+    function_code_start_reg: 3
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 20486
+    function_code_start_reg: 3
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+reactive_power_VAR:
+  start_register: 20506
+  function_code_start_reg: 3
+  num_registers: 2
+  multiplier: 1000.0
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 20508
+    function_code_start_reg: 3
+    num_registers: 2
+    multiplier: 1000.0
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 20510
+    function_code_start_reg: 3
+    num_registers: 2
+    multiplier: 1000.0
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 20512
+    function_code_start_reg: 3
+    num_registers: 2
+    multiplier: 1000.0
+    exponent_register: 0
+    function_code_exp_reg: 4
+current_A:
+  start_register: 0
+  function_code_start_reg: 4
+  num_registers: 0
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 20492
+    function_code_start_reg: 3
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 20494
+    function_code_start_reg: 3
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 20496
+    function_code_start_reg: 3
+    num_registers: 2
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+frequency_Hz:
+  start_register: 20488
+  function_code_start_reg: 3
+  num_registers: 2
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 4
+  L1:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L2:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4
+  L3:
+    start_register: 0
+    function_code_start_reg: 4
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 4

tools/EVerest-main/modules/HardwareDrivers/PowerMeters/GenericPowermeter/models/template.yaml

@@ -0,0 +1,206 @@
+# (<start_register> of length <num_registers>) * <multiplier> * 10^(<exponent_register>)
+#
+# if <start_register> is "0", then this value does not exist in the powermeter
+#
+# use <multiplier> to manually scale (e.g. set to 0.001 if device returns "kWh", but the parameter is "Wh") and <exponent_register> to scale by device value
+#
+# if <exponent_register> is "0", then no exponent register exists and multiplier needs to be set accordingly
+# 
+# if measuring AC, the first level of registers is always "total/sum" of a certain value and the L1/2/3 registers are for the distinct phases
+# if measuring DC, only use the first level of registers
+energy_Wh_import:
+  start_register: 0
+  function_code_start_reg: 3
+  num_registers: 0
+  multiplier: 0.001
+  exponent_register: 0
+  function_code_exp_reg: 3
+  L1:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L2:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L3:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+energy_Wh_export:
+  start_register: 0
+  function_code_start_reg: 3
+  num_registers: 0
+  multiplier: 0.001
+  exponent_register: 0
+  function_code_exp_reg: 3
+  L1:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L2:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L3:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+power_W:
+  start_register: 0
+  function_code_start_reg: 3
+  num_registers: 0
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 3
+  L1:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L2:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L3:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+voltage_V:
+  start_register: 0
+  function_code_start_reg: 3
+  num_registers: 0
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 3
+  L1:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L2:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L3:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+reactive_power_VAR:
+  start_register: 0
+  function_code_start_reg: 3
+  num_registers: 0
+  multiplier: 0.001
+  exponent_register: 0
+  function_code_exp_reg: 3
+  L1:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L2:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L3:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+current_A:
+  start_register: 0
+  function_code_start_reg: 3
+  num_registers: 0
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 3
+  L1:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L2:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L3:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+frequency_Hz:
+  start_register: 0
+  function_code_start_reg: 3
+  num_registers: 0
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 3
+  L1:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L2:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L3:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3

tools/EVerest-main/modules/HardwareDrivers/PowerMeters/GenericPowermeter/models/test_dummy.yaml

@@ -0,0 +1,206 @@
+# (<start_register> of length <num_registers>) * <multiplier> * 10^(<exponent_register>)
+#
+# if <start_register> is "0", then this value does not exist in the powermeter
+#
+# use <multiplier> to manually scale (e.g. set to 0.001 if device returns "kWh", but the parameter is "Wh") and <exponent_register> to scale by device value
+#
+# if <exponent_register> is "0", then no exponent register exists and multiplier needs to be set accordingly
+# 
+# if measuring AC, the first level of registers is always "total/sum" of a certain value and the L1/2/3 registers are for the distinct phases
+# if measuring DC, only use the first level of registers
+energy_Wh_import:
+  start_register: 40002
+  function_code_start_reg: 3
+  num_registers: 1
+  multiplier: 0.001
+  exponent_register: 40003
+  function_code_exp_reg: 4
+  L1:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L2:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L3:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+energy_Wh_export:
+  start_register: 0
+  function_code_start_reg: 3
+  num_registers: 0
+  multiplier: 0.001
+  exponent_register: 0
+  function_code_exp_reg: 3
+  L1:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L2:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L3:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+power_W:
+  start_register: 0
+  function_code_start_reg: 3
+  num_registers: 0
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 3
+  L1:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L2:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L3:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+voltage_V:
+  start_register: 0
+  function_code_start_reg: 3
+  num_registers: 0
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 3
+  L1:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L2:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L3:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+reactive_power_VAR:
+  start_register: 0
+  function_code_start_reg: 3
+  num_registers: 0
+  multiplier: 0.001
+  exponent_register: 0
+  function_code_exp_reg: 3
+  L1:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L2:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L3:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+current_A:
+  start_register: 0
+  function_code_start_reg: 3
+  num_registers: 0
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 3
+  L1:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L2:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L3:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+frequency_Hz:
+  start_register: 0
+  function_code_start_reg: 3
+  num_registers: 0
+  multiplier: 1
+  exponent_register: 0
+  function_code_exp_reg: 3
+  L1:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L2:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3
+  L3:
+    start_register: 0
+    function_code_start_reg: 3
+    num_registers: 0
+    multiplier: 1
+    exponent_register: 0
+    function_code_exp_reg: 3